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

Question

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

Les deux sont-ils valides? Est-ce qu'un est préféré pour une raison quelconque?

Answer 1

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

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

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

tandis que les tuples ne le sont pas :

>>> x = (1,2)
>>> x
(1, 2)
>>> x.append(3)
Traceback (most recent call last):
  File "", line 1, in 
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 une clé pour 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 "", line 1, in 
TypeError: unhashable type: 'list'

---

Remarquez que, comme beaucoup l'ont souligné, vous pouvez ajouter des tuples ensemble. Par exemple :

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

Cependant, ceci ne signifie pas que les tuples sont modifiables. Dans l'exemple ci-dessus, un nouveau tuple est construit en ajoutant les deux tuples comme arguments. Le tuple original n'est pas modifié. Pour le démontrer, considérez ce qui suit :

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

Alors que, si vous deviez construire le 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]

Answer 2

Une différence intéressante :

lst=[1]
print lst          // affiche [1]
print type(lst)    // affiche 

notATuple=(1)
print notATuple        // affiche 1
print type(notATuple)  // affiche 
                                         ^^ au lieu de tuple (attendu)

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

Answer 3

Ils ne sont pas des listes, ils sont une liste et un tuple. Vous pouvez en apprendre davantage sur les tuples dans le tutoriel Python. Alors que vous pouvez 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/ in ()

TypeError: 'tuple' object does not support item assignment

Answer 4

Une autre façon dont les crochets et les parenthèses diffèrent 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 ?

Answer 5

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

Jetez un œil à la section Structures de Données du tutoriel, et à la section Types de Séquence de la documentation.