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


1020

Quelle est la différence?

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


13
Les autres ont répondu ci-dessous, mais je voudrais souligner que, à mon humble avis, python a un nom de type de données totalement intuitif. Je ne pense pas qu'une autre langue ait des tuples (de ce nom), et pire encore en tant que mot, je ne peux même pas le traduire dans ma langue. Est-ce que quelqu'un sait d'où vient le "tuple"? Néerlandais ?
Tour

98
Les tuples sont un terme de base en mathématiques, dérivé du latin (voir wikipedia).
nikow

129
paire -> triple -> quadruple -> quintuple -> sextuple -> euh, comment ça s'appelle, ah sod it, 7-tuple -> 8-tuple -> ... d'où 'tuple' comme nom générique.
John Fouhy

31
@JohnFouhy C'est plus de six ans plus tard, mais: ... heptuple, octuple, tuple avec neuf éléments, decuple, undecuple, dodecuple ...: D
Augusta

18
@MegaWidget Je pensais que nous avions établi qu'un non-doublon était un list. ; D
Augusta

Réponses:


1017

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.


11
+1, en particulier pour votre deuxième lien avec un excellent exemple. J'adore cette citation: "Ce tuple fonctionne comme un enregistrement ou une structure légère."
Baltimark

105
"les listes sont des séquences homogènes" - je suis nouveau sur Python, mais les listes ne sont-elles pas hétérogènes? D'après docs.python.org/py3k/tutorial/introduction.html : "Les éléments de liste n'ont pas tous besoin du même type." Mais peut-être que vous parlez du concept formel, et non de la prise en charge de Python.
Matthew Cornell

13
Un bon synonyme sémantique pour "tuple" pourrait être "record". Il s'agit d'une collection d'éléments de données associés dans une séquence spécifique. En fait, je pense collections.namedtuplequ'il vaut mieux l'appeler collections.record. Cela n'aurait aucun sens d'échanger, disons, le nom et l'adresse dans un dossier client; en fait, cela serait généralement une erreur, que l'immuabilité du tuple vous empêche de commettre.
kindall

4
@nikow: Concernant What would you do with such a list?, je frissonne toujours quand les gens utilisent le manque de fantaisie comme argument. L'utilisation de listes de types mixtes fonctionne très bien, par exemple pour certaines structures de données hiérarchiques, où chaque liste est composée de listes d'enfants et d'éléments de valeur.
Sebastian Mach

18
N'est-il pas trompeur de dire que les tuples sont hétérogènes et que les listes sont homogènes? Par exemple, une liste peut avoir des mélanges de différents types de données, c'est-à-dire l = [1, 2, 'a']. Je ne comprends pas de quoi tu parles.
Celeritas

362

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

Alors, que se passe-t-il lorsque j'essaye de redimensionner la taille de la liste en grandes valeurs? Cela changera-t-il l'adresse mémoire (qui, je crois, devrait changer l'identifiant). Ou cela va-t-il me jeter une erreur?
WanderingMind

17
@WanderingMind: l'adresse mémoire où les valeurs de liste sont stockées n'est pas la même que l'adresse mémoire où l'objet de liste lui-même est stocké.
Tom

2
Hmmm ... tout le code de cet article, sauf la première case en dessous, 3. Permitted operationmontre d'abord le tuple case. Je sais qu'il est habituel de montrer le succès puis l'erreur, mais cela m'a dérangé la tête pendant quelques instants.
dmckee --- chaton ex-modérateur

1
Comme indiqué au point 3, une seule liste d'éléments peut être one_item_list = [a], mais one_tuple = (a,)c'est le tuple correspondant. Notez la virgule qui suit le nom de la variable. Mais notez aussi two_tuple = (a, b). Cela m'a jeté plus d'une fois (toujours là en Python 3).
mjkrause

1
@Cheng Parce que trier le tuple le muterait, c'est-à-dire changer ses éléments. Les tuples ne supportent pas cela. La façon la plus simple d'obtenir un tuple trié en python esttuple(sorted(the_unsorted_tuple))
ApproachingDarknessFish

204

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.


37
Cet exemple ressemble simplement à une convention. Les gens pourraient dire "je peux toujours utiliser [x, y] pour noter les coordonnées si je veux". Par conséquent, cette réponse est considérée comme inachevée, sauf une phrase de plus: "Lisez le message de @nikow pour savoir pourquoi vous ne devriez pas utiliser la liste pour stocker les coordonnées"
RayLuo

71
@Iceberg, ma réponse est destinée à aider à développer l'intuition. Il ne s'agit pas d'explorer toutes les nuances du sujet.
dan-gph

8
Bel exemple +1. Il souligne la nature complémentaire des éléments du tuple (ici les coordonnées), c'est pourquoi la modification de l'un d'eux n'est pas autorisée - car elle change la signification de l'ensemble du tuple (ici la position d'un point).
Hao Wang

