web-dev-qa-db-fra.com

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()?

2971
Claudiu

append : Ajoute un objet à la fin.

x = [1, 2, 3]
x.append([4, 5])
print (x)

vous donne: [1, 2, 3, [4, 5]]


extend : étend la liste en ajoutant des éléments de l'itérable.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

vous donne: [1, 2, 3, 4, 5]

4504
kender

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']

De Plongez dans Python.

562
Harley Holcombe

Quelle est la différence entre les méthodes list et append et extend?

  • append ajoute son argument en tant qu'élément unique à la fin d'une liste. La longueur de la liste elle-même augmentera d'un.
  • extend itè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.

347
Aaron Hall

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]]
106
Greg Hewgill

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.

51
Erik

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']

De Plongez au coeur de Python.

36
CodyChan

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 .

35
denfromufa

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

 enter image description here

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.

 enter image description here

 enter image description here

29
Giovanni Gianni

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]
20
Chaitanya

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]
19
octoback

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]]
17
skdev75

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]
15
The Gr8 Adakron

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

12
bconstanzo

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]
11
Shiv

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)
5
kmario23

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']]
4
Viraj Kaulkar

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'}
4
Sanyal

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

4
Crabime

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'},
                }
2
JawSaw

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
0
Abhinav1602

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 
0
Karthik Sai

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]
0
missnomer

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]
0
PythonLover

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]
0
tessie