it-swarm.com.de

Was ist der Unterschied zwischen ".append ()" und "+ = []" in Python?

Was ist der Unterschied zwischen:

some_list1 = []
some_list1.append("something")

und

some_list2 = []
some_list2 += ["something"]
115
Nope

Für Ihren Fall ist der einzige Unterschied die Leistung: Das Anfügen ist doppelt so schnell.

Python 3.0 (r30:67507, Dec  3 2008, 20:14:27) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.Timer('s.append("something")', 's = []').timeit()
0.20177424499999999
>>> timeit.Timer('s += ["something"]', 's = []').timeit()
0.41192320500000079

Python 2.5.1 (r251:54863, Apr 18 2007, 08:51:08) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.Timer('s.append("something")', 's = []').timeit()
0.23079359499999999
>>> timeit.Timer('s += ["something"]', 's = []').timeit()
0.44208112500000141

Im Allgemeinen fügt append ein Element zur Liste hinzu, während +=alle -Elemente der rechten Liste in die linke Liste kopiert.

Update: Perf-Analyse

Beim Vergleich von Bytecodes können wir davon ausgehen, dass append version Zyklen in LOAD_ATTR + CALL_FUNCTION und + = version - in BUILD_LIST verschwendet. Anscheinend überwiegt BUILD_LISTLOAD_ATTR + CALL_FUNCTION

>>> import dis
>>> dis.dis(compile("s = []; s.append('spam')", '', 'exec'))
  1           0 BUILD_LIST               0
              3 STORE_NAME               0 (s)
              6 LOAD_NAME                0 (s)
              9 LOAD_ATTR                1 (append)
             12 LOAD_CONST               0 ('spam')
             15 CALL_FUNCTION            1
             18 POP_TOP
             19 LOAD_CONST               1 (None)
             22 RETURN_VALUE
>>> dis.dis(compile("s = []; s += ['spam']", '', 'exec'))
  1           0 BUILD_LIST               0
              3 STORE_NAME               0 (s)
              6 LOAD_NAME                0 (s)
              9 LOAD_CONST               0 ('spam')
             12 BUILD_LIST               1
             15 INPLACE_ADD
             16 STORE_NAME               0 (s)
             19 LOAD_CONST               1 (None)
             22 RETURN_VALUE

Wir können die Leistung noch weiter verbessern, indem Sie LOAD_ATTR-Overhead entfernen:

>>> timeit.Timer('a("something")', 's = []; a = s.append').timeit()
0.15924410999923566
158
Constantin

In dem von Ihnen angegebenen Beispiel gibt es hinsichtlich der Ausgabe keinen Unterschied zwischen append und +=. Es gibt jedoch einen Unterschied zwischen append und + (worüber die Frage ursprünglich gestellt wurde).

>>> a = []
>>> id(a)
11814312
>>> a.append("hello")
>>> id(a)
11814312

>>> b = []
>>> id(b)
11828720
>>> c = b + ["hello"]
>>> id(c)
11833752
>>> b += ["hello"]
>>> id(b)
11828720

Wie Sie sehen, haben append und += dasselbe Ergebnis; Sie fügen das Element der Liste hinzu, ohne eine neue Liste zu erstellen. Mit + werden die beiden Listen hinzugefügt und eine neue Liste erstellt.

47
DNS
>>> a=[]
>>> a.append([1,2])
>>> a
[[1, 2]]
>>> a=[]
>>> a+=[1,2]
>>> a
[1, 2]

In diesem Anhang wird der Liste ein einzelnes Element hinzugefügt. +=[] verbindet die Listen.

39
dwc

+ = ist eine Zuordnung. Wenn Sie es verwenden, sagen Sie wirklich "some_list2 = some_list2 + [" irgendwas "]". Zuweisungen beinhalten die Neubindung, also:

l= []

def a1(x):
    l.append(x) # works

def a2(x):
    l= l+[x] # assign to l, makes l local
             # so attempt to read l for addition gives UnboundLocalError

def a3(x):
    l+= [x]  # fails for the same reason

Der Operator + = sollte normalerweise auch ein neues Listenobjekt erstellen, wie list + list normalerweise:

>>> l1= []
>>> l2= l1

>>> l1.append('x')
>>> l1 is l2
True

>>> l1= l1+['x']
>>> l1 is l2
False

In der Realität jedoch:

>>> l2= l1
>>> l1+= ['x']
>>> l1 is l2
True

