¿Cuál es la diferencia entre las listas entre corchetes y paréntesis en Python?

4 minutos de lectura

avatar de usuario
qazwsx

>>> x=[1,2]
>>> x[1]
2
>>> x=(1,2)
>>> x[1]
2

¿Son ambos válidos? ¿Se prefiere uno por alguna razón?

  • Solo para su información: hay una diferencia más profunda entre (i for i in ...) y [i for i in ...].

    –Rik Poggi

    17 de enero de 2012 a las 21:28

  • @RikPoggi ¿Cuál es la profunda diferencia? ¿Podría por favor elaborar?

    – qazwsx

    17 de enero de 2012 a las 21:49

  • El primero es un generador de expresión y el segundo es un lista de comprensión. Puede encontrar algunas informaciones aquí: Tutorial oficial sobre comprensión de listas, PEP 289. Y aquí en algunas preguntas del sistema operativo: Expresiones del generador frente a Comprensión de listas, comprensión del generador.

    –Rik Poggi

    17 de enero de 2012 a las 22:08

avatar de usuario
jterraza

los corchetes son liza mientras que los paréntesis son tuplas.

Una lista es mutable, lo que significa que puede cambiar su contenido:

>>> x = [1,2]
>>> x.append(3)
>>> x
[1, 2, 3]

mientras que las tuplas no lo son:

>>> x = (1,2)
>>> x
(1, 2)
>>> x.append(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'

La otra diferencia principal es que una tupla es hashable, lo que significa que puede usarla como clave para un diccionario, entre otras cosas. Por ejemplo:

>>> x = (1,2)
>>> y = [1,2]
>>> z = {}
>>> z[x] = 3
>>> z
{(1, 2): 3}
>>> z[y] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Tenga en cuenta que, como muchas personas han señalado, puede agregar tuplas juntas. Por ejemplo:

>>> x = (1,2)
>>> x += (3,)
>>> x
(1, 2, 3)

Sin embargo, esto no significa que las tuplas sean mutables. En el ejemplo anterior, un nuevo tupla se construye sumando las dos tuplas como argumentos. La tupla original no se modifica. Para demostrar esto, considere lo siguiente:

>>> x = (1,2)
>>> y = x
>>> x += (3,)
>>> x
(1, 2, 3)
>>> y
(1, 2)

Mientras que, si tuviera que construir este mismo ejemplo con una lista, y también se actualizaría:

>>> x = [1, 2]
>>> y = x
>>> x += [3]
>>> x
[1, 2, 3]
>>> y
[1, 2, 3]

  • ejemplos buenos pero simples para enumerar las diferencias. ¡Gracias!

    – Dra. Essen

    13 de enero de 2020 a las 10:50

  • para el ejemplo anterior de ‘y=x’, list y tuple se comportan de la misma manera ahora (verificado en python3.8.5)

    – Youjun Hu

    15 de agosto de 2020 a las 9:11

avatar de usuario
saurav sahu

Una diferencia interesante:

lst=[1]
print lst          // prints [1]
print type(lst)    // prints <type 'list'>

notATuple=(1)
print notATuple        // prints 1
print type(notATuple)  // prints <type 'int'>
                                         ^^ instead of tuple(expected)

Se debe incluir una coma en una tupla incluso si contiene un solo valor. p.ej (1,) en vez de (1).

  • Gracias. Esto es lo que estaba buscando. El código que vi tenía un (list1 + list2 + list3) y devolvió una lista, no una tupla.

    – Josué Stafford

    19 oct 2018 a las 17:57

No son listas, son una lista y una tupla. Puedes leer sobre tuplas en el tutorial de Python. Si bien puede mutar listas, esto no es posible con tuplas.

In [1]: x = (1, 2)

In [2]: x[0] = 3
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/home/user/<ipython console> in <module>()

TypeError: 'tuple' object does not support item assignment

avatar de usuario
xyzzy71

Otra diferencia entre corchetes y paréntesis es que los corchetes pueden describir la comprensión de una lista, por ejemplo [x for x in y]

Mientras que la sintaxis entre paréntesis correspondiente especifica una tupla generador: (x for x in y)

Puede obtener una comprensión de tupla usando: tuple(x for x in y)

Ver: ¿Por qué no hay comprensión de tuplas en Python?

La primera es una lista, la segunda es una tupla. Las listas son mutables, las tuplas no.

Echa un vistazo a la Estructuras de datos sección del tutorial, y la Tipos de secuencia sección de la documentación.

Elementos separados por comas encerrados por ( y ) son tuples, los encerrados por [ and ] son lists.

(gracias a Robert por la aclaración, a continuación se muestra solo en caso de usar listas de comprensión:)

! otro diferencia muy importante es que entre paréntesis tendremos un generador y así el el consumo de memoria es mucho menor en comparación con la lista con corchetes, especialmente cuando se trata de listas grandes: generador consumirá no solo significativamente menos memoria, sino también llevará mucho menos tiempo porque no necesitarás objetos preconstruidos en la lista

  • ¿Estás seguro de eso? ¿Puedes editar tu respuesta y explicar más por qué hay un generador? Todas las demás respuestas dicen que (...) es una tupla vs [...] siendo una lista. AFAIK un generador es una función, pero las preguntas tienen constantes.

    – Roberto

    16/09/2021 a las 20:52


¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad