multiple - python list of lists




Unterschied zwischen Append- und Erweiterungslistenmethoden in Python (16)

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 Sie eine verschachtelte Liste bekommen

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, erweitern Sie mehrere Elemente auf einmal, 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, das nicht im alten Element verschachtelt ist.

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

Mit mehr Elementen werden Sie also mit extend eine Liste mit mehr Elementen erhalten. Sie verwenden Anhängen, 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 sehen können.

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


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

  • append fügt sein Argument als einzelnes Element am Ende einer Liste hinzu. Die Länge der Liste selbst wird um eins erhöht.
  • extend überlä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 als ein einzelner Eintrag in der Liste am Ende von my_list 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, fügen Sie jedes Zeichen an, wenn 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']

Operator-Überladung, __add__ ( + ) und __iadd__ ( += )

Für die list sind sowohl + als auch += Operatoren 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. Es muss jedoch die zweite Liste, die durchläuft werden kann, sein.

my_list += another_list ändert die Liste an Ort und Stelle (es handelt sich dabei um den 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 entspricht nicht += - Sie erhalten eine brandneue Liste, die my_list zugewiesen ist.

Zeitkomplexität

Append hat eine konstante Zeitkomplexität , O (1).

Erweitern hat Zeitkomplexität, O (k).

Das Durchlaufen mehrerer Aufrufe zum append erhöht die Komplexität und entspricht damit der von extend. Da die Iteration von extend in C implementiert wird, ist es immer schneller, wenn Sie aufeinanderfolgende Elemente aus einer iterierbaren Liste 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:

import timeit

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

Kommentar zu Timings

Ein Kommentator sagte:

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

Tun Sie die semantisch korrekte Sache. Wenn Sie alle Elemente in einem iterierbaren Element 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, 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 der Verwendung von extend nichts gewinnen kann extend wenn wir nur ein Element anhängen müssen.

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

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 das append , 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 .


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

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

my_list = [1,2,3,4]

Um der Liste ein neues Element hinzuzufügen, können wir die append-Methode auf folgende Weise 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ügungsmethode wurde verwendet, um die Einschränkungen von Append zu überwinden. Mit insert können wir die genaue Position explizit definieren, an der unser neues Element eingefügt werden soll.

Methodendeskriptor der Einfügung (Index, Objekt). Es braucht zwei Argumente, erstens den Index, in den wir unser Element einfügen wollen, 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 wir zwei oder mehr Listen zu einer einzigen Liste zusammenfassen möchten. Ohne Erweiterungen enthält das Ergebnisobjekt eine Liste von Listen, wenn wir zwei Listen zusammenfügen möchten.

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

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

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

Um mehrere Listen zusammenzufassen

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

Die Methode "append" fügt der Liste ihren Parameter als einzelnes Element 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']]

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.


Dies entspricht dem 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]]

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

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

Mit diesem Wissen, lasst uns jetzt verstehen

1) Der Unterschied zwischen append und extend

append :

  • Hängt ein beliebiges Python-Objekt unverändert an das Ende der Liste (dh als letztes Element in der Liste).
  • Die resultierende Liste kann verschachtelt sein und heterogene Elemente enthalten (z. B. Liste, String, Tupel, Wörterbuch, Gruppe 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 heterogene Elemente enthalten (z. B. Zeichen, Ganzzahlen, Gleitkommazahlen), wenn eine list(iterable) .

2) Ähnlichkeit zwischen append und extend

  • Beide haben genau ein Argument.
  • Beide ändern die Liste direkt .
  • Als Ergebnis geben beide 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)

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


Ich hoffe, ich kann diese Frage sinnvoll ergänzen. Wenn Ihre Liste ein bestimmtes Typobjekt speichert, z. B. Info , ist dies eine Situation, in der die extend nicht geeignet ist: In einer for Schleife und einem Info Objekt, das jedes Mal generiert wird, und durch Verwendung von extend in der Liste gespeichert wird, schlägt dies 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. Natürlich kann ein bestimmtes Objekt nicht wiederholt werden.


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 und extend . Einer der größten Unterschiede von += vom append und extend besteht darin, dass es in Funktionsbereichen verwendet wird. Siehe diesen Blogbeitrag .


extend (L) erweitert die Liste, indem alle Elemente der angegebenen Liste L angehängt werden.

>>> 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 : Fügt das Objekt am Ende an.

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

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

extend : extend Liste, indem Elemente aus dem iterierbaren Element angehängt werden.

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

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


append "erweitert" die Liste (in place) um nur ein Element , das einzeln übergebenes Objekt (als Argument).

extend "erweitert" die Liste (in place) um so viele Elemente, wie das übergebene Objekt (als Argument) enthält.

Dies kann für str Objekte etwas verwirrend sein.

  1. Wenn Sie eine Zeichenfolge als Argument übergeben: append fügt am Ende ein einzelnes Zeichenfolgenelement hinzu. Bei der extend werden jedoch so viele "einzelne" "str" ​​-Elemente als Länge dieser Zeichenfolge hinzugefügt.
  2. Wenn Sie eine Liste mit Strings als Argument übergeben: append fügt am Ende immer noch ein einzelnes "Listen" -Element hinzu und extend fügt so viele "Listen" -Elemente hinzu, wie die Länge der übergebenen Liste ist.
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,

append fügt ein Element zu einer Liste hinzu und extend 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', 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']

Vom Eintauchen in Python .


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 itertools.chain.from_iterable() dazu 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 erhalte die gewünschte Liste.

Äquivalent kann extend() 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]

append () : Im Grunde wird es 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]]

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]






extend