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

Quelle est la différence?

Quels sont les avantages / inconvénients des tuples / listes?

Outre que les tuples 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 des paires de pages et de numéros 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 pourrait en revanche ê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'un autre côté, il n'est pas logique d'ajouter ou de supprimer des éléments d'un emplacement existant - les tuples sont donc immuables.

Il peut y avoir des situations où vous souhaitez modifier des éléments dans un tuple d'emplacement existant, par exemple lors de l'itération à travers les lignes d'une page. Mais l'immuabilité du tuple vous oblige à créer un nouveau tuple d'emplacement pour chaque nouvelle valeur. Cela semble gênant à première vue, mais l'utilisation de données immuables comme celle-ci est une pierre angulaire des types de valeur et des techniques de programmation fonctionnelle, qui peuvent avoir des avantages substantiels.

Il y a quelques articles intéressants sur cette question, par exemple "Les tuples Python ne sont pas seulement des listes constantes" ou "Comprendre les tuples vs les listes en Python" . La documentation officielle de Python le mentionne également

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

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

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

Différence entre la liste et le tuple

1. Littéral

   someTuple = (1,2)
   someList  = [1,2] 

2. Taille

   a = tuple(range(1000))
   b = list(range(1000))
   
   a.__sizeof__() # 8024
   b.__sizeof__() # 9088

   En raison de la taille plus petite d'une opération de tuple, elle devient un peu plus rapide, mais pas tant que ça jusqu'à ce que vous ayez un grand nombre d'éléments.

3. 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 liste et au tuple, à la seule différence que, puisque le tuple est immuable, vous n'ajoutez pas vraiment un élément mais vous créez un nouveau tuple, donc l'id de va changer

   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

4. Usage

   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

Si vous vous promenez, vous pouvez noter vos coordonnées à tout instant 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 faire l'inverse.

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 modifier les valeurs, utilisez une liste.

Avantages pour les tuples:

1. Légère amélioration des performances.
2. Un tuple étant immuable, il peut être utilisé comme clé dans un dictionnaire.
3. Si vous ne pouvez pas le changer, personne d'autre ne peut le faire, c'est-à-dire que vous n'avez pas à vous soucier des fonctions de l'API, etc., changer votre tuple sans qu'on vous le demande.

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

Depuis 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 accessibles via le déballage (voir plus loin dans cette section) ou l'indexation (ou même par attribut dans le cas des couples nommés). Les listes sont modifiables et leurs éléments sont généralement homogènes et sont accessibles en itérant sur la liste.

Il a été mentionné que la différence est largement 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; certaines bibliothèques se comportent en fait différemment en fonction de ce qu'elles sont transmises. Prenez NumPy par exemple (copié d' un autre post où je demande plus d'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, bien que NumPy ne fasse pas partie de la bibliothèque standard, c'est une bibliothèque Python majeure , et dans les listes et tuples NumPy, il y a des choses complètement différentes.

Les listes sont pour le bouclage, les tuples sont pour les structures ie "%s %s" %tuple .

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

Les listes sont de longueur variable, les tuples sont de longueur fixe.

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 tuple Python:

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

