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

Question

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

Answer 1

append : Ajoute un objet à la fin.

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

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

étendre : É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]

Answer 2

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

De Plongez dans Python . / p>

Answer 3

  

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

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

ajouter

La méthode list.append 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 tout autre élément, il est ajouté à la fin de ma_liste 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 objet unique à 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.

expand

La méthode list.extend étend une liste en ajoutant des éléments à partir 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]

N'oubliez pas 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 à chaque itération de 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 d'opérateur, __ add __ ( + ) et __ iadd __ ( + = )

Les opérateurs + et + = sont définis pour liste . 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 ( est l'opérateur sur place et les listes sont des objets mutables, comme nous l'avons vu). ne crée pas de nouvelle liste. Cela fonctionne aussi 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 attribuée à ma_list.

Complexité temporelle

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

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

La itération des multiples appels à append ajoute à la complexité, la rendant équivalente à celle 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 successivement éléments d'un itératif sur une liste.

Performances

Vous vous demandez peut-être 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)

Nous allons donc les chronométrer:

import timeit

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

Adressant un commentaire sur les horaires

Un intervenant a déclaré:

  

Réponse parfaite, je manque 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 d'une variable, utilisez extend . Si vous ajoutez seulement un élément, utilisez append .

Ok, 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 un itératif juste utiliser une extension 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 aucun avantage à utiliser extend si nous n'avons qu'un seul élément à 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 Droite Way & # 8482;.

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 ce qui est sémantiquement correct.

Conclusion

Nous constatons que extend est sémantiquement plus clair et qu'il peut être exécuté beaucoup plus rapidement que append , lorsque vous avez l'intention d'ajouter chaque élément d'un élément itérable à un élément. liste.

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

Answer 4

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

Notez que si vous passez une liste à ajouter, un élément est ajouté:

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

Answer 5

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.

Answer 6

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 Plonger dans Python .

Answer 7

Vous pouvez utiliser " + " pour retourner étendre, 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 un comportement à la place, mais avec de légères différences avec append & amp; expand . L'une des plus grandes différences entre + = et append et extend est son utilisation dans les portées de fonctions, voir ce billet de blog .

Answer 8

  

Ajouter ou é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 seul élément ou une seule liste d'éléments:

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

Pour obtenir une liste imbriquée

Au lieu de cela, vous pouvez étendre un seul élément comme ceci

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

  

Ajout de plus d'éléments ... avec des résultats différents

Si vous utilisez append pour plusieurs éléments, 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, vous passez plutôt 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 non 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.

Answer 9

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 (liste) - 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]

Answer 10

extend () peut être utilisé avec un argument itérateur. Voici un exemple. Vous souhaitez créer une liste à partir d'une liste de listes de la manière suivante:

De

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

vous voulez

>>>
[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 itérateur:

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

Answer 11

Ceci est l'équivalent de append et de extend à l'aide de 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]]

Answer 12

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]

Answer 13

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, il faut considérer que list.extend (transformation_elements) est remplacé.

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" (liste de chaînes).

Answer 14

Ajouter ajoute toutes les données en une fois. L'ensemble des données sera ajouté à l'index nouvellement créé. D'autre part, extend , comme son nom l'indique, étend le tableau actuel.

Par exemple

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

Avec append , nous obtenons:

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

Alors que expand , nous obtenons:

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

Answer 15

Un dictionnaire anglais définit les mots append et expand comme suit:

ajouter : ajoutez (quelque chose) à la fin d'un document écrit.
extension : agrandissez-le. Agrandir ou agrandir

Avec cette connaissance, comprenons maintenant

1) La différence entre append et extend

ajouter :

• Ajoute un 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.)

étendre :

• Accepte n'importe quel itérable comme argument et agrandit 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 valeurs flottantes) résultant de l'application de liste (itérable) . <. / li>

2) Similarité entre append et extend

• Les deux prennent exactement un argument.
• Les deux modifient la liste in-situ .
• Par conséquent, les deux renvoient Aucun .

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)

Answer 16

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 pour et et en générant un objet Info à chaque fois et en utilisant extend pour le stocker dans votre liste, cela é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é.

Answer 17

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 personnes séparées 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'},
                }

Answer 18

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]

Answer 19

append " extend " la liste (en place) par un seul élément , seul objet transmis (en tant qu'argument).

extend " extend " la liste (en place) contient autant d'éléments que l'objet passé (sous forme d'argument) contient.

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

1. Si vous passez une chaîne en argument: append ajoutera un élément de chaîne unique à la fin mais extend ajoutera autant de & single; single " Les éléments 'str' correspondent à la longueur de cette chaîne.
2. Si vous passez une liste de chaînes en argument: append ajoutera toujours un seul élément "liste" à la fin et extend ajoutera autant d'éléments 'list' que la longueur de la liste transmise.

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,

Answer 20

L’ajout et l’extension 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 à la position (longueur + 1).

Insert: La méthode insert a été utilisée pour surmonter les limitations d’append. Avec insert, nous pouvons définir explicitement la position exacte à laquelle nous souhaitons insérer notre nouvel élément.

Description de la méthode d’insertion (index, objet). Il faut deux arguments, l’index que nous voulons insérer et 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 en pos 2, nous obtenons une liste ([3]) au lieu de l'élément. Pour joindre deux listes, nous devrons utiliser append.

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

Pour joindre plusieurs listes

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