Was ist der Unterschied zwischen den Listenmethoden append()und extend()?

append: Hängt das Objekt am Ende an.

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

gibt Ihnen: [1, 2, 3, [4, 5]]

extend: Erweitert die Liste durch Anhängen von Elementen aus der Iterable.

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

gibt Ihnen: [1, 2, 3, 4, 5]

appendFügt einer Liste ein Element hinzu und extendverkettet die erste Liste mit einer anderen Liste (oder einer anderen iterierbaren, nicht unbedingt 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', ['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']

Was ist der Unterschied zwischen den Listenmethoden zum Anhängen und Erweitern?

• appendfügt sein Argument als einzelnes Element am Ende einer Liste hinzu. Die Länge der Liste selbst wird um eins erhöht.
• extenditeriert über sein Argument und fügt jedes Element zur Liste hinzu, wodurch die Liste erweitert wird. Die Länge der Liste erhöht sich um die Anzahl der Elemente im iterierbaren Argument.

append

Die list.appendMethode hängt ein Objekt an das 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 my_listals einzelner Eintrag in der Liste hinzugefügt .

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

Denken Sie also daran, dass eine Liste ein Objekt ist. Wenn Sie eine andere Liste an eine Liste anhängen, ist die erste Liste ein einzelnes Objekt am Ende der Liste (was möglicherweise nicht Ihren Wünschen 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.extendMethode erweitert eine Liste durch Anhängen von Elementen aus einer iterierbaren Datei:

my_list.extend(iterable)

Mit expand wird also jedes Element der Iterable 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 iterierbar ist. Wenn Sie also eine Liste mit einer Zeichenfolge erweitern, hängen Sie jedes Zeichen an, während Sie über die Zeichenfolge iterieren (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 definiert list. Sie sind semantisch ähnlich zu erweitern.

my_list + another_list Erstellt eine dritte Liste im Speicher, sodass Sie das Ergebnis zurückgeben können. Die zweite iterierbare Liste muss jedoch eine Liste sein.

my_list += another_listÄndert die Liste an Ort und Stelle (es ist der Operator an Ort und Stelle, und Listen sind veränderbare Objekte, wie wir gesehen haben), sodass keine neue Liste erstellt wird. Es funktioniert auch wie Extend, da das zweite Iterable jede Art von Iterable sein kann.

Seien Sie nicht verwirrt - my_list = my_list + another_listist nicht gleichbedeutend mit +=- es gibt Ihnen eine brandneue Liste, die my_list zugewiesen ist.

Zeitliche Komplexität

Anhängen hat eine konstante zeitliche Komplexität , O (1).

Erweitern hat Zeitkomplexität, O (k).

Das Durchlaufen der mehreren Aufrufe erhöht appenddie Komplexität und entspricht damit der Erweiterung. Da die Iteration von extens in C implementiert ist, ist sie immer schneller, wenn Sie aufeinanderfolgende Elemente aus einer iterierbaren Datei an eine Liste anhängen möchten.

Performance

Sie fragen sich vielleicht, was leistungsfähiger ist, da Anhängen verwendet werden kann, um das gleiche Ergebnis wie Erweitern zu erzielen. Die folgenden Funktionen machen dasselbe:

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

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

Also lasst uns sie zeitlich festlegen:

import timeit

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

Adressierung eines Kommentars zu Timings

Ein Kommentator sagte:

Perfekte Antwort, ich vermisse nur den Zeitpunkt des Vergleichs, indem ich nur ein Element hinzufüge

Mach das semantisch Richtige. Wenn Sie alle Elemente in einer Iterable 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 funktioniert:

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, sich die Mühe zu machen, eine iterierbare Erweiterung zu erstellen, um sie nur zu verwenden:

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

Wir lernen daraus, dass die Verwendung nichts bringt, extendwenn wir nur ein Element anhängen müssen.

Auch diese Timings sind nicht so wichtig. Ich zeige ihnen nur, um zu verdeutlichen, dass in Python das semantisch Richtige die Dinge auf die richtige Art und Weise tun .

Es ist denkbar, dass Sie Timings an zwei vergleichbaren Operationen testen und ein mehrdeutiges oder inverses Ergebnis erhalten. Konzentrieren Sie sich einfach darauf, das semantisch Richtige zu tun.

Fazit

Wir sehen , dass extendsemantisch klarer, und dass es als viel schneller ausgeführt werden können append, wenn Sie beabsichtigen , jedes Element in einer iterable zu einer Liste anzuhängen.

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

appendfügt ein einzelnes Element hinzu. extendHängt eine Liste von Elementen an.

Beachten Sie, dass beim Übergeben einer Liste zum Anhängen immer noch ein Element hinzugefügt wird:

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

Anhängen gegen Erweitern

Mit Anhängen können Sie ein einzelnes Element anhängen, das die Liste erweitert:

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

Wenn Sie mehr als ein Element erweitern möchten, sollten Sie verlängern 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 Sie eine verschachtelte Liste erhalten

Stattdessen können Sie mit verlängern ein einzelnes Element wie dieses erweitern

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

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

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

Hinzufügen eines Elements mit beiden Methoden

Sowohl Anhängen als auch Erweitern können ein Element am Ende der Liste hinzufügen, obwohl das Anhängen einfacher ist.

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]

Hinzufügen weiterer Elemente ... mit unterschiedlichen Ergebnissen

Wenn Sie append für mehr als ein Element verwenden, müssen Sie eine Liste von Elementen als Argumente übergeben, und Sie erhalten eine NESTED-Liste!

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

Mit verlängern übergeben Sie stattdessen eine Liste als Argument, erhalten jedoch eine Liste mit dem neuen Element, das nicht im alten verschachtelt ist.

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

Mit mehr Elementen verwenden Sie "Erweitern", um eine Liste mit mehr Elementen zu erhalten. Durch das Anhängen einer Liste werden jedoch keine weiteren Elemente zur Liste hinzugefügt, sondern ein Element, das eine verschachtelte Liste ist, wie Sie in der Ausgabe des Codes deutlich sehen können.

Die folgenden zwei Schnipsel sind semantisch äquivalent:

for item in iterator:
    a_list.append(item)

und

a_list.extend(iterator)

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

Die append()Methode fügt am Ende der Liste ein einzelnes Element 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 verwendet ein Argument, eine Liste, und hängt jedes Element des Arguments an die ursprüngliche Liste an. (Listen werden als Klassen implementiert. Durch das „Erstellen“ einer Liste wird eine Klasse wirklich instanziiert. Daher verfügt eine Liste über Methoden, die darauf angewendet werden.)

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

Vom Tauchen in Python .

Sie können "+" verwenden, um "verlängern" zurückzugeben, anstatt an Ort und Stelle zu verlängern.

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]

Ähnliches gilt +=für das Verhalten an Ort und Stelle, jedoch mit geringfügigen Abweichungen von append& extend. Einer der größten Unterschiede von +=aus appendund extendist , wenn es in Funktion Bereichen verwendet wird, finden Sie diese Blog - Post .

append(object) - Aktualisiert die Liste, indem der Liste ein Objekt hinzugefügt wird.

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 Iteratorargument verwendet werden. Hier ist ein Beispiel. Sie möchten eine Liste aus einer Liste von Listen 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 dies verwenden itertools.chain.from_iterable(). Die Ausgabe dieser Methode ist ein Iterator. Seine 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 holen Sie sich die Fahndungsliste.

So extend()kann ein Iterator-Argument gleichwertig verwendet werden:

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

Dies entspricht dem Operator appendund dessen extendVerwendung +:

>>> 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 () : In Python wird grundsätzlich ein Element hinzugefügt.

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

verlängern () : Wobei verlängern () verwendet wird, 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 das Erweitern schneller ist als das Anhängen. Für jede Schleife, in der Anhänge enthalten sind, sollte davon ausgegangen werden, dass sie durch list.extend (process_elements) ersetzt wird.

Beachten Sie, dass das Zulassen neuer Elemente dazu führen kann, dass die gesamte Liste an einen besseren Speicherort verschoben 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 die gesamten Daten auf einmal hinzu. Die gesamten Daten werden dem neu erstellten Index hinzugefügt. Auf der anderen Seite wird extend, wie der Name schon sagt, das aktuelle Array erweitert.

Zum Beispiel

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

Mit appendbekommen wir:

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

Währenddessen erhalten extendwir:

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

Ein englisches Wörterbuch definiert die Wörter appendund extendals:

anhängen : am Ende eines schriftlichen Dokuments (etwas) hinzufügen.
verlängern : größer machen. Vergrößern oder erweitern

Mit diesem Wissen wollen wir jetzt verstehen

1) Der Unterschied zwischen appendundextend