Les listes et les tuples Python sont similaires en ce qu'ils sont tous deux des collections ordonnées de valeurs. Outre la faible différence que les listes sont créées en utilisant les crochets "[..., ...]" et les tuples en utilisant les parenthèses "(..., ...)", la principale différence technique "codée en dur en syntaxe Python" entre eux est que les éléments d'un tuple particulier sont immuables alors que les listes sont mutables (... donc seuls les tuples sont lavables et peuvent être utilisés comme dictionnaire / clé de hachage!). Cela donne lieu à des différences dans la façon dont elles peuvent ou ne peuvent pas être utilisées (imposées a priori par la syntaxe) et à des différences dans la façon dont les gens choisissent de les utiliser (encouragées comme «meilleures pratiques», a posteriori, c'est ce que les intelligents programmeurs ). les gens donnent à l'ordre des éléments.

Pour les tuples, «l'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 champ car chacune fournit des valeurs sur deux dimensions ou échelles différentes. Ils fournissent des réponses à différents types de questions et sont généralement de la forme: pour un objet / sujet donné, quels sont ses attributs? L'objet / sujet reste constant, 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 est positionné à la 2e place en fonction d'une échelle ou dimension particulière et commune. Les éléments sont pris dans leur ensemble et fournissent pour la plupart des réponses à une seule question typiquement de la forme, pour un attribut donné, comment ces objets / sujets se comparent-ils? L'attribut reste constant, l'objet / sujet diffère.

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

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

Similitudes:

1. Doublons - Les tuples et les listes permettent les doublons

2. Indexation, sélection et découpage - Les tuples et les listes indexent en utilisant des valeurs entières trouvées entre crochets. 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]

3. Comparaison et tri - Deux tuples ou deux listes sont tous deux comparés par leur premier élément, et s'il y a une égalité, alors par le deuxième élément, et ainsi de suite. Aucune autre attention n'est accordée aux éléments suivants après que 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

1. Syntaxe - Les listes utilisent [], les tuples utilisent ()

2. Mutabilité - Les éléments d'une liste donnée sont mutables, 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

3. Hashtables (Dictionaries) - Comme les hashtables (dictionaries) exigent que ses clés soient lavables et donc immuables, seuls les tuples peuvent agir comme des clés de dictionnaire, pas des 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 - A posteriori, dans l'usage

1. Homo vs hétérogénéité des éléments - En général, les objets de liste sont homogènes et les objets tuple sont hétérogènes. Autrement dit, les listes sont utilisées pour des objets / sujets du même type (comme tous les candidats à la présidentielle, ou toutes les chansons, ou tous les coureurs) alors que même si ce n'est pas forcé par), alors que les tuples sont plus pour des objets hétérogènes.

2. Boucle vs Structures - Bien que les deux permettent la boucle (pour x dans ma_liste ...), cela n'a vraiment de sens que de le faire pour une liste. Les tuples 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", "Mort"))

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

Les avantages et les inconvénients dépendent de l'utilisation. Si vous avez de telles données que vous ne voulez jamais changer, vous devez utiliser le tuple, sinon la liste est la meilleure option.

Différence entre la liste et le tuple

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

1. Syntaxe littérale

   Nous utilisons des parenthèses ( ) pour construire des tuples et des crochets [ ]pour obtenir une nouvelle liste. En outre, nous pouvons utiliser l'appel du type approprié pour obtenir la structure requise - tuple ou list.

   someTuple = (4,6)
   someList  = [2,6] 

2. Mutabilité

   Les tuples sont immuables, tandis que les listes sont mutables. Ce point est la base pour les suivants.

3. Utilisation de la mémoire

   En raison de la mutabilité, vous avez besoin de plus de mémoire pour les listes et moins de mémoire pour les tuples.

4. Extension

   Vous pouvez ajouter un nouvel élément aux tuples et aux listes avec la seule différence que l'identifiant du tuple sera changé (c'est-à-dire que nous aurons un nouvel objet).

5. Hachage

   Les tuples sont lavables et les listes ne le sont pas. 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

6. Sémantique

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

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

Comme les gens ont déjà répondu ici qui tuplessont immuables tout enlists étant mutables, mais il y a un aspect important de l'utilisation de tuples dont nous devons nous souvenir

Si le tuplecontient un listou un dictionaryintérieur, ceux-ci peuvent être modifiés même si le tuplelui-même est immuable.

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

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 du tuple comme

my_tuple[4]['a'] = 500

ce qui rendra le tuple global comme

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

Cela se produit car listet dictionarysont les objets et ces objets ne changent pas, mais le contenu son pointant vers.

Donc le tuplereste immuable sans aucune exception

