Quelle est la différence entre les listes et les tuples?

Question

Quelle est la différence?

Quels sont les avantages/inconvénients des n-uplets/listes?

nikow · Accepted Answer

Outre que les n-uplets sont immuables, il existe également une distinction sémantique qui devrait guider leur utilisation. Les tuples sont des structures de données hétérogènes (c'est-à-dire que leurs entrées ont des significations différentes), tandis que les listes sont des séquences homogènes. Les tuples ont une structure, les listes ont un ordre.

L'utilisation de cette distinction rend le code plus explicite et compréhensible.

Un exemple serait les paires de page et numéro de ligne pour référencer les emplacements dans un livre, par exemple:

my_location = (42, 11) # page number, line number

Vous pouvez ensuite l'utiliser comme clé dans un dictionnaire pour stocker des notes sur des emplacements. Une liste, par contre, pourrait être utilisée pour stocker plusieurs emplacements. Naturellement, on peut vouloir ajouter ou supprimer des emplacements de la liste, il est donc logique que les listes soient mutables. D'autre part, il n'est pas logique d'ajouter ou de supprimer des éléments d'un emplacement existant - les n-uplets sont donc immuables.

Il peut arriver que vous souhaitiez modifier des éléments dans un emplacement existant Tuple, par exemple lors d'une itération à travers les lignes d'une page. Mais l’immuabilité de Tuple vous oblige à créer un nouveau Tuple de localisation pour chaque nouvelle valeur. Cela semble gênant, mais utiliser des données immuables comme celle-ci est la pierre angulaire des types de valeur et des techniques de programmation fonctionnelle, ce qui peut présenter des avantages substantiels.

Il existe des articles intéressants sur cette question, par exemple "Les tuples Python ne sont pas que des listes constantes" ou "Comprendre les tuples vs listes en Python" . La documentation officielle Python mentionne également ceci

"Les tuples sont immuables et contiennent généralement une séquence hétérogène ...".

Dans un langage statiquement typé comme Haskell , les valeurs dans un tuple ont généralement des types différents et la longueur du tuple doit être fixée. Dans une liste, les valeurs ont toutes le même type et la longueur n'est pas fixe. Donc, la différence est très évidente.

Enfin, il y a le namedtuple en Python, ce qui est logique car un tuple est déjà supposé avoir une structure. Ceci souligne l’idée que les tuples sont une alternative légère aux classes et aux instances.

Nikita · Answer

Différence entre liste et tuple

Littéral
```
someTuple = (1,2) someList = [1,2] 
```
Taille
```
a = Tuple(range(1000)) b = list(range(1000)) a.__sizeof__() # 8024 b.__sizeof__() # 9088 
```
En raison de la taille réduite d'une opération Tuple, l'opération devient un peu plus rapide, mais il n'y a pas beaucoup de choses à dire jusqu'à ce que vous ayez un grand nombre d'éléments.
Opérations autorisées
```
b = [1,2] b[0] = 3 # [3, 2] a = (1,2) a[0] = 3 # Error 
```
Cela signifie également que vous ne pouvez pas supprimer un élément ou trier un tuple. Cependant, vous pouvez ajouter un nouvel élément à la fois à la liste et au tuple, à la seule différence que vous modifierez l'id du tuple en ajoutant un élément
```
a = (1,2) b = [1,2] id(a) # 140230916716520 id(b) # 748527696 a += (3,) # (1, 2, 3) b += [3] # [1, 2, 3] id(a) # 140230916878160 id(b) # 748527696 
```
Utilisation

Comme une liste est modifiable, elle ne peut pas être utilisée comme clé dans un dictionnaire, alors qu'un tuple peut être utilisé.
```
a = (1,2) b = [1,2] c = {a: 1} # OK c = {b: 1} # Error 
```
Hashable Le tuple est hashable alors que la liste ne l’est pas. Les fonctions de hachage renvoient la valeur de hachage de l'objet, s'il en a une.

dan-gph · Answer

Si vous alliez vous promener, vous pouvez noter vos coordonnées à tout moment dans un (x,y) Tuple.

Si vous souhaitez enregistrer votre trajet, vous pouvez ajouter votre position toutes les quelques secondes à une liste.

Mais vous ne pouviez pas le faire dans l'autre sens.

Dave Webb · Answer

La principale différence est que les tuples sont immuables. Cela signifie que vous ne pouvez pas modifier les valeurs d'un tuple une fois que vous l'avez créé.

Donc, si vous devez changer les valeurs, utilisez une liste.

Avantages pour tuples:

Légère amélioration des performances.
Comme un tuple est immuable, il peut être utilisé comme clé dans un dictionnaire.
Si vous ne pouvez pas le changer, vous ne le ferez pas non plus avec quelqu'un d'autre, ce qui signifie que vous n'avez pas à vous soucier des fonctions de l'API, etc.

duffymo · Answer

Les listes sont modifiables; les tuples ne le sont pas.

De docs.python.org/2/tutorial/datastructures.html

Les tuples sont immuables et contiennent généralement une séquence hétérogène d'éléments auxquels on accède par décompression (voir plus loin dans cette section) ou par indexation (ou même par attribut dans le cas de nommés). Les listes sont modifiables et leurs éléments sont généralement homogènes et sont accessibles par itération sur la liste.

Shep · Answer

C'est été mentionné que la différence est en grande partie sémantique: les gens s'attendent à ce qu'un tuple et une liste représentent des informations différentes. Mais cela va plus loin qu'une ligne directrice; En fait, certaines bibliothèques se comportent différemment en fonction de ce qu'elles ont été transmises. Prenons NumPy par exemple (copié de n autre post où je demande d'autres exemples):

