Différence entre les méthodes append et extend list en Python
Quelle est la différence entre les méthodes listées append() et extend()?
append ajoute un élément à une liste et extend concatène la première liste avec une autre liste (ou une autre liste itérable, pas nécessairement une liste).
>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']
>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', ['new', 2]]
>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
Quelle est la différence entre les méthodes list et append et extend?
appendajoute son argument en tant qu'élément unique à la fin d'une liste. La longueur de la liste elle-même augmentera d'un.extenditère sur son argument en ajoutant chaque élément à la liste, en élargissant la liste. La longueur de la liste augmentera de plusieurs éléments dans l'argument itérable.
append
La méthode list.append ajoute un objet à la fin de la liste.
my_list.append(object)
Quel que soit l'objet, que ce soit un nombre, une chaîne, une autre liste ou quelque chose d'autre, il est ajouté à la fin de my_list en tant qu'entrée unique dans la liste.
>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']
Alors gardez à l'esprit qu'une liste est un objet. Si vous ajoutez une autre liste à une liste, la première liste sera un seul objet à la fin de la liste (ce qui peut ne pas être ce que vous voulez):
>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
#^^^^^^^^^--- single item at the end of the list.
extend
La méthode list.extend étend une liste en ajoutant des éléments à partir d'un iterable:
my_list.extend(iterable)
Donc, avec extend, chaque élément de l'itérable est ajouté à la liste. Par exemple:
>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]
Gardez à l'esprit qu'une chaîne est un élément itérable. Par conséquent, si vous étendez une liste avec une chaîne, vous ajouterez chaque caractère lors de l'itération sur la chaîne (ce qui peut ne pas être ce que vous voulez):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
Surcharge de l'opérateur, __add__ (+) et __iadd__ (+=)
Les opérateurs + et += sont tous deux définis pour list. Ils sont sémantiquement similaires pour s'étendre.
my_list + another_list crée une troisième liste en mémoire afin que vous puissiez en renvoyer le résultat, mais il faut que la seconde itérable soit une liste.
my_list += another_list modifie la liste sur place (il est l'opérateur sur place, et les listes sont des objets mutables, comme nous l'avons vu) afin de ne pas créer de nouvelle liste. Cela fonctionne également comme une extension, en ce sens que la seconde peut être tout type d’itéré.
Ne vous trompez pas - my_list = my_list + another_list n'est pas équivalent à += - il vous donne une nouvelle liste assignée à my_list.
La complexité du temps
Append a complexité temporelle constante , O (1).
Étendre a une complexité temporelle, O (k).
Itérer parmi les multiples appels à append ajoute à la complexité, en le rendant équivalent à celui de extend, et puisque l'itération de extend est implémentée en C, il sera toujours plus rapide si vous avez l'intention d'ajouter des éléments successifs d'un itérable à une liste.
Performance
Vous pouvez vous demander ce qui est plus performant, puisque append peut être utilisé pour obtenir le même résultat que extend. Les fonctions suivantes font la même chose:
def append(alist, iterable):
for item in iterable:
alist.append(item)
def extend(alist, iterable):
alist.extend(iterable)
Alors chronométrons les:
import timeit
>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883
Répondre à un commentaire sur les horaires
Un commentateur a déclaré:
Réponse parfaite, je manque le moment de comparer en ajoutant un seul élément
Faites la chose sémantiquement correcte. Si vous souhaitez ajouter tous les éléments d'une variable, utilisez extend. Si vous ajoutez seulement un élément, utilisez append.
Ok, alors créons une expérience pour voir comment cela fonctionne dans le temps:
def append_one(a_list, element):
a_list.append(element)
def extend_one(a_list, element):
"""creating a new list is semantically the most direct
way to create an iterable to give to extend"""
a_list.extend([element])
import timeit
Et nous voyons que faire de notre mieux pour créer une extension itérable juste utiliser est une perte de temps (mineure):
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
Nous apprenons de cela que l’utilisation de extend n’a rien à gagner lorsque nous n’avons qu’un élément one à ajouter.
En outre, ces horaires ne sont pas si importants. Je leur montre simplement que, en Python, faire ce qui est sémantiquement correct, c'est faire les choses à la manière Right Way ™.
Il est concevable que vous puissiez tester les synchronisations sur deux opérations comparables et obtenir un résultat ambigu ou inverse. Concentrez-vous simplement sur ce qui est sémantiquement correct.
Conclusion
Nous voyons que extend est sémantiquement plus clair et qu’elle peut courir beaucoup plus vite que append, lorsque vous avez l’intention d’ajouter chaque élément d’un élément itérable à une liste.
Si vous n'avez qu'un seul élément à ajouter à la liste (pas dans une itérable), utilisez append.
append ajoute un seul élément. extend ajoute une liste d'éléments.
Notez que si vous passez une liste à ajouter, un élément reste ajouté:
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
Les deux extraits suivants sont sémantiquement équivalents:
for item in iterator:
a_list.append(item)
et
a_list.extend(iterator)
Ce dernier peut être plus rapide puisque la boucle est implémentée en C.
La méthode append () ajoute un seul élément à la fin de la liste.
x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']
La méthode extend () prend un argument, une liste, et ajoute chacun des éléments de l'argument à la liste d'origine. (Les listes sont implémentées en tant que classes. «Créer» une liste, c'est vraiment instancier une classe. En tant que telle, une liste a des méthodes qui fonctionnent dessus.)
x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']
Vous pouvez utiliser "+" pour renvoyer une extension, au lieu d'une extension en place.
l1=range(10)
l1+[11]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]
l2=range(10,1,-1)
l1+l2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]
De même, += pour le comportement en place, mais avec de légères différences entre append et extend. Une des plus grandes différences entre += de append et extend réside dans son utilisation dans les portées de fonctions, voir cet article de blog .
Append vs Extend
![enter image description here]()
Avec append, vous pouvez ajouter un seul élément qui étendra la liste:
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]
Si vous souhaitez étendre plus d'un élément, vous devez utiliser extend, car vous ne pouvez ajouter qu'un seul élément ou une seule liste d'éléments:
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
Pour que vous obteniez une liste imbriquée
Avec plutôt extend, vous pouvez étendre un seul élément comme celui-ci
>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]
Ou, différemment de append, étendre plusieurs éléments en une fois sans imbriquer la liste dans celle d'origine (c'est la raison de l'extension du nom)
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
Ajout d'un élément avec les deux méthodes
ajouter 1 élément
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
étendre un élément
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]
Ajouter plus d'éléments ... avec des résultats différents
Si vous utilisez append pour plus d'un élément, vous devez passer une liste d'éléments comme arguments et vous obtiendrez une liste NESTED!
>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]
Avec extend, au lieu de cela, vous passez une liste en tant qu'argument, mais vous obtiendrez une liste avec le nouvel élément qui n'est pas imbriqué dans l'ancien.
>>> z = [1,2]
>>> z.extend([3,4])
>>> z
[1,2,3,4]
Ainsi, avec plus d’éléments, vous utiliserez extend pour obtenir une liste avec plus d’éléments . sortie du code.
append(object) - Met à jour la liste en ajoutant un objet à la liste.
x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]
extend(list) - Concatène essentiellement deux listes.
x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]
extend() peut être utilisé avec un argument itérateur. Voici un exemple. Vous souhaitez faire une liste d'une liste de listes de cette façon:
De
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
tu veux
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Vous pouvez utiliser itertools.chain.from_iterable() pour le faire. La sortie de cette méthode est un itérateur. Sa mise en œuvre est équivalente à
def from_iterable(iterables):
# chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
for it in iterables:
for element in it:
yield element
Retour à notre exemple, nous pouvons faire
import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))
et obtenez la liste des personnes recherchées.
Voici comment extend() peut être utilisé de manière équivalente avec un argument d'itérateur:
merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Ceci est l'équivalent de append et extend en utilisant l'opérateur +:
>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]
append (): Il est essentiellement utilisé en Python pour ajouter un élément.
Exemple 1:
>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]
Exemple 2:
>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]
extend (): Où extend (), sert à fusionner deux listes ou à insérer plusieurs éléments dans une liste.
Exemple 1:
>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]
Exemple 2:
>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]
Un point intéressant qui a été laissé entendre, mais n’a pas été expliqué, est que l’extension est plus rapide que l’ajout. Pour toute boucle comportant append inside doit être considérée comme remplacée par list.extend (éléments_processus).
N'oubliez pas que l'approbation de nouveaux éléments peut entraîner une réallocation complète de la liste dans un meilleur emplacement en mémoire. Si cela est fait plusieurs fois parce que nous ajoutons un élément à la fois, les performances globales en pâtissent. En ce sens, list.extend est analogue à "" .join (stringlist).
Ajouter ajoute la totalité des données à la fois. L'ensemble des données sera ajouté à l'index nouvellement créé. Par ailleurs, extend, comme son nom l'indique, étend le tableau actuel.
Par exemple
list1 = [123, 456, 678]
list2 = [111, 222]
Avec append on obtient:
result = [123, 456, 678, [111, 222]]
Alors que sur extend nous obtenons:
result = [123, 456, 678, 111, 222]
Un dictionnaire anglais définit les mots append et extend comme suit:
append : ajoute (quelque chose) à la fin d'un document écrit.
extend : agrandit. Agrandir ou agrandir
Avec cette connaissance, comprenons maintenant
1) La différence entre append et extend
append:
- Ajoute n’importe quel objet Python tel quel à la fin de la liste (c’est-à-dire en tant que dernier élément de la liste ).
- La liste résultante peut être imbriquée et contenir des éléments hétérogènes (liste, chaîne, tuple, dictionnaire, ensemble, etc.)
extend:
- Accepte tout iterable comme argument et rend la liste plus grande.
- La liste résultante est toujours une liste à une dimension (c'est-à-dire aucune imbrication) et peut contenir des éléments hétérogènes (par exemple des caractères, des entiers, des éléments flottants) résultant de l'application de
list(iterable).
2) Similitude entre append et extend
- Les deux prend exactement un argument.
- Les deux modifient la liste in-place.
- Par conséquent, les deux renvoient
None.
Exemple
lis = [1, 2, 3]
# 'extend' is equivalent to this
lis = lis + list(iterable)
# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
lis.append(object)
La méthode "append" ajoute son paramètre en tant que élément unique à la liste, tandis que "extend" obtient une liste et ajoute son contenu.
Par exemple,
étendre
letters = ['a', 'b']
letters.extend(['c', 'd'])
print(letters) # ['a', 'b', 'c', 'd']
append
letters.append(['e', 'f'])
print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]
Ajouter un dictionnaire à un autre:
>>>def foo():
dic = {1:'a', 2:'b', 3:'c', 4:'a'}
newdic = {5:'v', 1:'aa'}
for i in dic.keys():
if not newdic.has_key(dic[i]):
newdic[i] = dic[i]
print "Appended one:", newdic
>>>foo()
Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}
J'espère pouvoir compléter utilement cette question. Si votre liste stocke un objet de type spécifique, par exemple Info, il existe une situation dans laquelle la méthode extend ne convient pas: dans une boucle for et générant un objet Info à chaque fois et en utilisant extend pour le stocker dans votre liste, il échouera. L'exception est comme ci-dessous:
TypeError: l'objet 'Info' n'est pas itérable
Mais si vous utilisez la méthode append, le résultat est OK. Parce que chaque fois que vous utilisez la méthode extend, il la traitera toujours comme une liste ou tout autre type de collection, itérera-la et la placera après la liste précédente. Un objet spécifique ne peut évidemment pas être itéré.
Pour les distinguer intuitivement
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]
C'est comme si l1 reproduisait un corps dans son corps (imbriqué).
# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']
C'est comme si deux individus séparés se mariaient et construisaient une famille unie.
En outre, je fais une feuille de triche exhaustive de toutes les méthodes de la liste pour votre référence.
list_methods = {'Add': {'extend', 'append', 'insert'},
'Remove': {'pop', 'remove', 'clear'}
'Sort': {'reverse', 'sort'},
'Search': {'count', 'index'},
'Copy': {'copy'},
}
append: ajoute la "liste" ou "un seul élément" à la fin de la liste existante
a = [1,2]
b = [3]
a.append(b)
print(a) # prints [1,2,[3]]
a.append(4)
print(a) # prints [1,2,[3],4]
extend: ajoute 'les éléments d'une liste' (passés en argument) à la liste existante.
a = [1,2]
b = [3]
a.extend(b)
print(a) # prints [1,2,3]
a.extend(4) # typeError as int cannot be used as argument with extend
Append: ajoute son argument en tant qu'élément unique à la fin d'une liste.
par exemple:-
my_list = ['stack', 'over']
my_list.append('flow')
print my_list
Sortie:
['stack', 'over', 'flow']
Remarque: - Si vous ajoutez une autre liste à une liste, la première liste sera un objet unique à la fin de la liste.
par exemple:-
my_list = ['stack', 'over', 'flow']
another_list = [1,2,3,4] ,
my_list.append(another_list)
print my_list
Sortie:-
['stack', 'over', 'over', [1,2,3,4]]
extend(): - Itère son argument en ajoutant chaque élément à la liste et en étendant la liste. La longueur de la liste augmente en fonction du nombre d’éléments de son argument.
par exemple:-
my_list = ['stack', 'over']
another_list = [6, 0, 4, 1]
my_list.extend(another_list)
print my_list
Sortie:
['stack', 'over', 6, 0, 4, 1]
Remarque: - Une chaîne est un élément itérable. Par conséquent, si vous étendez une liste avec une chaîne, vous ajouterez chaque caractère à chaque itération.
par exemple:-
my_list = ['stack', 'overflow', 6, 0, 4, 1]
my_list.extend('hello')
print my_list
Cela m'a aidé à comprendre ce qui se passe réellement lorsque vous utilisez append et extend:
a = [[1,2,3],[4,5,6]]
print(a)
>>> [[1, 2, 3], [4, 5, 6]]
a.append([6,7,8])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8]]
a.extend([0,1,2])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2]
a=a+[8,9,10]
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2, 8, 9, 10]
append () method ajoutera l'argument qui lui est transmis en tant qu'élément unique.
extend () sera itéré sur les arguments passés et étendra la liste en passant chaque élément itéré, fondamentalement, il ajoutera plusieurs éléments n’ajoutant pas un tout.
list1 = [1,2,3,4,5]
list2 = [6,7,8]
list1.append(list2)
print(list1)
#[1,2,3,4,5,[6,7,8]]
list1.extend(list2)
print(list1)
#[1,2,3,4,5,6,7,8]
extend (L) prolonge la liste en ajoutant tous les éléments de la liste donnée L.
>>> a
[1, 2, 3]
a.extend([4) #is eqivalent of a[len(a):] = [4]
>>>a
[1, 2, 3, 4]
a =[1,2,3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]