Le PEP 484 - Type Hints indique que les types d'éléments d'un tuplepeuvent être typés individuellement; afin que vous puissiez dire Tuple[str, int, float]; mais a list, avec Listtypage, la classe ne peut prendre qu'un seul paramètre de type:, List[str]ce qui laisse entendre que la différence des 2 est que le premier est hétérogène, tandis que le second est intrinsèquement homogène.

De plus, la bibliothèque standard utilise principalement le tuple comme valeur de retour de ces fonctions standard où le C retournerait a struct.

Comme les gens ont déjà mentionné les différences, j'écrirai pourquoi les tuples.

Pourquoi les tuples sont préférés?

Optimisation de l'allocation pour les petits tuples

Pour réduire la fragmentation de la mémoire et accélérer les allocations, Python réutilise les anciens tuples. Si un tuple n'est plus nécessaire et contient moins de 20 éléments au lieu de le supprimer définitivement, Python le déplace vers une liste gratuite.

Une liste libre est divisée en 20 groupes, où chaque groupe représente une liste de tuples de longueur n comprise entre 0 et 20. Chaque groupe peut stocker jusqu'à 2 000 tuples. Le premier (zéro) groupe ne contient qu'un seul élément et représente un tuple vide.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

Dans l'exemple ci-dessus, nous pouvons voir que a et b ont le même id. C'est parce que nous avons immédiatement occupé un tuple détruit qui était sur la liste gratuite.

Optimisation de l'allocation des listes

Comme les listes peuvent être modifiées, Python n'utilise pas la même optimisation que dans les tuples. Cependant, les listes Python ont également une liste gratuite, mais elle n'est utilisée que pour les objets vides. Si une liste vide est supprimée ou collectée par GC, elle peut être réutilisée ultérieurement.

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Source: https://rushter.com/blog/python-lists-and-tuples/

Pourquoi les tuples sont efficaces que les listes? -> https://stackoverflow.com/a/22140115

Une citation de direction 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 à des fins différentes. Les tuples sont immuables et contiennent généralement une séquence hétérogène d'éléments accessibles via le déballage (voir plus loin dans cette section) ou l' indexation (ou même par attribut dans le cas des couples nommés). Les listes sont modifiables et leurs éléments sont généralement homogènes et sont accessibles en itérant sur la liste.

Tout d'abord, ce sont tous les deux des objets non scalaires (également appelés objets composés) en Python.

• Tuples, séquence d'éléments ordonnée (qui peut contenir n'importe quel objet sans problème d'alias)
  • Immuable (tuple, int, float, str)
  • Concaténation utilisant +(un tout 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[:]
  • La compréhension de la liste [x**2 for x in range(1,7)]vous donne [1,4,9,16,25,36](non lisible)

L'utilisation de list peut également provoquer un bogue d'alias (deux chemins distincts pointant vers le même objet).

Les listes sont modifiables et les tuples sont immuables. Considérez simplement cet exemple.

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

Modifiez maintenant les valeurs d'index de la liste et du 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 a donc été prouvé que le code suivant n'est pas valide avec tuple, car nous avons tenté de mettre à jour un tuple, ce qui n'est pas autorisé.

La liste est modifiable et les tuples sont immuables. La principale différence entre mutable et immuable est l'utilisation de la mémoire lorsque vous essayez d'ajouter un élément.

Lorsque vous créez une variable, une mémoire fixe est affectée à la variable. S'il s'agit d'une liste, plus de mémoire est allouée qu'elle n'est réellement utilisée. Par exemple, si l'affectation de mémoire actuelle est de 100 octets, lorsque vous souhaitez ajouter le 101e octet, peut-être 100 autres octets seront attribués (au total 200 octets dans ce cas).

Cependant, si vous savez que vous n'ajoutez pas fréquemment de nouveaux éléments, vous devez utiliser des tuples. Tuples attribue exactement la taille de la mémoire nécessaire et économise donc de la mémoire, en particulier lorsque vous utilisez de gros blocs de mémoire.