Unterschied zwischen Append- und Erweiterungslistenmethoden in Python

append fügt ein Element zu einer Liste hinzu und extend verknüpft die erste Liste mit einer anderen Liste (oder einer anderen iterierbaren, nicht notwendigerweise einer 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']

Von Eintauchen in Python.

Was ist der Unterschied zwischen den Listenmethoden, die angehängt und erweitert werden?

• append fügt ihr Argument als einzelnes Element am Ende einer Liste hinzu. Die Länge der Liste selbst wird um eins erhöht.
• extend durchläuft sein Argument und fügt jedes Element der Liste hinzu, wodurch die Liste erweitert wird. Die Länge der Liste wird sich dadurch erhöhen, dass viele Elemente im iterierbaren Argument enthalten waren.

append

Die list.append-Methode hängt ein Objekt am Ende der Liste an.

my_list.append(object) 

Was auch immer das Objekt ist, ob eine Zahl, eine Zeichenfolge, eine andere Liste oder etwas anderes, es wird am Ende von my_list als einzelner Eintrag in der Liste hinzugefügt. 

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

Denken Sie daran, dass eine Liste ein Objekt ist. Wenn Sie eine weitere Liste an eine Liste anhängen, ist die erste Liste ein einzelnes Objekt am Ende der Liste (das möglicherweise nicht Ihren Vorstellungen entspricht):

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

Die list.extend-Methode erweitert eine Liste, indem Elemente aus einem iterierbaren Element angehängt werden:

my_list.extend(iterable)

Mit extend wird also jedes Element des Iterierbaren an die Liste angehängt. Zum Beispiel:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Denken Sie daran, dass eine Zeichenfolge eine Iteration ist. Wenn Sie eine Liste mit einer Zeichenfolge erweitern, hängen Sie jedes Zeichen an, während Sie die Zeichenfolge durchlaufen (was möglicherweise nicht das ist, was Sie möchten):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Bedienerüberlastung, __add__ (+) und __iadd__ (+=)

Sowohl + als auch +=-Operatoren sind für list definiert. Sie sind semantisch ähnlich zu erweitern.

my_list + another_list erstellt eine dritte Liste im Speicher, sodass Sie das Ergebnis davon zurückgeben können, aber es muss eine zweite Liste erstellt werden. 

my_list += another_list ändert die In-Place-Liste (ist der In-Place-Operator, und Listen sind, wie wir gesehen haben, veränderliche Objekte), sodass keine neue Liste erstellt wird. Es funktioniert auch so, dass der zweite iterable jede Art von iterable sein kann.

Lassen Sie sich nicht verwirren - my_list = my_list + another_list ist nicht gleichbedeutend mit += - Sie erhalten eine brandneue Liste, die my_list zugewiesen ist.

Zeitkomplexität

Append hat konstante zeitliche Komplexität , O (1). 

Erweitern hat Zeitkomplexität, O (k). 

Das Durchlaufen der mehrfachen Aufrufe von append erhöht die Komplexität und macht sie mit der von extend vergleichbar. Da die Iteration von extend in C implementiert wird, ist es immer schneller, wenn Sie nacheinander Elemente aus einer Iteration an eine Liste anhängen möchten.

Performance

Sie fragen sich vielleicht, was performanter ist, da mit append das gleiche Ergebnis wie mit extend erzielt werden kann. Die folgenden Funktionen machen dasselbe:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Also lass uns mal Zeit haben:

import timeit

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

Kommentieren von Timings

Ein Kommentator sagte:

Perfekte Antwort, ich vermisse nur das Timing, wenn ich nur ein Element hinzufüge

Tun Sie die semantisch korrekte Sache. Wenn Sie alle Elemente in einer Iteration anhängen möchten, verwenden Sie extend. Wenn Sie nur ein Element hinzufügen, verwenden Sie append.

Ok, also lassen Sie uns ein Experiment erstellen, um zu sehen, wie dies rechtzeitig klappt:

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

Und wir sehen, dass es eine (geringfügige) Zeitverschwendung ist, wenn wir alles tun, um ein iterierbares Erweiterungsprogramm zu erstellen:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Wir lernen daraus, dass man mit extend nichts gewinnen kann, wenn wir nur one -Element zum Anhängen haben.

Diese Timings sind auch nicht so wichtig. Ich zeige ihnen nur, dass sie in Python die semantisch korrekte Sache tun, nämlich die Right Way ™.

Es ist denkbar, dass Sie Timings an zwei vergleichbaren Operationen testen und ein mehrdeutiges oder umgekehrtes Ergebnis erhalten. Konzentrieren Sie sich einfach auf die semantisch korrekte Sache.

Fazit

Wir sehen, dass extend semantisch klarer ist und viel schneller als append, ausgeführt werden kann, wenn Sie jedes Element in einer Iteration an eine Liste anhängen möchten. 

Wenn Sie nur ein einzelnes Element (nicht in einem iterierbaren Element) zur Liste hinzufügen möchten, verwenden Sie append.

append hängt ein einzelnes Element an. extend fügt eine Liste von Elementen hinzu.

Wenn Sie eine Liste zum Anhängen übergeben, wird noch ein Element hinzugefügt:

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

Die folgenden zwei Ausschnitte sind semantisch äquivalent:

for item in iterator:
    a_list.append(item)

und

a_list.extend(iterator)

Letzteres kann schneller sein, da die Schleife in C implementiert ist.

Die append () -Methode fügt ein einzelnes Element am Ende der Liste hinzu.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

Die extend () -Methode nimmt ein Argument, eine Liste, und fügt jedes Element des Arguments der ursprünglichen Liste hinzu. (Listen werden als Klassen implementiert. Durch das Erstellen einer Liste wird eine Klasse wirklich instanziiert. Daher verfügt eine Liste über Methoden, die darauf arbeiten.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

Aus In Python eintauchen.

Sie können "+" verwenden, um die Erweiterung zurückzugeben, anstatt sie zu erweitern.

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]

Ähnlich += für In-Place-Verhalten, jedoch mit geringfügigen Unterschieden zu append & extend. Einer der größten Unterschiede von += von append und extend ist, wenn es in Funktionsbereichen verwendet wird, siehe diesem Blogbeitrag .

Append vs Extend

 

Mit Append können Sie ein einzelnes Element anfügen, das die Liste erweitert:

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

Wenn Sie mehrere Elemente erweitern möchten, sollten Sie extend verwenden, da Sie nur ein Element oder eine Liste von Elementen anhängen können:

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

Damit erhalten Sie eine verschachtelte Liste

Statt mit extend können Sie ein einzelnes Element so erweitern

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

Oder, anders als beim Anhängen, mehrere Elemente auf einmal erweitern, ohne die Liste in die ursprüngliche zu verschachteln (das ist der Grund des Namenserweiterung)

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

Hinzufügen eines Elements mit beiden Methoden

1 Element anhängen 

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

ein Element erweitern 

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

Weitere Elemente hinzufügen ... mit unterschiedlichen Ergebnissen 

Wenn Sie append für mehrere Elemente verwenden, müssen Sie eine Liste mit Elementen als Argumente übergeben, und Sie erhalten eine NESTED-Liste!

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

Stattdessen übergeben Sie eine Liste als Argument, aber Sie erhalten eine Liste mit dem neuen Element, die nicht im alten Element verschachtelt ist.

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

Wenn Sie also mehr Elemente verwenden, erhalten Sie extend, um eine Liste mit mehr Elementen zu erhalten. Sie verwenden Anfügen, um nicht weitere Elemente an die Liste anzuhängen, sondern ein Element, das eine verschachtelte Liste ist, wie Sie deutlich in sehen können Ausgabe des Codes.

append(object) - Aktualisiert die Liste durch Hinzufügen eines Objekts zur 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) - Verkettet im Wesentlichen zwei Listen.

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() kann mit einem Iterator-Argument verwendet werden. Hier ist ein Beispiel. Sie möchten eine Liste aus einer Liste auf folgende Weise erstellen:

