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

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]

appendajoute un élément à une liste et extendconcatène la première liste avec une autre liste (ou un 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.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']

Quelle est la différence entre les méthodes de liste ajoutées et étendues?

• appendajoute 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é.
• extenditère sur son argument en ajoutant chaque élément à la liste, en étendant la liste. La longueur de la liste augmentera d'autant que de nombreux éléments figuraient dans l'argument itérable.

append

La list.appendmé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 d' my_listune seule entrée de 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 (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 list.extendméthode étend une liste en ajoutant des éléments à partir d'un itérable:

my_list.extend(iterable)

Ainsi, 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 itérable, donc si vous étendez une liste avec une chaîne, vous ajouterez chaque caractère pendant que vous parcourez 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 définis pour list. Ils sont sémantiquement similaires à étendre.

my_list + another_list crée une troisième liste en mémoire, vous pouvez donc en renvoyer le résultat, mais il faut que le deuxième itérable soit une liste.

my_list += another_listmodifie la liste en place (il est l'opérateur en place, et les listes sont des objets mutables, comme nous l' avons vu) il ne crée pas une nouvelle liste. Il fonctionne également comme extend, en ce que le deuxième itérable peut être n'importe quel type d'itérable.

Ne vous trompez pas - my_list = my_list + another_listn'est pas équivalent à +=- cela vous donne une toute nouvelle liste affectée à my_list.

Complexité temporelle

Append a une complexité temporelle constante , O (1).

Étendre a une complexité temporelle, O (k).

L'itération à travers les multiples appels à appendajoute à la complexité, ce qui la rend équivalente à celle d'Extend, et puisque l'itération d'Extend est implémentée en 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 vous demandez peut-être ce qui est plus performant, car ajouter peut être utilisé pour obtenir le même résultat que prolonger. 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 intervenant a déclaré:

Réponse parfaite, je manque juste le moment de comparer l'ajout d'un seul élément

Faites la chose sémantiquement correcte. Si vous souhaitez ajouter tous les éléments dans un itérable, utilisez extend. Si vous ajoutez juste un élément, utilisez append.

Ok, créons donc 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 chemin pour créer un itérable juste pour utiliser extend 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 à gagner à utiliser extendquand nous n'avons qu'un seul élément à ajouter.

De plus, ces horaires ne sont pas si importants. Je leur montre simplement qu'ils font valoir qu'en Python, faire ce qui est sémantiquement correct, c'est faire les choses de la bonne façon ™.

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

Conclusion

Nous voyons extendest sémantiquement plus claire, et qu'il peut fonctionner beaucoup plus rapidement que append, lorsque vous avez l' intention d'ajouter chaque élément dans un itérables à une liste.

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

appendajoute un seul élément. extendajoute 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]]

Ajouter vs étendre

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 plusieurs éléments, vous devez utiliser 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 obtenir une liste imbriquée

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

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

Ou, différemment, à partir de l'ajout, étendez plus d'éléments en une seule fois sans imbriquer la liste dans l'original (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

L'ajout et l'extension peuvent ajouter un élément à la fin de la liste, bien que l'ajout soit plus simple.

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]

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]

Ainsi, avec plus d'éléments, vous utiliserez extend pour obtenir une liste avec plus d'éléments. Cependant, l'ajout d'une liste n'ajoutera 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.

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

La append()méthode 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 extend()méthode 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. La «création» d'une liste instancie vraiment 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 Dive Into Python .

Vous pouvez utiliser "+" pour renvoyer extend, au lieu d'é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 par rapport à append& extend. L' une des plus grandes différences de +=partir appendet extendest quand il est utilisé dans des étendues de fonction, voir ce billet de blog .

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 à partir 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 ce faire. La sortie de cette méthode est un itérateur. Sa mise en œuvre équivaut à

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

Revenons à notre exemple, nous pouvons le 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 l'équivalent extend()peut être utilisé avec un argument itérateur:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

C'est l'équivalent de appendet en extendutilisant 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 (), est utilisé pour 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é suggéré, mais non expliqué, est que l'extension est plus rapide que l'ajout. Pour toute boucle qui a ajouté à l'intérieur doit être considérée comme remplacée par list.extend (processor_elements).

