web-dev-qa-db-fra.com

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

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

Sont-ils tous les deux valables? Est-ce qu'on préfère pour une raison quelconque?

pythonlist
140
qazwsx

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

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

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

tandis 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 est hashable, ce qui signifie que vous pouvez l'utiliser comme clé d'un dictionnaire, entre autres choses. 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 beaucoup de personnes l’ont souligné, vous pouvez ajouter des nuplets ensemble. Par exemple:

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

Cependant, cela ne signifie pas que les n-uplets sont mutables . Dans l'exemple ci-dessus, un nouveau Tuple est construit en additionnant les deux n-uplets en tant qu'arguments. Le tuple d'origine n'est pas modifié. Pour démontrer cela, considérez les points suivants:

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

Tandis que si vous construisiez ce même exemple avec une liste, y serait également mis à jour:

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

Ce ne sont pas des listes, elles sont une liste et un tuple. Vous pouvez lire sur tuples dans le tutoriel Python. Bien que vous puissiez modifier des listes, cela n’est pas possible avec des n-uplets.

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
4
Gandaro

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

Jetez un coup d'œil à la section Structures de données du tutoriel et à la section Types de séquence de la documentation.

2
NPE

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

2
0605002

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).

2
Saurav Sahu

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

Alors que la syntaxe entre parenthèses 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?

1
xyzzy71