Von

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

sie wollen

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

Sie können dazu itertools.chain.from_iterable() verwenden. Die Ausgabe dieser Methode ist ein Iterator. Ihre Umsetzung entspricht

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

Zurück zu unserem Beispiel können wir tun

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

und die gewünschte Liste erhalten.

So kann extend() äquivalent mit einem Iterator-Argument verwendet werden:

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

Dies ist das Äquivalent von append und extend mit dem +-Operator:

>>> 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 (): Wird in Python grundsätzlich verwendet, um ein Element hinzuzufügen.

Beispiel 1:

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

Beispiel 2

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

extend (): Where extend () wird verwendet, um zwei Listen zusammenzuführen oder mehrere Elemente in eine Liste einzufügen.

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

Beispiel 2

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

Ein interessanter Punkt, der angedeutet, aber nicht erklärt wurde, ist, dass die Erweiterung schneller ist als das Anhängen. Für jede Schleife, in der sich ein Anhang befindet, sollte davon ausgegangen werden, dass sie durch list.extend (processing_elements) ersetzt wird.

Beachten Sie, dass die Genehmigung neuer Elemente dazu führen kann, dass die gesamte Liste an einem besseren Ort im Speicher gespeichert wird. Wenn dies mehrmals durchgeführt wird, weil jeweils 1 Element angehängt wird, leidet die Gesamtleistung. In diesem Sinne ist list.extend analog zu "" .join (stringlist).

Anhängen fügt alle Daten auf einmal hinzu. Die gesamten Daten werden dem neu erstellten Index hinzugefügt. Andererseits erweitert extend, wie der Name schon sagt, das aktuelle Array. 

Zum Beispiel

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

Mit append erhalten wir:

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

Während auf extend erhalten wir:

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

Ein englisches Wörterbuch definiert die Wörter append und extend als:

