Python) append () vs + opérateur sur les listes, pourquoi ceux-ci donnent des résultats différents?
Pourquoi ces deux opérations (append() resp. +) donne des résultats différents?
>>> c = [1, 2, 3]
>>> c
[1, 2, 3]
>>> c += c
>>> c
[1, 2, 3, 1, 2, 3]
>>> c = [1, 2, 3]
>>> c.append(c)
>>> c
[1, 2, 3, [...]]
>>>
Dans le dernier cas, il y a une récursion infinie. c[-1] et c sont identiques. Pourquoi est-ce différent avec le + opération?
Pour expliquer "pourquoi":
L'opération + ajoute les éléments array au tableau d'origine. L’opération array.append insère le tableau (ou n’importe quel objet) à la fin du tableau d’origine, ce qui entraîne une référence à self à cet endroit (d'où la récursion infinie).
La différence ici est que l'opération + agit de manière spécifique lorsque vous ajoutez un tableau (il est surchargé comme les autres, voir ce chapitre sur les séquences) en concaténant l'élément. Cependant, la méthode append fait littéralement ce que vous demandez: ajoutez l'objet à droite que vous lui donnez (le tableau ou tout autre objet), au lieu de prendre ses éléments.
Une alternative
Utilisez extend() si vous souhaitez utiliser une fonction similaire à l'opérateur + (comme d'autres l'ont montré ici). Il n'est pas sage de faire le contraire: essayer de mimer l'ajout avec l'opérateur + pour les listes (voir mon lien précédent sur pourquoi).
Peu d'histoire
Pour le plaisir, un peu d’histoire: le naissance du module tableau en Python en février 1993. Cela pourrait vous surprendre, mais des tableaux ont été ajoutés bien après la création de séquences et de listes.
L'opérateur de concaténation + est un opérateur infixe binaire qui, lorsqu'il est appliqué à des listes, renvoie une nouvelle liste contenant tous les éléments de chacun de ses deux opérandes. La méthode list.append() est une méthode mutator on list qui ajoute son unique argument object ( dans votre exemple spécifique, la liste c) du sujet list . Dans votre exemple, il en résulte que c ajoute une référence à lui-même (d'où la récursion infinie).
Une alternative à la concaténation '+'
La méthode list.extend() est également une méthode de mutation qui concatène son argument sequence avec le sujet list . Plus précisément, il ajoute chacun des éléments de sequence dans l’ordre des itérations.
Un aparté
Étant un opérateur, + renvoie le résultat de l'expression sous forme de nouvelle valeur. Étant une méthode non chaînante mutator, list.extend() modifie la liste de sujets sur place et ne renvoie rien.
Tableaux
J'ai ajouté ceci en raison de la confusion potentielle que la réponse d'Abel ci-dessus peut causer en mélangeant la discussion de listes, de séquences et de tableaux. Arrays ont été ajoutés à Python après les séquences et les listes, comme moyen plus efficace de stocker des tableaux de types de données intégrales. Ne confondez pas arrays avec lists. Ils ne sont pas identiques.
À partir de la documentation sur le tablea :
Les tableaux sont des types de séquence et se comportent très bien comme des listes, sauf que le type des objets qui y sont stockés est contraint. Le type est spécifié au moment de la création de l'objet à l'aide d'un code de type, qui est un caractère unique.
append ajoute un élément à une liste. si vous souhaitez étendre la liste avec la nouvelle liste, vous devez utiliser extend.
>>> c = [1, 2, 3]
>>> c.extend(c)
>>> c
[1, 2, 3, 1, 2, 3]
Les listes Python sont hétérogènes, c'est-à-dire que les éléments de la même liste peuvent être n'importe quel type d'objet. L'expression: c.append(c) ajoute l'objet c à la liste. Dans le cas présent, la liste est elle-même membre de la liste.
L'expression c += c Additionne deux listes et affecte le résultat à la variable c. L'opérateur surchargé + Est défini sur les listes pour créer une nouvelle liste dont le contenu est constitué des éléments de la première liste et des éléments de la deuxième liste.
Donc, ce ne sont vraiment que des expressions différentes utilisées pour faire des choses différentes par conception.
La méthode que vous recherchez est extend(). De la Python documentation :
list.append(x)
Add an item to the end of the list; equivalent to a[len(a):] = [x].
list.extend(L)
Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L.
list.insert(i, x)
Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).
vous devriez utiliser extend ()
>>> c=[1,2,3]
>>> c.extend(c)
>>> c
[1, 2, 3, 1, 2, 3]
autre info: append vs. extend
Voir la documentation :
list.append (x)
- Ajouter un élément à la fin de la liste; équivalent à un [len (a):] = [x].
list.extend (L) - Étend la liste en ajoutant tous les éléments de la liste donnée; équivalent à un [len (a):] = L.
c.append(c) "ajoute" c à lui-même en tant qu'élément . Puisqu'une liste est un type de référence, cela crée une structure de données récursive.
c += c Équivaut à extend(c), qui ajoute les éléments de c à c.