Liste vs Tuple, quand utiliser chacun?
En Python, quand faut-il utiliser des listes et quand des tuples?
Parfois, vous n'avez pas le choix, par exemple si vous avez
"hello %s you are %s years old" % x
alors x doit être un tuple.
Mais si je suis celui qui conçoit l'API et doit choisir les types de données, quelles sont les directives?
Il existe une forte culture de nuplets pour les collections hétérogènes, similaire à celle pour laquelle vous utiliseriez structs en C, et les listes pour les collections homogènes, similaire à celle pour laquelle vous utiliseriez des tableaux. Mais je n'ai jamais vraiment concilié cela avec le problème de mutabilité mentionné dans les autres réponses. La mutabilité a des dents (vous ne pouvez pas réellement changer un tuple), tandis que l'homogénéité n'est pas imposée et semble donc être une distinction beaucoup moins intéressante.
Tuples ont une taille fixe dans la nature alors que listes sont dynamiques.
En d’autres termes, une Tuple est immuable alors qu’un list est mutable .
- Vous ne pouvez pas ajouter d'éléments à un tuple. Les tuples n'ont pas de méthode append ou extend.
- Vous ne pouvez pas supprimer des éléments d'un tuple. Les tuples n'ont pas de méthode remove ou pop.
- Vous pouvez trouver des éléments dans un tuple, car cela ne change pas le tuple.
- Vous pouvez également utiliser l'opérateur
inpour vérifier si un élément existe dans le tuple.
Les tuples sont plus rapides que les listes. Si vous définissez un ensemble constant de valeurs et que tout ce que vous allez faire, c'est le parcourir, utilisez un tuple au lieu d'une liste.
Votre code est plus sûr si vous "protégez en écriture" des données qu'il n'est pas nécessaire de modifier. Utiliser un tuple à la place d'une liste revient à avoir une affirmation implicite que ces données sont constantes et qu'une pensée spéciale (et une fonction spécifique) est nécessaire pour remplacer cette donnée.
Certains tuples peuvent être utilisés comme clés de dictionnaire (en particulier, des tuples contenant des valeurs immuables telles que des chaînes, des nombres et d'autres tuples). Les listes ne peuvent jamais être utilisées comme clés de dictionnaire, car les listes ne sont pas immuables.
Source: Plongez dans Python
Je crois (et je ne suis pas très au courant de Python) que la principale différence est qu'un tuple est immuable (il ne peut pas être changé en place après l'attribution) et une liste est mutable (vous pouvez ajouter, modifier, soustraire, etc.).
Ainsi, j’ai tendance à faire en mulples des choses qui ne devraient pas changer après l’affectation et de ma liste des choses qui peuvent.
Doit-il être mutable? Utilisez une liste. Ne doit-il pas être mutable? Utilisez un tuple.
Sinon, c'est une question de choix.
Pour les collections d'objets hétérogènes (comme une adresse divisée en nom, rue, ville, état et code postal), je préfère utiliser un tuple. Ils peuvent toujours être facilement promus à nommés tuples .
De même, si la collection doit être itérée, je préfère une liste. S'il ne s'agit que d'un conteneur contenant plusieurs objets, je préfère un tuple.
La première chose à déterminer est de savoir si la structure de données doit être modifiable ou non. Comme il a été mentionné, les listes sont mutables, les n-uplets ne le sont pas. Cela signifie également que les nuplets peuvent être utilisés pour les clés de dictionnaire, contrairement aux listes.
D'après mon expérience, les n-uplets sont généralement utilisés lorsque l'ordre et la position sont significatifs et cohérents. Par exemple, lors de la création d'une structure de données pour votre propre jeu d'aventure, j'ai choisi d'utiliser des n-uplets au lieu de listes, car la position dans le tuple était significative. Voici un exemple de cette structure de données:
pages = {'foyer': {'text' : "some text",
'choices' : [('open the door', 'Rainbow'),
('go left into the kitchen', 'bottomless pit'),
('stay put','foyer2')]},}
La première position du tuple correspond au choix affiché pour l'utilisateur lorsqu'il joue au jeu. La seconde position est la clé de la page à laquelle ce choix est attribué, ce qui est cohérent pour toutes les pages.
Les tuples sont également plus efficaces en termes de mémoire que les listes, bien que je ne sache pas quand cet avantage deviendra évident.
Consultez également les chapitres sur les listes et les nuplets dans Think Python .
Mais si je suis celui qui conçoit l'API et doit choisir les types de données, quelles sont les directives?
Pour les paramètres d'entrée, il est préférable d'accepter l'interface la plus générique répondant à vos besoins. C'est rarement un tuple ou une liste - le plus souvent, c'est une séquence, une sliceable ou même une itérabilité. La saisie de code de Python est généralement gratuite, sauf si vous vérifiez explicitement les types d'entrée. Ne faites pas ça à moins que cela ne soit absolument inévitable.
Pour les données que vous produisez (paramètres de sortie), renvoyez simplement ce qui vous convient le mieux, par exemple: renvoie le type de données que vous conservez ou celui que votre fonction d'assistance renvoie.
Une chose à garder à l'esprit est d'éviter de renvoyer une liste (ou tout autre fichier mutable) faisant partie de votre état, par exemple.
class ThingsKeeper
def __init__(self):
self.__things = []
def things(self):
return self.__things #outside objects can now modify your state
def safer(self):
return self.__things[:] #it's copy-on-write, shouldn't hurt performance
Un avantage mineur mais notable d’une liste par rapport à un tuple est que les listes ont tendance à être légèrement plus portables. Les outils standard sont moins susceptibles de supporter les n-uplets. JSON, par exemple, n'a pas de type Tuple. YAML fait, mais sa syntaxe est laide comparée à sa syntaxe de liste, qui est tout à fait Nice.
Dans ces cas, vous pouvez utiliser un tuple en interne, puis convertir en liste dans le cadre d'un processus d'exportation. Sinon, vous pouvez utiliser des listes partout pour la cohérence.