Gardez à l'esprit que l'approbation de nouveaux éléments peut entraîner la réallocation de la liste entière à un meilleur emplacement en mémoire. Si cela est fait plusieurs fois parce que nous ajoutons 1 élément à la fois, les performances globales en souffrent. En ce sens, list.extend est analogue à "" .join (stringlist).

Append ajoute toutes les données à la fois. Toutes les données seront ajoutées à l'index nouvellement créé. D'autre part, extendcomme son nom l'indique, étend le tableau actuel.

Par exemple

list1 = [123, 456, 678]
list2 = [111, 222]

Avec appendnous obtenons:

result = [123, 456, 678, [111, 222]]

Pendant que extendnous obtenons:

result = [123, 456, 678, 111, 222]

Un dictionnaire anglais définit les mots appendet extendcomme:

ajouter : ajouter (quelque chose) à la fin d'un document écrit.
étendre : agrandir. Agrandir ou agrandir

Avec cette connaissance, comprenons maintenant

1) La différence entre appendetextend

append:

• Ajoute tout 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 (c.-à-d. Liste, chaîne, tuple, dictionnaire, ensemble, etc.)

extend:

• Accepte tout itérables comme argument et fait la liste plus .
• La liste résultante est toujours une liste unidimensionnelle (c'est-à-dire pas d'imbrication) et elle peut contenir des éléments hétérogènes (par exemple des caractères, des entiers, des flottants) à la suite de l'application list(iterable).

2) Similitude entre appendetextend

• Les deux prennent exactement un argument.
• Les deux modifient la liste sur place .
• En conséquence, les deux reviennent 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
list.append(object)

J'espère pouvoir apporter un complément utile à cette question. Si votre liste stocke un objet de type spécifique, par exemple Info, voici une situation où la extendméthode n'est pas appropriée: dans une forboucle et et en générant un Infoobjet à chaque fois et en l'utilisant extendpour 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 appendméthode, le résultat est OK. Parce que chaque fois que vous utilisez la extendméthode, il la traitera toujours comme une liste ou tout autre type de collection, l'itérera et la placera après la liste précédente. Un objet spécifique ne peut pas être itéré, évidemment.

Les distinguer intuitivement

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

C'est comme l1reproduire un corps à l'intérieur de son corps (imbriqué).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

C'est comme si deux personnes séparées se marient et construisent 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'},
                }

extend(L)étend 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]

append"étend" la liste (en place) par un seul élément , l'objet unique transmis (comme argument).

extend"étend" la liste (en place) par autant d'éléments que contient l'objet (comme argument).

Cela peut être légèrement déroutant pour les strobjets.

1. Si vous passez une chaîne en argument: appendajoutera un seul élément de chaîne à la fin mais extendajoutera autant d'éléments "str" ​​"simples" que la longueur de cette chaîne.
2. Si vous passez une liste de chaînes comme argument: appendajoutera toujours un seul élément 'liste' à la fin et extendajoutera autant d'éléments 'liste' que la longueur de la liste passée.

def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

produit:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

Ajouter et étendre sont l'un des mécanismes d'extensibilité en python.

Ajouter: ajoute un élément à la fin de la liste.

my_list = [1,2,3,4]

Pour ajouter un nouvel élément à la liste, nous pouvons utiliser la méthode append de la manière suivante.

my_list.append(5)

L'emplacement par défaut auquel le nouvel élément sera ajouté est toujours en position (longueur + 1).

Insertion: La méthode d'insertion a été utilisée pour surmonter les limitations de l'ajout. Avec insert, nous pouvons définir explicitement la position exacte à laquelle nous voulons que notre nouvel élément soit inséré.

Descripteur de méthode d'insertion (index, objet). Il prend deux arguments, tout d'abord l'indice que nous voulons insérer notre élément et ensuite l'élément lui-même.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Étendre: Ceci est très utile lorsque nous voulons joindre deux ou plusieurs listes en une seule liste. Sans extension, si nous voulons joindre deux listes, l'objet résultant contiendra une liste de listes.

a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]

Si nous essayons d'accéder à l'élément à la pos 2, nous obtenons une liste ([3]), au lieu de l'élément. Pour rejoindre deux listes, nous devrons utiliser append.

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

Pour rejoindre plusieurs listes

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]