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

quelle différence?

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

868
demandé sur Chris_Rands 2009-03-09 18:41:25

18 réponses

outre le fait que tuples est immuable il y a aussi une distinction sémantique qui devrait guider leur usage. Les Tuples sont des structures de données hétérogènes (c.-à-d. que leurs entrées ont des significations différentes), tandis que les listes sont des séquences homogènes. Tuples ont la structure, les listes ont l'ordre.

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

un exemple serait les paires de pages et de numéros de ligne à référence emplacements dans un livre, p.ex.:

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

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

il peut y avoir des situations où vous voulez changer des éléments dans un tuple emplacement existant, par exemple lors de l'itération à travers les lignes d'une page. Mais l'immutabilité de tuple vous oblige à créer un nouveau tuple d'emplacement pour chaque nouvelle valeur. Cela semble peu pratique à 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 "Python les Tuples ne sont Pas Constant Listes" ou "la Compréhension de tuples par rapport aux listes en Python" . La documentation officielle de Python mentionne également ce

"n-Uplets 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 différentes les types et la longueur du tuple doivent être fixés. Dans une liste les valeurs ont tous le même type et la longueur n'est pas fixe. La différence est donc évidente.

enfin il y a le namedtuple en Python, ce qui a du sens parce qu'un tuple est déjà supposé avoir une structure. Cela souligne l'idée que les tuples sont une alternative légère aux classes et instances.

905
répondu nikow 2018-05-14 07:50:27

différence entre list et tuple

  1. Littérale

    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 plus petite taille d'une opération de tuple, il devient un peu plus rapide, mais pas tant que cela à mentionner jusqu'à ce que vous avez 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 aussi que vous ne pouvez pas supprimer un élément ou trier un tuple. Cependant, vous pouvez ajouter un nouvel élément à la fois list et tuple avec la seule différence que vous changerez l'id du tuple en ajoutant l'é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
    
  4. Utilisation

    Comme une liste est mutable, il ne peut pas être utilisé comme une clé dans un dictionnaire, alors qu'un n-uplet peut être utiliser.

    a    = (1,2)
    b    = [1,2] 
    
    c = {a: 1}     # OK
    c = {b: 1}     # Error
    
306
répondu Nikita 2017-06-11 18:05:11

si vous vous promenez, vous pouvez noter vos coordonnées à tout moment dans un (x,y) tuple.

si vous voulez enregistrer votre voyage, vous pouvez ajouter votre emplacement toutes les quelques secondes à une liste.

mais vous ne pouviez pas faire l'inverse.

179
répondu dan-gph 2018-06-06 04:29:15

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

donc si vous devez changer les valeurs utilisez une liste.

prestations à tuples:

  1. légère amélioration des performances.
  2. Comme un n-uplet est immuable, il peut être utilisé comme une clé dans un dictionnaire.
  3. Si vous ne pouvez pas le changer personne d'autre ne le peut, ce qui veut dire que vous n'avez pas à vous soucier des fonctions de L'API, etc. changer votre tuple sans qu'on vous le demande.
71
répondu Dave Webb 2014-10-01 20:18:16
Les listes

sont mutables; les tuples ne le sont pas.

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

Tuples sont immuables, et contiennent généralement une séquence hétérogène de les éléments auxquels on accède via le déballage (voir plus loin dans cette section)) ou indexation (ou même par attribut dans le cas de namedtuples). Liste sont mutables, et leurs éléments sont généralement homogènes et sont accessible par itérer sur la liste.

30
répondu duffymo 2014-02-04 20:47:28
Les listes

sont pour la boucle, les tuples sont pour les structures i.e. "%s %s" %tuple .

Les listes

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

Les listes

sont pour longueur variable, les tuples pour longueur fixe.

18
répondu Srinivas Reddy Thatiparthy 2013-06-03 06:48:52