append : füge (etwas) am Ende eines schriftlichen Dokuments hinzu. 
extend : größer machen. Vergrößern oder erweitern

Mit diesem Wissen lasst uns jetzt verstehen

1) Der Unterschied zwischen append und extend

append:

• Hängt jedes Python-Objekt unverändert an das Ende der Liste an (d. H. Als letztes Element in der Liste ).
• Die resultierende Liste kann verschachtelt sein und heterogene Elemente enthalten (d. H. Liste, Zeichenfolge, Tuple, Wörterbuch, Gruppe usw.).

extend:

• Akzeptiert ein beliebiges iterable als Argument und macht die Liste größer.
• Die resultierende Liste ist immer eine eindimensionale Liste (d. H. Keine Verschachtelung) und kann heterogene Elemente (z. B. Zeichen, ganze Zahlen, Gleitkommazahlen) als Ergebnis der Anwendung von list(iterable) enthalten.

2) Ähnlichkeit zwischen append und extend

• Beide haben genau ein Argument.
• Beide ändern die Liste in-place.
• Als Ergebnis geben beide None zurück.

Beispiel

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)

Die Methode "append" fügt ihren Parameter als single element zur Liste hinzu, während "extend" eine Liste erhält und deren Inhalt hinzufügt.

Zum Beispiel,

erweitern

    letters = ['a', 'b']
    letters.extend(['c', 'd'])
    print(letters) # ['a', 'b', 'c', 'd']

anhängen

    letters.append(['e', 'f'])
    print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]

Füge ein Wörterbuch zu einem anderen hinzu:

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

Ich hoffe, ich kann diese Frage sinnvoll ergänzen. Wenn in Ihrer Liste ein bestimmtes Typobjekt gespeichert ist, beispielsweise Info, ist dies die Situation, dass die extend-Methode nicht geeignet ist: In einer for-Schleife und wenn Sie jedes Mal ein Info-Objekt generieren und es mit extend in Ihrer Liste speichern, schlägt der Vorgang fehl. Die Ausnahme ist wie folgt:

TypeError: 'Info'-Objekt kann nicht iteriert werden

Wenn Sie jedoch die append-Methode verwenden, ist das Ergebnis in Ordnung. Jedes Mal, wenn Sie die extend-Methode verwenden, wird sie immer als Liste oder einen anderen Auflistungstyp behandelt, iteriert und nach der vorherigen Liste platziert. Ein bestimmtes Objekt kann offensichtlich nicht iteriert werden.

Um sie intuitiv zu unterscheiden

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

Es ist wie l1, einen Körper in ihrem Körper zu reproduzieren (verschachtelt).

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

Es ist so, als würden zwei getrennte Personen heiraten und eine vereinte Familie gründen.

Außerdem mache ich ein ausführliches Cheatsheet mit allen Methoden der Liste als Referenz.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

Anhängen: Fügt die 'Liste' oder 'ein einzelnes Element' am Ende der vorhandenen Liste hinzu

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: fügt der vorhandenen Liste 'Elemente einer Liste' (als Argument übergeben) hinzu.

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

Anhängen: Fügt sein Argument als einzelnes Element am Ende einer Liste hinzu.

z.B:-

my_list = ['stack', 'over'] 
my_list.append('flow') 
print my_list 

Ausgabe:

['stack', 'over', 'flow']

Hinweis: - Wenn Sie eine weitere Liste an eine Liste anhängen, ist die erste Liste ein einzelnes Objekt am Ende der Liste.

z.B:-

my_list = ['stack', 'over', 'flow'] 
another_list = [1,2,3,4] ,
my_list.append(another_list) 
print my_list 

Ausgabe:-

['stack', 'over', 'over', [1,2,3,4]]

extend(): - Durchläuft sein Argument und fügt jedes Element der Liste hinzu und erweitert die Liste. Die Länge der Liste erhöht sich um die Anzahl der Elemente im Argument.

z.B:-

my_list = ['stack', 'over'] 
another_list = [6, 0, 4, 1] 
my_list.extend(another_list) 
print my_list 

Ausgabe:

['stack', 'over', 6, 0, 4, 1]

Hinweis: - Eine Zeichenfolge kann wiederholt werden. Wenn Sie eine Liste mit einer Zeichenfolge erweitern, fügen Sie jedes Zeichen an, wenn Sie die Zeichenfolge durchlaufen.

z.B:-

my_list = ['stack', 'overflow', 6, 0, 4, 1] 
my_list.extend('hello') 
print my_list 

Dies half mir zu verstehen, was wirklich passiert, wenn Sie append und extend verwenden:

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 fügt das übergebene Argument als einzelnes Element hinzu.

extend () wird über die übergebenen Argumente iteriert und erweitert die Liste, indem alle Elemente iteriert übergeben werden. Im Allgemeinen werden mehrere Elemente hinzugefügt, die nicht als Ganzes hinzugefügt werden.

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) erweitert die Liste um alle Elemente der angegebenen Liste 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]