Was ist der Unterschied zwischen den Listenmethoden von Python angehängt und erweitert?
https://stackoverflow.com/questions/252703
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Was ist der Unterschied zwischen den Listenmethoden append() und extend()?
Andere Tipps
append fügt einer Liste ein Element hinzu und extend verkettet die erste Liste mit einer anderen Liste (oder einer anderen iterbaren, nicht unbedingt eine 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 angehängt und erweitert?
appendFügt sein Argument als einzelnes Element zum Ende einer Liste hinzu. Die Länge der Liste selbst erhöht sich um eins.extendIteriert das Argument, das jedes Element zur Liste hinzufügt und die Liste erweitert. Die Länge der Liste wird sich um das iterable Argument erhöhen.
append
Das list.append Die Methode wendet ein Objekt am Ende der Liste an.
my_list.append(object)
Was auch immer das Objekt ist, ob eine Nummer, eine Zeichenfolge, eine andere Liste oder etwas anderes, es wird am Ende von hinzugefügt my_list Als einzelner Eintrag auf der Liste.
>>> 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 am Ende der Liste ein einzelnes Objekt (was möglicherweise nicht das ist, was Sie wollen):
>>> 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
Das list.extend Die Methode erweitert eine Liste, indem Elemente von einem iterablen angehängt werden:
my_list.extend(iterable)
Mit Erweiterung wird jedes Element des iterablen 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]
Beachten Sie, dass eine Zeichenfolge eine iterable ist. Wenn Sie also eine Liste mit einer Zeichenfolge erweitern, geben Sie jedes Zeichen an, während Sie über die Zeichenfolge iterieren (was möglicherweise nicht das ist, was Sie wollen):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
Bedienerüberlastung, __add__ (+) und __iadd__ (+=)
Beide + und += Betreiber sind definiert für list. Sie ähneln semantisch dem Erweiterung.
my_list + another_list Erstellt eine dritte Liste im Speicher, sodass Sie das Ergebnis zurückgeben können, aber es erfordert, dass die zweite iterable eine Liste ist.
my_list += another_list ändert die Liste an Ort ist Der In-Place-Operator und Listen sind, wie wir gesehen haben, veränderliche Objekte), sodass er keine neue Liste erstellt. Es funktioniert auch wie Extend, da das zweite iterable jede Art von iterierbar sein kann.
Sei nicht verwirrt - my_list = my_list + another_list ist nicht gleichwertig zu += - Es gibt Ihnen eine brandneue Liste, die My_List zugeordnet ist.
Zeitkomplexität
Append hat Konstante Zeitkomplexität, O (1).
Extend hat Zeitkomplexität, O (k).
Durch die mehrfachen Anrufe durch append Fügt die Komplexität hinzu, wodurch sie der von Extend äquivalent macht, und da die Iteration von Extend in C implementiert ist, wird es immer schneller sein, wenn Sie beabsichtige, aufeinanderfolgende Elemente von einer Iterable auf eine Liste anzuhängen.
Leistung
Sie fragen sich vielleicht, was Performanten ist, da der Anhang verwendet werden kann, um das gleiche Ergebnis zu erzielen, wie sie erweitert wird. Die folgenden Funktionen tun dasselbe:
def append(alist, iterable):
for item in iterable:
alist.append(item)
def extend(alist, iterable):
alist.extend(iterable)
Ziehen wir also mit ihnen:
import timeit
>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883
Einen Kommentar zu Timings eingehen
Ein Kommentator sagte:
Perfekte Antwort, ich vermisse nur das Timing des Vergleichs des Hinzufügens nur ein Element
Mach das semantisch korrekte Sache. Wenn Sie alle Elemente in einem iterablen anhängen möchten, verwenden Sie die Verwendung 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, eine iterable zu erstellen, nur um zu verwenden, um zu verwenden, ist eine (geringfügige) Zeitverschwendung:
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
Wir lernen daraus, dass durch die Verwendung nichts gewonnen wird extend Wenn wir nur haben eines Element angehängt.
Auch diese Zeiten sind nicht so wichtig. Ich zeige ihnen nur, dass sie in Python darauf hingewiesen werden, dass das semantisch korrekte Dinge Dinge tut Recht Way ™.
Es ist denkbar, dass Sie den Zeitpunkt auf zwei vergleichbare Operationen testen und ein mehrdeutiges oder inverses Ergebnis erzielen können. Konzentrieren Sie sich einfach darauf, das semantisch korrekte Ding zu tun.
Fazit
Wir sehen das extend ist semantisch klarer und kann viel schneller laufen als append, Wenn Sie beabsichtigen, jedes Element in eine Iterable an eine Liste anzuhängen.
Wenn Sie nur ein einzelnes Element (nicht in einem iterablen) zur hinzugefügten Liste haben, verwenden Sie die Liste append.
append findet ein einzelnes Element an. extend Fängt eine Liste von Elementen an.
Beachten Sie, dass wenn Sie eine Liste an angehängt übergeben, immer noch ein Element hinzugefügt wird:
>>> 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, wenn die Schleife in C implementiert ist.
Das append() Die Methode fügt zum 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']
Das extend() Die Methode nimmt ein Argument, eine Liste, und nimmt jedes der Elemente des Arguments an die ursprüngliche Liste an. (Listen werden als Klassen implementiert. „Erstellen“ einer Liste ist wirklich eine Klasse. Als solche enthält eine Liste Methoden, die darauf funktionieren.)
x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']
Sie können "+" für die Rückkehr verlängern, anstatt sich 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 an Ort und Stelle, aber mit geringfügigen Unterschieden von append & extend. Einer der größten Unterschiede von += aus append und extend ist, wenn es in Funktionsbereiche verwendet wird, siehe Dieser Blog -Beitrag.
Append vs erweitert
Mit Anhang 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 Erweiterung verwenden, da Sie nur eine Elemente oder eine Liste von Elementen anhängen können:
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
So dass Sie eine verschachtelte Liste erhalten
Stattdessen können Sie mit Extend ein einzelnes Element wie dieses erweitern
>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]
Oder unterschiedlich als Append mehr Elemente in einer Zeit erweitern, ohne die Liste in das ursprüngliche zu verzahlen (das ist der Grund, warum sich der Name erweitert)
>>> 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]
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 erhalten eine verschachtelte Liste!
>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]
Mit Extend vergeben 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 Extend, um eine Liste mit weiteren Elementen zu erhalten. Sie werden Append verwenden, um nicht mehr Elemente an die Liste anzuhängen, sondern ein Element, das eine verschachtelte Liste ist, wie Sie in der Ausgabe des Codes deutlich angezeigt werden können.
append(object) - Aktualisiert die Liste, indem ein Objekt zur Liste 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 auf diese Weise eine Liste aus einer Liste von Listen erstellen:
Aus
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
Sie wollen
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Sie können verwenden itertools.chain.from_iterable() dazu. Die Ausgabe dieser Methode ist ein Iterator. Seine Implementierung entspricht zu
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 gewünschte Liste.
Hier ist, wie äquivalent extend() kann mit einem Iteratorargument 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 Verwendung der + 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 (): Es wird im Grunde in Python 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]]
erweitern(): Wo extend () verwendet wird, um zwei Listen zu verschmelzen 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 Verlängerung schneller als angehängt ist. Für jede Schleife, die angehängt ist, sollte angesehen werden, dass sie durch list.extend (processed_elements) ersetzt werden.
Beachten Sie, dass die Zustimmung neuer Elemente zur Umsetzung der gesamten Liste an einen besseren Ort im Speicher führen kann. Wenn dies mehrmals erfolgt, weil wir jeweils 1 Element anhängen, leidet die Gesamtleistung. In diesem Sinne ist List.extend analog zu "" .Join (StringList).
Append fügt die gesamten Daten gleichzeitig hinzu. Die gesamten Daten werden dem neu erstellten Index hinzugefügt. Auf der anderen Seite, extend, Wie der Name schon sagt, erweitert das aktuelle Array.
Zum Beispiel
list1 = [123, 456, 678]
list2 = [111, 222]
Mit append wir bekommen:
result = [123, 456, 678, [111, 222]]
Während der Zeit extend wir bekommen:
result = [123, 456, 678, 111, 222]
Ein englisches Wörterbuch definiert die Wörter append und extend wie:
anhängen: Fügen Sie (etwas) zum Ende eines schriftlichen Dokuments hinzu.
erweitern: Machen Sie größer. Vergrößern oder erweitern
Lassen Sie uns jetzt mit diesem Wissen verstehen
1) Der Unterschied zwischen append und extend
append:
- Angehängt Jedes Python-Objekt As-is is bis zum Ende der Liste (dh als letztes Element in der Liste).
- Die resultierende Liste kann verschachtelt sein und heterogene Elemente enthalten (dh List, String, Tupel, Wörterbuch, Set usw.)
extend:
- Akzeptiert jeden wiederholbar als Argument und macht die Liste größer.
- Die resultierende Liste ist immer eine dimensionale Liste (dh keine Verschachtung) und kann heterogene Elemente enthalten (z.
list(iterable).
2) Ähnlichkeit zwischen append und extend
- Beide nimmt genau ein Argument.
- Beide ändern die Liste an Ort und Stelle.
- Infolgedessen Rückgaben
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
lis.append(object)
Ich hoffe, ich kann eine nützliche Ergänzung zu dieser Frage machen. Wenn in Ihrer Liste ein bestimmtes Typ -Objekt speichert, zum Beispiel Info, hier ist eine Situation, die extend Methode ist nicht geeignet: in a for Schleife und und erzeugen eine Info Objekt jedes Mal und verwenden extend Um es in Ihre Liste zu speichern, wird es scheitern. Die Ausnahme ist wie unten:
TypeError: 'Info' Objekt ist nicht iterierbar
Aber wenn Sie das verwenden append Methode, das Ergebnis ist in Ordnung. Denn jedes Mal mit dem extend Methode, es wird es immer als Liste oder einen anderen Sammlungstyp behandeln, sie wiederholen und nach der vorherigen Liste platzieren. Ein bestimmtes Objekt kann offensichtlich nicht iteriert werden.
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 reproduzieren Sie einen Körper in ihrem Körper (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 Vereinigte Familie bauen.
Außerdem mache ich ein umfassendes Cheatsheet aus allen Methoden der Liste für Ihre 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 Sie alle Elemente in der angegebenen Liste anhängen 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 (vorhanden) von Nur ein Artikel, das einzelne Objekt bestanden (als Argument).
extend "erweitert" die Liste (vorhanden) von so viele Gegenstände als Das übergebene Objekt (als Argument) enthält.
Dies kann etwas verwirrend sein für str Objekte.
- Wenn Sie eine Zeichenfolge als Argument übergeben:
appendfügt am Ende aber ein einzelnes String -Element hinzuextendFügen Sie so viele "Single" 'Str' -Elemente wie die Länge dieser Zeichenfolge hinzu. - Wenn Sie eine Liste von Zeichenfolgen als Argument bestehen:
appendfügt am Ende und weiterhin ein einzelnes 'List' -Element hinzu undextendFügt so viele 'List' -Elemente wie die Länge der übergebenen Liste hinzu.
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 Erweiterung sind eine der Erweiterbarkeitsmechanismen in Python.
Anhängen: Fügt dem Ende der Liste ein Element hinzu.
my_list = [1,2,3,4]
Um der Liste ein neues Element hinzuzufügen, können wir die Append -Methode folgendermaßen verwenden.
my_list.append(5)
Der Standardpunkt, an dem das neue Element hinzugefügt wird, befindet sich immer in der Position (Länge+1).
Einfügen: Die Einfügungsmethode wurde verwendet, um die Einschränkungen des Anhangs zu überwinden. Mit Insert können wir explizit die genaue Position definieren, in der unser neues Element eingefügt wird.
Methode Deskriptor von Insert (Index, Objekt). Es braucht zwei Argumente, die zunächst der Index sind, den wir unser Element einfügen und das Element selbst zweiten.
Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']
Erweitern Sie: Dies ist sehr nützlich, wenn wir zwei oder mehr Listen in eine einzelne Liste beitreten möchten. Wenn wir zwei Listen beitreten möchten, enthält das resultierende Objekt eine Liste von Listen.
a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]
Wenn wir versuchen, auf das Element bei POS 2 zuzugreifen, erhalten wir eine Liste ([3]) anstelle des Elements. Um zwei Listen anzuschließen, müssen wir Append verwenden.
a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]
Um mehrere Listen anzuschließen
a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]