append::

• Hängt jedes Python-Objekt unverändert an das Ende der Liste an (dh als letztes Element in der Liste).
• Die resultierende Liste kann verschachtelt sein und heterogene Elemente enthalten (z. B. Liste, Zeichenfolge, Tupel, Wörterbuch, Satz usw.).

extend::

• Akzeptiert jedes iterable als Argument und vergrößert die Liste .
• Die resultierende Liste ist immer eine eindimensionale Liste (dh keine Verschachtelung) und kann aufgrund der Anwendung heterogene Elemente (z. B. Zeichen, Ganzzahlen, Gleitkommazahlen) enthalten list(iterable).

2) Ähnlichkeit zwischen appendundextend

• Beide nehmen genau ein Argument.
• Beide ändern die Liste direkt .
• Infolgedessen kehren beide zurück None.

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
list.append(object)

Ich hoffe, ich kann diese Frage sinnvoll ergänzen. Wenn Ihre Liste beispielsweise ein bestimmtes Typobjekt speichert Info, ist diese extendMethode in einer Situation nicht geeignet: In einer forSchleife und Infojedes Mal, wenn ein Objekt generiert und extendzum Speichern in Ihrer Liste verwendet wird, schlägt dies fehl. Die Ausnahme ist wie folgt:

TypeError: Das Objekt 'Info' kann nicht iteriert werden

