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

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

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

Los corchetes son listas, 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 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 puedes 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 han señalado muchas personas, 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, se construye una nueva tupla 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 construyera este mismo ejemplo con una lista, ytambién se actualizaría:

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

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. por ejemplo, en (1,)lugar de (1).

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

Otra forma en que los paréntesis y los paréntesis difieren es que los corchetes pueden describir una comprensión de la lista, por ej. [x for x in y]

Mientras que la sintaxis entre paréntesis correspondiente especifica un generador de tuplas :(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?

El primero es una lista, el segundo es una tupla. Las listas son mutables, las tuplas no.

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

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