>>> import numpy as np >>> a = np.arange(9).reshape(3,3) >>> a array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> idx = (1,1) >>> a[idx] 4 >>> idx = [1,1] >>> a[idx] array([[3, 4, 5], [3, 4, 5]])

Le fait est que NumPy ne fait peut-être pas partie de la bibliothèque standard, il s’agit d’une bibliothèque majeure Python, et dans les listes NumPy et les tuples sont des choses complètement différentes.

Srinivas Reddy Thatiparthy · Answer

Les listes sont destinées aux boucles, les n-uplets aux structures: "%s %s" %Tuple.

Les listes sont généralement homogènes, les n-uplets sont généralement hétérogènes.

Les listes sont à longueur variable, les n-uplets à longueur fixe.

Afflatus · Answer

Voici un exemple de listes Python:

my_list = [0,1,2,3,4] top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

Voici un exemple de Python Tuple:

my_Tuple = (a,b,c,d,e) celebrity_Tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

Les listes et les nuplets Python sont similaires en ce qu'ils sont tous deux des collections ordonnées de valeurs. Outre la faible différence, les listes sont créées à l'aide de crochets "[..., ...]" et de tuples à l'aide de parenthèses "(..., ...)", le principal élément technique "codé en dur dans PythonLa différence entre elles réside dans le fait que les éléments d’un tuple sont immuables, alors que les listes sont mutables (... ainsi, seuls les n-uplets peuvent être hachés et peuvent être utilisés comme clés de dictionnaire/dièse!). Cela donne lieu à des différences quant à la manière dont ils peuvent ou ne peuvent pas être utilisés (imposée a priori par la syntaxe) et à des différences quant à la manière dont les gens choisissent de les utiliser (encouragés en tant que "meilleures pratiques", a posteriori, voici ce que intelligents font les programmeurs). La principale différence a posteriori dans la différenciation entre l'utilisation des n-uplets et celle des listes réside dans ce que signifie les gens donnent à l'ordre des éléments.

Pour les tuples, "ordre" ne signifie rien de plus qu'une "structure" spécifique pour la conservation des informations. Les valeurs trouvées dans le premier champ peuvent facilement être commutées dans le second, car chacune fournit des valeurs sur deux dimensions ou échelles différentes. Ils fournissent des réponses à différents types de questions et sont typiquement de la forme: pour un objet/sujet donné, quels sont ses attributs? L'objet/sujet reste constante, les attributs diffèrent.

Pour les listes, 'ordre' signifie une séquence ou une directionnalité. Le deuxième élément DOIT venir après le premier élément car il se positionne à la 2e place sur la base d'une échelle ou d'une dimension particulière et commune. Les éléments sont pris dans leur ensemble et fournissent la plupart du temps des réponses à une seule question typique de la forme pour un attribut donné, comment ces objets/sujets se comparent-ils? L’attribut reste constant, l’objet/le sujet est différent.

Il existe d'innombrables exemples de personnes dans la culture populaire et de programmeurs qui ne se conforment pas à ces différences, et d'innombrables personnes pourraient utiliser une fourchette à salade pour leur plat principal. À la fin de la journée, ça va et les deux peuvent généralement faire le travail.

