Question Différence entre les méthodes append et extend en Python


Quelle est la différence entre les méthodes de liste append() et extend()?


2682
2017-10-31 05:55


origine


Réponses:


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]


4073
2017-10-31 06:02



append ajoute un élément à une liste, et extend concatène la première liste avec une autre liste (ou une autre 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.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.


525
2017-10-31 05:57



Quelle est la différence entre les méthodes de liste 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'une unité.
  • extend itère sur son argument en ajoutant chaque élément à la liste, étendant la liste. La longueur de la liste augmentera en dépit du fait que de nombreux éléments étaient dans l'argument itérable.

append

le list.append méthode ajoute un objet à la fin de la liste.

my_list.append(object) 

Quel que soit l'objet, qu'il s'agisse d'un nombre, d'une chaîne, d'une autre liste ou de quelque chose d'autre, il est ajouté à la fin de my_list comme une seule entrée sur la liste.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Gardez donc à 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 on end of list.

extend

le list.extend La méthode étend une liste en ajoutant des éléments d'un itérable:

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 une itérable, donc si vous étendez une liste avec une chaîne, vous ajouterez chaque caractère pendant que vous itérez 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__ (+=)

Tous les deux + et += les opérateurs sont définis pour list. Ils sont sémantiquement similaires à étendre.

my_list + another_list crée une troisième liste en mémoire, de sorte que vous pouvez retourner 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 in-situ, et les listes sont des objets mutables, comme nous l'avons vu) donc il ne crée pas de nouvelle liste. Cela fonctionne aussi comme extension, en ce que le deuxième itérable peut être n'importe quel itérable.

Ne soyez pas confus - my_list = my_list + another_list n'est pas équivalent à += - il vous donne une toute nouvelle liste affectée à my_list.

Complexité du temps

Append a la complexité du temps constant, O (1).

L'extension a la complexité du temps, O (k).

Itérer à travers les multiples appels à append ajoute à la complexité, la rendant équivalente à celle d'extend, et puisque l'itération d'extend est implémentée dans C, elle 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 le 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 laissez-les temps:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Adresser un commentaire sur les horaires

Un commentateur a dit:

Réponse parfaite, je manque juste le moment de la comparaison en ajoutant un seul élément

Faites la chose sémantiquement correcte. Si vous voulez ajouter tous les éléments dans un itérable, utilisez extend. Si vous ajoutez juste 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 sortir de notre façon de créer un itérable juste pour utiliser étendre 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 qu'il n'y a rien gagné d'utiliser extend quand nous avons seulement un élément à ajouter.

En outre, ces horaires ne sont pas si importants. Je leur montre juste que pour faire le point que, en Python, faire la chose sémantiquement correcte fait les choses les Droite Façon.

Il est concevable que vous puissiez tester les temps sur deux opérations comparables et obtenir un résultat ambigu ou inverse. Concentrez-vous simplement sur la chose sémantiquement correcte.

Conclusion

On voit ça extend est sémantiquement plus clair, et qu'il peut fonctionner beaucoup plus vite que append, lorsque vous avez l'intention d'ajouter chaque élément dans un itérable à une liste. 

Si vous n'avez qu'un seul élément (pas dans un itérable) à ajouter à la liste, utilisez append.


265
2018-01-23 22:44



append ajoute un seul élément. extend ajoute une liste d'éléments.

Notez que si vous passez une liste à ajouter, elle ajoute toujours un élément:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

92
2017-10-31 05:57



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 que la boucle est implémentée en C.


42
2017-08-20 21:11



Vous pouvez utiliser "+" pour renvoyer extend, au lieu de l'étendre 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 de append & extend. L'une des plus grandes différences de += de append et extend est quand il est utilisé dans les champs d'application, voir ce blog.


29
2017-08-26 11:21



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 instancie réellement une classe, ce qui fait qu'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 dans Python.


29
2017-10-31 13:12



 Ajouter vs étendre

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 voulez étendre plus d'un élément, utilisez extend, car vous ne pouvez ajouter qu'un élément ou une liste d'éléments:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Pour que vous obteniez une liste imbriquée

Au lieu de prolonger, vous pouvez étendre un seul élément comme celui-ci

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

Ou, différemment d'ajouter, étendre plus d'éléments en une fois sans imbriquer la liste dans l'original (c'est la raison du nom étendre)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

 Ajouter un élément avec les deux méthodes

enter image description here

 ajouter un é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, à la place, vous passez une liste en 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]

Donc, avec plus d'éléments, vous utiliserez extend pour obtenir une liste avec plus d'éléments. Vous utiliserez append, pour ajouter pas plus d'éléments à la liste, mais un élément qui est une liste imbriquée comme vous pouvez le voir clairement dans la sortie du code.

enter image description here

enter image description here


17
2017-10-18 07:33



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]

16
2018-05-12 19:51