Frage Unterschied zwischen Append und Extend List Methoden in Python


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


2682
2017-10-31 05:55


Ursprung


Antworten:


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 dem Iterablen.

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

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


4073
2017-10-31 06:02



append fügt ein Element zu einer Liste hinzu und extend Verkettet die erste Liste mit einer anderen Liste (oder einer anderen Liste, 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.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 Tauchen Sie in Python ein.


525
2017-10-31 05:57



Was ist der Unterschied zwischen den Listenmethoden append und extend?

  • append fügt sein Argument als einzelnes Element am Ende einer Liste hinzu. Die Länge der Liste wird um eins erhöht.
  • extend iteriert über sein Argument, fügt jedes Element zur Liste hinzu und erweitert die Liste. Die Länge der Liste wird erhöht, wenn sich viele Elemente im iterierbaren Argument befinden.

append

Das list.append Methode 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 von hinzugefügt my_list als einzelner Eintrag in der Liste.

>>> 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 andere Liste an eine Liste anhängen, wird die erste Liste ein einzelnes Objekt am Ende der Liste sein (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 on end of list.

extend

Das list.extend Methode erweitert eine Liste durch Anhängen von Elementen aus einem iterablen:

my_list.extend(iterable)

Mit extend wird jedes Element des Iterablen an die Liste angehängt. Beispielsweise:

>>> 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 iterierbar ist. Wenn Sie also eine Liste mit einer Zeichenfolge erweitern, werden Sie jedes Zeichen anhängen, wenn Sie über die Zeichenfolge (die möglicherweise nicht Ihren Vorstellungen entspricht) übergehen.

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

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

Beide + und += Operatoren sind definiert für list. Sie sind semantisch ähnlich zu erweitern.

my_list + another_list erstellt eine dritte Liste im Speicher, so dass Sie das Ergebnis davon zurückgeben können, aber es erfordert, dass das zweite iterable eine Liste sein muss.

my_list += another_list ändert die Liste an Ort und Stelle (es ist der In-Place-Operator und Listen sind veränderbare Objekte, wie wir gesehen haben, so dass es keine neue Liste erstellt. Es funktioniert auch wie erweitert, in dem das zweite iterable irgendeine Art von iterable sein kann.

Verwechsle dich nicht - my_list = my_list + another_list ist nicht gleichbedeutend mit += - Es gibt Ihnen eine brandneue Liste, die my_list zugeordnet ist.

Zeitkomplexität

Anhängen hat konstante Zeitkomplexität, O (1).

Extend hat Zeitkomplexität, O (k).

Iterieren durch die Mehrfachanrufe nach append fügt zu der Komplexität hinzu und macht sie äquivalent zu der von extend, und da die Iteration von extend in C implementiert ist, wird sie immer schneller sein, wenn Sie beabsichtigen, aufeinanderfolgende Elemente von einer iterierbaren auf eine Liste anzuhängen.

Performance

Sie fragen sich vielleicht, was leistungsfähiger ist, da append verwendet werden kann, um das gleiche Ergebnis wie extend zu erreichen. Die folgenden Funktionen machen das Gleiche:

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

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

Also lass uns mal Zeit nehmen:

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 das Timing des Vergleichs nur ein Element hinzufügen

Mach das semantisch korrekte Ding. Wenn Sie alle Elemente iterativ anhängen möchten, verwenden Sie extend. Wenn Sie nur ein Element hinzufügen, verwenden Sie append.

Ok, lassen Sie uns ein Experiment erstellen, um zu sehen, wie dies in der Zeit 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, einen iterierbaren Extend zu erstellen,

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

Wir lernen daraus, dass durch den Gebrauch nichts gewonnen wird extend wenn wir nur haben ein Element zum Anhängen.

Auch diese Zeiten sind nicht so wichtig. Ich zeige ihnen nur, um zu verdeutlichen, dass in Python die semantisch korrekte Sache zu tun ist Recht Weg.

Es ist denkbar, dass Sie Timings für zwei vergleichbare Operationen testen und ein mehrdeutiges oder inverses Ergebnis erhalten. Konzentriere dich nur auf die semantisch korrekte Sache.

Fazit

Wir sehen das extend ist semantisch klarer und kann viel schneller laufen als append, wenn Sie beabsichtigen, jedes Element in einer Liste an eine Liste anzuhängen. 

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


265
2018-01-23 22:44



append hängt ein einzelnes Element an. extend hängt eine Liste von Elementen an.

Beachten Sie, dass beim Übergeben einer anzuhängenden Liste immer noch ein Element hinzugefügt wird:

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

92
2017-10-31 05:57



Die folgenden zwei Snippets 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.


42
2017-08-20 21:11



Sie können "+" verwenden, um die Ausdehnung zurückzugeben, anstatt sich an Ort und Stelle zu erstrecken.

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 situ Verhalten, aber mit leichten Unterschieden von append & extend. Einer der größten Unterschiede von += von append und extend ist, wenn es in Funktionsbereichen verwendet wird, siehe dieser Blogbeitrag.


29
2017-08-26 11:21



Die Methode append () 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 hängt jedes der Elemente des Arguments an die ursprüngliche Liste an. (Listen werden als Klassen implementiert. Beim Erstellen einer Liste wird eine Klasse tatsächlich instanziiert. Daher gibt es in einer Liste 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']

Von Tauche in Python ein.


29
2017-10-31 13:12



 Append vs Extend

enter image description here

Mit append 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 extend verwenden, da Sie nur eine Element oder eine Elementliste anhängen können:

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

Damit erhalten Sie eine verschachtelte Liste

Stattdessen können Sie mit extend ein einzelnes Element erweitern

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

Oder, anders als append, erweitern Sie mehr Elemente auf einmal, ohne die Liste in die ursprüngliche zu verschachteln (das ist der Grund für den Namen extend)

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

 Ein Element mit beiden Methoden hinzufügen

enter image description here

 füge 1 Element hinzu

>>> 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 von mehr Elementen ... mit unterschiedlichen Ergebnissen

Wenn Sie für mehr als ein Element append 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 extend übergeben Sie stattdessen eine Liste als Argument, aber Sie erhalten eine Liste mit dem neuen Element, die nicht in der 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 mehr Elementen zu erhalten. Sie verwenden append, 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.

enter image description here

enter image description here


17
2017-10-18 07:33



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) - Im Wesentlichen verkettet 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]

16
2018-05-12 19:51



extend() kann mit einem Iterator-Argument verwendet werden. Hier ist ein Beispiel. Sie möchten auf diese Weise eine Liste aus Listen erstellen:

Von

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

Sie wollen

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

Sie dürfen verwenden itertools.chain.from_iterable() um es zu tun. Die Ausgabe dieser Methode ist ein Iterator. Seine Implementierung 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 Fahndungsliste bekommen.

Hier ist wie äquivalent extend() kann 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]

15
2018-05-12 18:21