Pour résumer certains des détails les plus fins

Similarités:

Duplicates - Les deux n-uplets et les listes permettent les doublons
Indexation, sélection et découpage en tranches - Les deux n-uplets et les listes indexent à l'aide de valeurs entières trouvées entre parenthèses. Donc, si vous voulez les 3 premières valeurs d’une liste ou d’un tuple donné, la syntaxe serait la même:
```
>>> my_list[0:3] [0,1,2] >>> my_Tuple[0:3] [a,b,c] 
```
Comparaison et tri - Deux n-uplets ou deux listes sont comparés par leur premier élément et, en cas d'égalité, par le second élément, etc. sur. Aucune autre attention n'est accordée aux éléments suivants, car les éléments précédents montrent une différence.
```
>>> [0,2,0,0,0,0]>[0,0,0,0,0,500] True >>> (0,2,0,0,0,0)>(0,0,0,0,0,500) True 
```

Différences: - A priori, par définition

Syntaxe - Les listes utilisent [], les n-uplets utilisent ()

Mutabilité - Les éléments d'une liste donnée sont modifiables, les éléments d'un tuple donné ne sont PAS mutables.

# Lists are mutable: >>> top_rock_list ['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son'] >>> top_rock_list[1] 'Kashmir' >>> top_rock_list[1] = "Stairway to Heaven" >>> top_rock_list ['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son'] # Tuples are NOT mutable: >>> celebrity_Tuple ('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead') >>> celebrity_Tuple[5] 'Dead' >>> celebrity_Tuple[5]="Alive" Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'Tuple' object does not support item assignment

Hashtables (Dictionnaires) - Comme les hashtables (dictionnaires) exigent que leurs clés soient déchiffrables et donc immuables, seuls les n-uplets peuvent servir de clés de dictionnaire, pas de listes.

#Lists CAN'T act as keys for hashtables(dictionaries) >>> my_dict = {[a,b,c]:"some value"} Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list' #Tuples CAN act as keys for hashtables(dictionaries) >>> my_dict = {("John","Wayne"): 90210} >>> my_dict {('John', 'Wayne'): 90210}

Différences - à posteriori, en usage

Homo vs hétérogénéité des éléments - En règle générale, les objets de la liste sont homogènes et les objets Tuple sont hétérogènes. C'est-à-dire que les listes sont utilisées pour des objets/sujets du même type (comme tous les candidats à la présidentielle, toutes les chansons ou tous les coureurs), alors que les choix ne sont pas forcés, alors que les tuples sont davantage utilisés pour des objets hétérogènes.
Bouclage ou structure - Bien que les deux autorisent le bouclage (pour x dans ma_liste ...), cela n'a de sens que de le faire pour une liste. Les n-uplets sont plus appropriés pour structurer et présenter des informations (% s% s résidant dans% s est un% s et actuellement% s% ("John", "Wayne", 90210, "Acteur", "Morte"))

user2436485 · Answer

Les valeurs de liste peuvent être changées à tout moment mais les valeurs de tuples ne peuvent pas être changées.

Le avantages et inconvénients dépend de l'utilisation. Si vous possédez des données que vous ne souhaitez jamais modifier, vous devez utiliser Tuple, sinon la liste est la meilleure option.

pquers · Answer

Les listes sont destinées à être des séquences homogènes, tandis que les nuplets sont des structures de données hétérogènes.

iNet · Answer

Différence entre liste et tuple

Les tuples et les listes sont des types de séquence apparemment similaires en Python.

syntaxe littérale

Nous utilisons des parenthèses () pour construire des n-uplets et des crochets [ ] pour obtenir une nouvelle liste. En outre, nous pouvons utiliser un appel du type approprié pour obtenir la structure requise - Tuple ou liste.
```
someTuple = (4,6) someList = [2,6] 
```
mutabilité

Les tuples sont immuables, alors que les listes sont mutables. Ce point est la base pour les suivants.
tilisation de la mémoire

En raison de la mutabilité, vous avez besoin de plus de mémoire pour les listes et de moins de mémoire pour les n-uplets.
extension

Vous pouvez ajouter un nouvel élément à la fois aux n-uplets et aux listes, à la seule différence que l'id du tuple sera modifié (c'est-à-dire que nous aurons un nouvel objet).
hachage