Wenn Sie jedoch die appendMethode verwenden, ist das Ergebnis in Ordnung. Da die extendMethode jedes Mal verwendet wird, wird sie immer als Liste oder ein anderer Auflistungstyp behandelt, iteriert und nach der vorherigen Liste platziert. Ein bestimmtes Objekt kann natürlich 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, als würde man l1einen Körper in ihrem Körper reproduzieren (verschachtelt).

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

Es ist so, dass zwei getrennte Personen heiraten und eine vereinte Familie bilden.

Außerdem erstelle ich ein ausführliches Cheatsheet aller Methoden der Liste als Referenz.

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

extend(L)Erweitert die Liste, indem alle Elemente in der angegebenen Liste angehängt werden 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"erweitert" die Liste (an Ort und Stelle) um nur ein Element , das einzelne übergebene Objekt (als Argument).

extend"erweitert" die Liste (an Ort und Stelle) um so viele Elemente, wie das übergebene Objekt (als Argument) enthält.

Dies kann für strObjekte etwas verwirrend sein .

1. Wenn Sie eine Zeichenfolge als Argument übergeben: Fügt appendam Ende ein einzelnes Zeichenfolgenelement hinzu, extendfügt jedoch so viele "einzelne" "str" ​​-Elemente wie die Länge dieser Zeichenfolge hinzu.
2. Wenn Sie eine Liste von Zeichenfolgen als Argument übergeben: Fügt appendam Ende immer noch ein einzelnes Listenelement hinzu und extendfügt so viele Listenelemente hinzu, wie die Länge der übergebenen Liste beträgt.

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

produziert:

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

Anhängen und Erweitern sind einer der Erweiterungsmechanismen in Python.

Anhängen: Fügt am Ende der Liste ein Element hinzu.

my_list = [1,2,3,4]

Um der Liste ein neues Element hinzuzufügen, können Sie die Append-Methode folgendermaßen verwenden.

my_list.append(5)

Die Standardposition, an der das neue Element hinzugefügt wird, befindet sich immer an der Position (Länge + 1).

Einfügen: Die Einfügemethode wurde verwendet, um die Einschränkungen des Anhängens zu überwinden. Mit Einfügen können wir explizit die genaue Position definieren, an der unser neues Element eingefügt werden soll.

Methodendeskriptor der Einfügung (Index, Objekt). Es werden zwei Argumente benötigt: erstens der Index, in den wir unser Element einfügen möchten, und zweitens das Element selbst.

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

Erweitern: Dies ist sehr nützlich, wenn zwei oder mehr Listen zu einer einzigen Liste zusammengefasst werden sollen. Wenn wir zwei Listen verbinden möchten, enthält das resultierende Objekt ohne Erweiterung eine Liste von Listen.

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

Wenn wir versuchen, auf das Element in Position 2 zuzugreifen, erhalten wir anstelle des Elements eine Liste ([3]). Um zwei Listen zu verbinden, müssen wir append verwenden.

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

Mehrere Listen verbinden

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