Quelle est la différence entre les listes entre crochets et parenthèses en Python?

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

Sont-ils tous les deux valides? Est-ce que l'un est préféré pour une raison quelconque?

Les crochets sont des listes tandis que les parenthèses sont des tuples .

Une liste est modifiable, ce qui signifie que vous pouvez modifier son contenu:

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

alors que les tuples ne sont pas:

>>> 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'

L'autre différence principale est qu'un tuple peut être haché, ce qui signifie que vous pouvez l'utiliser comme clé d'un dictionnaire, entre autres. Par exemple:

>>> 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'

Notez que, comme de nombreuses personnes l'ont souligné, vous pouvez ajouter des tuples ensemble. Par exemple:

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

Cependant, cela ne signifie pas que les tuples sont mutables . Dans l'exemple ci-dessus, un nouveau tuple est construit en additionnant les deux tuples comme arguments. Le tuple d'origine n'est pas modifié. Pour illustrer cela, tenez compte des éléments suivants:

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

Alors que, si vous deviez construire ce même exemple avec une liste, yserait également mis à jour:

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

Une différence intéressante:

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)

Une virgule doit être incluse dans un tuple même s'il ne contient qu'une seule valeur. par exemple (1,)au lieu de (1).

Ce ne sont pas des listes, ce sont une liste et un tuple. Vous pouvez en savoir plus sur les tuples dans le didacticiel Python. Bien que vous puissiez muter des listes, cela n'est pas possible avec les tuples.

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

Une autre différence entre les crochets et les parenthèses est que les crochets peuvent décrire une compréhension de liste, par exemple [x for x in y]

Alors que la syntaxe parenthétique correspondante spécifie un générateur de tuple :(x for x in y)

Vous pouvez obtenir une compréhension de tuple en utilisant: tuple(x for x in y)

Voir: Pourquoi n'y a-t-il pas de compréhension de tuple en Python?

Le premier est une liste, le second est un tuple. Les listes sont modifiables, les tuples ne le sont pas.

Jetez un œil à la section Structures de données du didacticiel et à la section Types de séquence de la documentation.

Les éléments séparés par des virgules entre (et )sont des tuples, ceux entourés par [et ]sont des lists.