Les tuples sont hashable et les listes non. Cela signifie que vous pouvez utiliser un tuple comme clé dans un dictionnaire. La liste ne peut pas être utilisée comme clé dans un dictionnaire, alors qu'un tuple peut être utilisé
```
tup = (1,2) list_ = [1,2] c = {tup : 1} # ok c = {list_ : 1} # error 
```
Sémantique

Ce point concerne davantage les meilleures pratiques. Vous devez utiliser des nuplets en tant que structures de données hétérogènes, tandis que les listes sont des séquences homogènes.

Daksh · Answer

Comme les gens ont déjà répondu ici que tuples sont immuables alors que lists sont mutables, mais il y a un aspect important de l'utilisation des n-uplets dont nous devons nous souvenir.

Si le Tuple contient un list ou un dictionary à l'intérieur, ceux-ci peuvent être modifiés même si le Tuple lui-même est immuable.

Par exemple, supposons que nous avons un tuple qui contient une liste et un dictionnaire comme

my_Tuple = (10,20,30,[40,50],{ 'a' : 10})

nous pouvons changer le contenu de la liste comme

my_Tuple[3][0] = 400 my_Tuple[3][1] = 500

ce qui fait que le nouveau Tuple ressemble

(10, 20, 30, [400, 500], {'a': 10})

nous pouvons également changer le dictionnaire à l'intérieur de Tuple comme

my_Tuple[4]['a'] = 500

qui fera le tuple dans son ensemble ressemble

(10, 20, 30, [400, 500], {'a': 500})

Cela est dû au fait que list et dictionary sont les objets et que ces objets ne changent pas, mais que le contenu est dirigé vers lui.

Donc, la Tuple reste immuable sans aucune exception

Antti Haapala · Answer

Le PEP 484 - Indications de type indique que les types d'éléments d'un Tuple peuvent être typés individuellement; afin que vous puissiez dire Tuple[str, int, float]; mais une classe list avec List ne peut prendre qu'un seul paramètre de type: List[str], ce qui laisse à penser que la différence entre les 2 réside en fait dans le fait que le premier est hétérogène, alors que le dernier est intrinsèquement homogène. .

En outre, la bibliothèque standard utilise principalement le Tuple en tant que valeur de retour à partir de ces fonctions standard où le C renvoie un struct.

Albus Dumbledore · Answer

Une citation de la documentation sur 5.3. Tuples et séquences :

Bien que les tuples puissent sembler similaires aux listes, ils sont souvent utilisés dans différentes situations et à différentes fins. Les tuples sont immuables et contiennent généralement une séquence hétérogène d'éléments accessible via décompressant (voir plus loin dans cette section) ou indexé (ou même par attribut dans le cas de tubes nommés). Les listes sont mutables et leurs éléments sont généralement homogènes et sont accessibles par itérant sur la liste.

Lorem Ipsum Dolor · Answer

Tout d'abord, il s'agit d'objets non scalaires (également appelés objets composés) en Python.

Tuples, séquence ordonnée d'éléments (pouvant contenir n'importe quel objet sans problème d'aliasing)
- Immuable (Tuple, int, float, str)
- Concaténation à l'aide de + (un nouveau tuple sera créé bien sûr)
- Indexage
- Tranchage
- Singleton (3,) # -> (3) au lieu de (3) # -> 3
Liste (Tableau dans d'autres langues), séquence de valeurs ordonnée
- Mutable
- Singleton [3]
- Clonage new_array = Origin_array[:]
- Compréhension de liste [x**2 for x in range(1,7)] vous donne [1,4,9,16,25,36] (illisible)

L'utilisation de list peut également être à l'origine d'un bogue d'aliasing (deux chemins distincts pointant vers le même objet).

Rahul Sawriya · Answer

Les listes sont modifiables et les n-uplets sont immuables. Prenons juste cet exemple.

a = ["1", "2", "ra", "sa"] #list b = ("1", "2", "ra", "sa") #Tuple

Maintenant changez les valeurs d'index de list et de Tuple.

a[2] = 1000 print a #output : ['1', '2', 1000, 'sa'] b[2] = 1000 print b #output : TypeError: 'Tuple' object does not support item assignment.

Il est donc prouvé que le code suivant est invalide avec Tuple, car nous avons tenté de mettre à jour un Tuple, ce qui n'est pas autorisé.