c'est qui a é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; certaines bibliothèques se comportent en fait différemment selon ce qu'elles passent. Prenez NumPy par exemple (copié de 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 point est, tandis que NumPy peut ne pas faire partie de la bibliothèque standard, c'est une bibliothèque majeure Python, et au sein de NumPy listes et tuples sont des choses complètement différentes.

17
répondu Shep 2017-05-23 11:55:03

ceci est un exemple de listes Python:

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

c'est un exemple de Python tuple:

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

listes Python et tuples sont similaires en ce qu'ils sont tous les deux des collections ordonnées de valeurs. En plus de la différence superficielle que les listes sont créées en utilisant des parenthèses "[ ... , ... ]" et les tuples à l'aide de parenthèses "( ... , ... ) ", le noyau technique" codé en dur dans la syntaxe Python " différence entre eux est que les éléments d'un les tuples particuliers sont immuables alors que les listes sont mutables (...donc seuls les tuples sont hachables et peuvent être utilisés comme des clés de dictionnaire/hachage!). Cela donne lieu à des différences dans la façon dont ils peuvent ou ne peuvent pas être utilisés (a priori par la syntaxe) et des différences dans la façon dont les gens choisissent de les utiliser (encouragé en tant que "meilleures pratiques", a posteriori, c'est ce que font smart programers). La principale différence a posteriori dans la différenciation entre les tuples utilisés et les listes utilisées réside dans le fait que qui signifie les gens donnent à l'ordre des éléments.

pour tuples, "ordre" signifie rien de plus qu'une "structure" spécifique pour contenir l'information. Les valeurs trouvées dans le premier champ peuvent facilement être converties dans le deuxième champ, car chacun fournit des valeurs à travers deux dimensions ou échelles différentes. Ils apportent des réponses à différents types de questions et sont typiquement de la forme: pour un objet/sujet donné, ce qui sont ses attributs? l'objet / sujet reste constant, les attributs diffèrent.

pour les listes, "ordre" signifie une séquence ou une directionalité. Le deuxième élément doit venir après le premier élément parce qu'il est placé à la deuxième place basée sur une échelle ou une dimension particulière et commune. Les éléments sont considérés comme un tout et fournissent la plupart du temps des réponses à une seule question typiquement de la forme, pour un attribut donné, comment faire ces objets/sujets comparer? , L'attribut reste constante, l'objet/sujet diffère.

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

pour résumer quelques-uns des détails plus fins

similitudes:

  1. doublons - les tuples et les listes permettent les doublons
  2. indexage, Selecting, & Slicing - les tuples et les listes indexent en utilisant des valeurs entières trouvées entre parenthèses. Donc, si vous voulez les 3 premières valeurs d'une liste ou un tuple, la syntaxe sera 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 toutes deux comparées par leur premier élément, et s'il y a un lien, puis 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 - Listes utilisez [], l'utilisation des n-uplets ()

  2. mutabilité - les éléments d'une liste donnée sont mutables, les éléments d'un tuple donné ne le sont pas.

    # 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 (dictionnaires) - comme les hashtables (dictionnaires) exigent que ses clés soient hachables et donc immuables, seuls les tuples peuvent agir comme les clés de dictionnaire, et non 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 - Généralement les objets de la liste sont homogènes et 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 présidentiels, ou toutes les chansons, ou tous les coureurs) alors que ce n'est pas forcé par), alors que les tuples sont plus pour objets hétérogènes.

  2. boucle en fonction des Structures - bien que les deux permettent la boucle (pour x dans my_list...), il n'a vraiment de sens que pour une liste. Les Tuples sont plus appropriés pour la structuration et la présentation de l'information (%s %s résidant dans %s est %s et actuellement %s % ("Jean","Wayne",90210, "Acteur","Mort"))

13
répondu Afflatus 2016-12-06 11:54:21

les valeurs de list peuvent être modifiées à tout moment mais les valeurs de tuples ne peuvent pas être modifiées.

Le avantages et inconvénients dépend de l'utilisation. Si vous avez de telles données que vous ne voulez jamais changer, alors vous devriez utiliser tuple, sinon list est la meilleure option.

8
répondu bluish 2013-06-10 08:14:25
Les listes

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

5
répondu pquers 2009-03-09 20:29:55

le PEP 484 -- Type Hints dit que les types d'éléments d'un tuple peuvent être dactylographiés individuellement; de sorte que vous pouvez dire Tuple[str, int, float] ; mais un list , avec List typing class ne peut prendre qu'un seul paramètre de type: List[str] , ce qui suggère que la différence du 2 est vraiment 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 comme un valeur de retour de telles fonctions standard où le C retournerait un struct .

2
répondu Antti Haapala 2016-09-22 16:13:04

différence entre list et tuple