Dies liegt daran, dass Python-Listen __iadd __ () implementieren, um stattdessen einen + = erweiterten Kurzschluss für Zuweisungen zu erstellen und list.extend () aufzurufen. (Dies ist ein bisschen eine seltsame Warze: Normalerweise macht es das, was Sie meinten, aber aus verwirrenden Gründen.)

Wenn Sie eine vorhandene Liste hinzufügen/erweitern und den Verweis auf derselben Liste beibehalten (anstatt eine neue Liste zu erstellen), ist es im Allgemeinen am besten, explizit zu sein und bei append ()/extend () zu bleiben. Methoden.

29
bobince
 some_list2 += ["something"]

ist eigentlich 

 some_list2.extend(["something"])

für einen Wert gibt es keinen Unterschied. Die Dokumentation besagt, dass:

s.append(x) wie s[len(s):len(s)] = [x] 
s.extend(x) wie s[len(s):len(s)] = x

Natürlich ist s.append(x) das Gleiche wie s.extend([x])

20
vartec

Der Unterschied ist das verketten wird die resultierende Liste abflachen, während anhängen hält die Ebenen intakt:

Also zum Beispiel mit:

myList = [ ]
listA = [1,2,3]
listB = ["a","b","c"]

Mit append erhalten Sie eine Liste mit Listen:

>> myList.append(listA)
>> myList.append(listB)
>> myList
[[1,2,3],['a',b','c']]

Verwenden Sie stattdessen verketten, erhalten Sie eine flache Liste:

>> myList += listA + listB
>> myList
[1,2,3,"a","b","c"]
6
SRC2

Die Leistungstests hier sind nicht korrekt:

  1. Sie sollten das Profil nicht nur einmal ausführen.
  2. Beim Vergleich von Anhängen vs. + = [] sollten Sie Anhänge als lokale Funktion deklarieren.
  3. die Zeitergebnisse unterscheiden sich bei verschiedenen Python-Versionen: 64 und 32 Bit

z.B. 

timeit.Timer ('für i in xrange (100): app (i)', 's = []; app = s.append'). timeit () 

gute Tests finden Sie hier: http://markandclick.com/1/post/2012/01/python-list-append-vs.html

5
Michael

Zusätzlich zu den in den anderen Antworten beschriebenen Aspekten weisen append und + [] sehr unterschiedliche Verhaltensweisen auf, wenn Sie versuchen, eine Liste mit Listen zu erstellen.

>>> list1=[[1,2],[3,4]]
>>> list2=[5,6]
>>> list3=list1+list2
>>> list3
[[1, 2], [3, 4], 5, 6]
>>> list1.append(list2)
>>> list1
[[1, 2], [3, 4], [5, 6]]

list1 + ['5', '6'] fügt '5' und '6' als einzelnes Element zu list1 hinzu. list1.append (['5', '6']) fügt der list1 die Liste ['5', '6'] als einzelnes Element hinzu.

3
Chris Upchurch

Das in anderen Antworten erwähnte Umbindungsverhalten spielt unter bestimmten Umständen eine Rolle:

>>> a = ([],[])
>>> a[0].append(1)
>>> a
([1], [])
>>> a[1] += [1]
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
TypeError: 'Tuple' object does not support item assignment

Das liegt daran, dass die erweiterte Zuordnung immer neu gebunden wird, auch wenn das Objekt an Ort und Stelle mutiert wurde. Das Umbinden hier ist zufällig a[1] = *mutated list*, was bei Tupeln nicht funktioniert.

2
WolframH

Die Methode append () fügt der vorhandenen Liste ein einzelnes Element hinzu. Es wird keine neue Liste zurückgegeben, sondern die ursprüngliche Liste geändert.

some_list1 = []
some_list1.append("something")

Hier wird also die some_list1 geändert.

Während mit + die Elemente von Listen kombiniert werden, wird eine neue Liste zurückgegeben.

some_list2 = []
some_list2 += ["something"]

Hier sind also some_list2 und ["something"] die beiden Listen, die kombiniert werden, und es wird eine neue Liste zurückgegeben, die some_list2 zugewiesen wird

0
Naveen Verma

nehmen wir zuerst ein Beispiel

list1=[1,2,3,4]
list2=list1     (that means they points to same object)

if we do 
list1=list1+[5]    it will create a new object of list
print(list1)       output [1,2,3,4,5] 
print(list2)       output [1,2,3,4]

but if we append  then 
list1.append(5)     no new object of list created
print(list1)       output [1,2,3,4,5] 
print(list2)       output [1,2,3,4,5]

extend(list) also do the same work as append it just append a list instead of a 
single variable 
0
Avnish kumar