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

3116

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

Claudiu
quelle

Antworten:

5251

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]

Kender
quelle
122
Was ist der Unterschied zwischen extendund einfach mit dem Additionsoperator - im obigen Beispiel x = x + [4, 5]?
Rohan
303
Tatsächlich gibt es einen großen Unterschied - x + [4, 5]gibt Ihnen eine neue Liste, die x zugewiesen ist - x.extend()mutiert die ursprüngliche Liste. Ich werde in meiner Antwort hier unten näher darauf eingehen.
Aaron Hall
@AaronHall @Rohan aber es ist das gleiche wie x += [4,5].
Astitva Srivastava
1
@AstitvaSrivastava Eigentlich denke ich, dass Extend in Bezug auf Bytecode schneller ist
MilkyWay90
1
Das Schlüsselwort bei der Verwendung appendist Object . Wenn Sie versuchen, extendein Wörterbuch zu verwenden, und es übergeben , wird der Schlüssel und nicht der gesamte Hash an das Ende des Arrays angehängt.
Anthony
640

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']
Harley Holcombe
quelle
489

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.

Aaron Hall
quelle
1
@ Aaron Hall Ein kleiner Kommentar im Algorithmus für das Timing. "verlängern_one" kann "leicht falsche" Zeit zurückgeben, da auch das Erstellen einer Liste beteiligt ist. Wahrscheinlich ist es besser, die Elemente als Variablen ( ex1 = 0und ex2 = [0]) zu erstellen und diese Variablen zu übergeben, wenn Sie strenger sein möchten.
Ilias Iliadis
19
Perfekte Antwort in der Tat. Was ist mit der Leistung von l1 += l2vs l1.extend(l2)?
Jean-Francois T.
6
@ Jean-FrancoisT.: l1 += l2Und l1.extend(l2)letztendlich den gleichen Code ausführen (die list_extendFunktion in listobject.c). Die einzigen Unterschiede sind: 1. +=Neuzuweisung l1(für sich selbst list, aber die Neuzuweisung unterstützt unveränderliche Typen, die danach nicht mehr dasselbe Objekt sind), was es illegal macht, wenn l1es sich tatsächlich um ein Attribut eines unveränderlichen Objekts handelt; zum Beispiel t = ([],), t[0] += lstwürde scheitern, während t[0].extend(lst)funktionieren würde. 2. l1 += l2verwendet dedizierte Bytecodes, während l1.extend(l2)der allgemeine Methodenversand verwendet wird; das macht +=schneller als extend.
ShadowRanger
3
Die Tatsache, dass eine +=Neuzuweisung l1erforderlich ist, bedeutet, dass in einigen Fällen der langsamere Versand extendteilweise oder vollständig dadurch ausgeglichen wird, dass nicht auf der linken Seite zurück zugewiesen wird . Zum Beispiel, wenn das listein Attribut eines Objekts ist self.l1 += l2und self.l1.extend(l2)bei meiner Python 3.6-Installation die gleiche Leistung aufweist, einfach weil eine echte Operation eher so ist self.l1 = self.l1.__iadd__(l2), was bedeutet, dass sie eine mäßig teure Leistung erbringen muss STORE_ATTR, self.l1.extend(l2)die nicht erforderlich ist.
ShadowRanger
2
Einfacher Vergleich in lokalen Tests: Für eine lokale Variable (die +=nur verwendet wird STORE_FAST, was sehr billig ist), bei der der hinzugefügte Wert ein vorhandener listmit einem Element ist, wobei die Operation 1000-mal wiederholt wurde, +=dauerte die Operation durchschnittlich etwa 33 ns , während extend78 ns dauerte, eine Differenz von 45 ns. Wenn l1es sich um ein globales System handelt (das teurer ist STORE_GLOBAL), verringert sich der Unterschied auf 17 ns. Wenn l1tatsächlich local.l1(erfordert noch teurer STORE_ATTR), gibt es keinen bedeutenden Unterschied zwischen +=und extend(Timings ungefähr identisch; extendmanchmal gewinnt).
ShadowRanger
121

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]]
Greg Hewgill
quelle
62

Anhängen gegen Erweitern

Geben Sie hier die Bildbeschreibung ein

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

Geben Sie hier die Bildbeschreibung ein

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.

Geben Sie hier die Bildbeschreibung ein

Geben Sie hier die Bildbeschreibung ein

Giovanni G. PY
quelle
61

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.

Erik
quelle
20
Das Erweitern ist auf meinem Computer ~ 4x schneller als das Anhängen in einer Schleife (16us vs 4us für 100 Schleifen von Nullen)
Alex L
6
extend()wahrscheinlich vorbelegt, append()wahrscheinlich nicht.
Mad Physicist
@MadPhysicist: Der Vollständigkeit halber würde es Zeiten geben, in denen extend() eine sinnlose Vorbelegung nicht möglich ist, da einige Iterables nicht implementiert werden __len__(), aber wie Sie wäre ich überrascht, wenn es nicht versucht wird. Ein Teil des Leistungsgewinns resultiert auch aus dem Iterationsteil in reinem C anstelle von Python, wie in Aarons Antwort ausgeführt .
Soren Bjornstad
44

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 .

CodyChan
quelle
Sie können nicht mit nur 6 verlängern, da es nicht iterierbar ist. Und die zweite Ausgabe in Ihrem Beispiel ist falsch. 'abc' wird als einzelnes Element hinzugefügt, da Sie es extendals Liste mit einem Element übergeben haben ['abc']: [1, 2, 3, 4, 5, 'abc']. Ändern Sie die abc-Zeile in : x.extend('abc'). Und entfernen Sie das x.extend(6)oder ändern Sie es in x.extend([6]).
Aneroid
37

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 .

denfromufa
quelle
Hat die Verwendung des '+' für die Rückgabe von verlängern einen Einfluss auf die Zeitkomplexität?
Franklin
5
@franklin, siehe diese Antwort für Details: stackoverflow.com/a/28119966/2230844
denfromufa
1
Ich sehe nicht, wie dies die Frage beantwortet
pppery
22

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]
Chaitanya
quelle
20

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]
kiriloff
quelle
2
Diese Antwort steht nicht im Gegensatz zum Anhängen und beantwortet daher nicht die Frage
pppery
19

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]]
skdev75
quelle
Warum nicht = + ?! Prägnanter
denfromufa
16

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]
Der Gr8 Adakron
quelle
12

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

bconstanzo
quelle
12

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]
Shiv
quelle
8

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)
kmario23
quelle
5

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.

Crabime
quelle
4

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'},
                }
Infinitesimalrechnung
quelle
2

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]
Tessie
quelle
0

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,
ilias iliadis
quelle
0

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]
vivek
quelle
2
Warum beantworten Sie eine Frage, die bereits oft beantwortet wurde? Diese Frage ist 10 Jahre alt ...
Mike - SMT