Tuples et listes sont des types de séquences apparemment similaires en Python.

  1. syntaxe littérale

    nous utilisons la parenthèse ( ) to construct tuples and square brackets [ ] pour obtenir une nouvelle liste. De plus, nous pouvons utiliser l'appel du type approprié pour obtenir la structure - tuple ou la liste requise.

    someTuple = (4,6)
    someList  = [2,6] 
    
  2. Mutabilité

    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 à la fois les tuples et les listes avec la seule différence que l'id du tuple sera modifié (c'est-à-dire que nous aurons un nouvel objet).

  5. "1519100920 de" Hachage

    Les Tuples

    sont hachurés et les listes ne le sont pas. Cela signifie que vous pouvez utiliser un tuple comme un élément 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 est plus sur les meilleures pratiques. Vous devez utiliser les tuples comme des structures de données hétérogènes, tandis que les listes sont des séquences homogènes.

2
répondu iPython 2018-07-19 19:03:40

tout d'abord, ils sont tous les deux des objets non-scalaires (aussi connus sous le nom d'objets composés) en Python.

  • Tuples, séquence ordonnée d'éléments (qui peuvent contenir n'importe quel objet sans aliasing problème)
    • immuable (tuple, int, float, str)
    • concaténation utilisant + (tout nouveau tuple sera créé bien sûr)
    • indexation
    • tranchage
    • Singleton (3,) # -> (3) au lieu de (3) # -> 3
  • Liste (Array dans d'autres langues), séquence ordonnée de valeurs
    • Mutable
    • Singleton [3]
    • Clonage new_array = origin_array[:]
    • liste de compréhension [x**2 for x in range(1,7)] vous donne [1,4,9,16,25,36] (non lisible)

à l'Aide de list peut aussi causer un bug d'alias (deux chemins distincts pointant vers le même objet).

1
répondu Xinyang Li 2016-12-11 11:02:44

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

bien que tuples puisse sembler similaire à des listes, ils sont souvent utilisés dans des situations différentes et à des fins différentes. Les Tuples sont immuable , et contiennent généralement une séquence hétérogène d'éléments auxquels on accède par déballage (voir plus loin dans cette section) ou indexage (ou même par attribut dans le cas de namedtuples). Les listes sont mutable , et leurs éléments sont généralement homogène et sont accessibles par des itération sur la liste.

1
répondu Albus Dumbledore 2017-09-26 16:12:11

comme les gens ont déjà répondu ici que tuples sont immuables tandis que lists sont mutables, mais il ya un aspect important de l'utilisation de tuples 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 en tant que

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 aussi changer le dictionnaire à l'intérieur de tuple comme

my_tuple[4]['a'] = 500

qui va faire l'ensemble de tuple ressemble à

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

cela se produit parce que list et dictionary sont les objets et ces objets ne changent pas, mais le contenu sa pointe.

ainsi le tuple reste immuable sans aucune exception

1
répondu Daksh 2018-09-11 14:18:07
Les listes

sont mutables et les tuples sont immuables. Il suffit de considérer cet exemple.

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

maintenant changer les valeurs d'index de list et 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.

donc prouvé que le code suivant est invalide avec tuple, parce que nous avons essayé de mettre à jour un tuple, ce qui n'est pas autorisé.

0
répondu Rahul Sawriya 2017-06-21 06:02:17

List est mutable et tuples est immuable. La principale différence entre changeant 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 assignée à la variable. Si c'est une liste, plus de mémoire est assignée que réellement utilisée. Par exemple: si la tâche mémoire courante est de 100 octets, lorsque vous voulez ajouter le 101e octet, peut-être que 100 autres octets seront assignés (au total 200 octets dans ce cas).

cependant, si vous savez que vous n'êtes pas souvent ajouter de nouveaux éléments, alors vous devez utiliser tuples. Tuples attribue exactement la taille de la mémoire nécessaire, et donc sauve la mémoire, surtout quand vous utilisez de grands blocs de mémoire.

-1
répondu Tony 2014-09-30 19:01:37

la différence de base que j'ai trouvé est que les listes sont mutables où as tuples sont immuables. Les Tuples sont bons pour les calculs dans lesquels ils n'ont pas besoin d'être changés.

-1
répondu Muhammad Ibrahim Mian 2018-06-20 22:11:19