77

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.

14
Notez qu'un tuple n'est immuable que si tous ses éléments le sont . Vous pourriez dire que la même chose est vraie pour toutes les collections immuables, comme frozensetou pour les divers dict / tree / etc gelés tiers. , mais aucun de ceux-ci ne vous permet d'ajouter des éléments mutables. (Et bien sûr, un tuple n'est lavable que si tous ses éléments le sont, ce qui est géré de la manière habituelle EAFP, donc d[1, [2]]il augmentera TypeError: unhashable type: 'list'.)
abarnert

1
Un tuple ne peut être utilisé comme clé dans un dictionnaire que si tous ses éléments sont immuables. Voir ici
Will Dereham

31

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.


1
Je pense vraiment que vous devriez également considérer les implications sémantiques (voir ma réponse ci-dessous).
nikow

Semble à peine en vaut la peine maintenant, mais merci pour la tête.
duffymo

Six mois plus tard, et c'est tout ce que vous pouvez apporter? J'ai donné cette réponse à l'époque parce que dans les quatre heures qui se sont écoulées entre ma réponse d'origine et le commentaire, d'autres ont plus que compensé la différence. La réponse était-elle incorrecte? Pas vraiment, bien que Nikow l'ait amélioré. Alors, qu'est-ce qu'un lien ajouterait vraiment?
duffymo

4
C'est drôle de voir comment d'autres réponses ici ont la même qualité comme celle-ci, mais seulement cela est détesté à cause d'un commentateur qui dit "-1". Et il y a une autre réponse qui n'a que 0,5 fois la qualité, mais seulement 0,1 fois les downvotes.
Sebastian Mach

2
@duffymo Je pense que cette réponse est la plus claire et la plus concise de cette page. Il nomme la seule différence vraiment importante entre les tuples et les listes et ne babille pas sans fin sur ce bain de lait manifestement faux homogène vs hétérogène.
entrée

20

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.


2
Ce n'est pas vraiment une réponse utile. La différence est que type(a_list) != type(a_tuple), donc tout morceau de code de bibliothèque basé sur type(x)se comportera différemment
Eric

1
bon point, j'ai édité le post: c'est juste pour souligner que les directives sémantiques sont codées en dur dans certaines bibliothèques.
Shep

1
Il pourrait être préférable d'utiliser des exemples provenant de stdlib / builtins que de bibliothèques tierces. Il existe un certain nombre d'emplacements où vous pouvez utiliser une seule valeur ou un tuple de valeurs, et une liste ou une autre séquence est considérée comme une valeur unique. Par exemple, '%d %d' % [2, 3]est un TypeError, car vous essayez de transmettre une liste à la première %det vous ne transmettez aucune valeur à la seconde %d. (Cependant, il y a aussi des contre-exemples, comme max…)
abarnert

c'est intéressant, je ne savais pas qu'il y avait des exemples de cela dans la bibliothèque standard de python. Un certain nombre d'endroits que vous dites?
Shep

18

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.


16

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


J'aime l'exemple de table de hachage / de table de hachage pour expliquer une raison d'immuabilité - vous pouvez utiliser un tuple (enregistrement / structure / coordonnée / vecteur / point) comme clé complexe dans un dict.
Dave X

9

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.


7

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.


1
Mon vote ici pour la discussion explicite de l'extension et du hachage, que je n'ai pas remarqué dans les réponses existantes par ailleurs très bonnes.
dmckee --- chaton ex-modérateur

6

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.


26
À ce stade, cette réponse n'ajoute rien à la discussion, car il existe de nombreuses autres meilleures réponses.
Jonathon Reinhart

5

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


Ce message serait amélioré si vous expliquiez que "ceux-ci peuvent être modifiés même si le tuple lui-même est immuable". c'est parce que ces objets conservent leur identité while (donc le tuple n'a pas changé car il contient toujours les mêmes objets ...).
dmckee --- chaton ex-modérateur

3

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.


3

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


2

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.


1

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


0

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


-1

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.


2
Bien que cela soit techniquement vrai, ce n'est pas vraiment la différence cruciale entre les types mutables et immuables. La plus grande différence est que les types mutables peuvent être modifiés après la construction, contrairement aux types immuables.
Roger Fan

1
Ce n'est pas non plus la raison. La mémoire et la mutabilité n'ont rien à voir l'une avec l'autre. Il s'agit simplement d'un détail d'implémentation spécifique aux listes. La mémoire n'est pas non plus affectée aux variables, elle est affectée aux objets. Les variables ne sont alors que des références à ces objets.
Roger Fan
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.