W Pythonie, jaka jest różnica między ".append () "i" + = []"?

W podanym przykładzie nie ma różnicy, jeśli chodzi o wynik, pomiędzy append i +=. Ale jest różnica między append i + (o czym pierwotnie zadano pytanie).

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

Jak widać, append i += mają ten sam wynik; dodają element do listy, bez tworzenia nowej listy. Użycie + dodaje dwie listy i tworzy nową listę.

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

Zobacz, że append dodaje pojedynczy element do listy, którym może być cokolwiek. +=[] dołącza do listy.

+ = to zadanie. Kiedy go używasz, mówisz " some_list2= some_list2+['something']". Zadania obejmują rebinding, więc:

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

Operator += powinien również normalnie utworzyć nowy obiekt list, jak list + list normalnie robi:

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

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

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

Jednak w rzeczywistości:

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

Dzieje się tak dlatego, że listy Pythona implementują _ _ iadd_ _ () , aby utworzyć zwarcie i listę połączeń z przypisaniem + = augmented.zamiast tego extend (). (To jest trochę dziwne brodawki to: to zwykle robi to, co miałeś na myśli, ale z mylących powodów.)

Ogólnie rzecz biorąc, jeśli dodajesz / rozszerzasz istniejącą listę i chcesz zachować odniesienie do tej samej listy (zamiast tworzyć nową), najlepiej jest być jawnym i trzymać się metod append()/extend ().

 some_list2 += ["something"]

Jest rzeczywiście

 some_list2.extend(["something"])

Dla jednej wartości nie ma różnicy. Dokumentacja stwierdza, że:

s.append(x) tak samo jak s[len(s):len(s)] = [x]
s.extend(x) to samo co s[len(s):len(s)] = x

Zatem oczywiście s.append(x) jest tym samym co s.extend([x])

Testy wydajności tutaj nie są poprawne:

1. nie powinieneś uruchomić profilu tylko raz.
2. porównując append vs. + = [] ilość razy powinieneś zadeklarować append jako funkcję lokalną.
3. wyniki czasowe są różne w różnych wersjach Pythona: 64 i 32-bitowych

Np.

Timeit.Timer ('for I in xrange(100): app(I)', 's = []; app = s. append').timeit ()

Dobre testy mogą być znaleziono tutaj: http://markandclick.com/1/post/2012/01/python-list-append-vs.html

Różnica polega na tym, że konkatenat będzie spłaszczyć wynikową listę, natomiast Dołącz zachowa poziom nienaruszony:

Więc na przykład z:

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

Używając append, kończysz z listą list:

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

Zamiast tego używając concatenate, kończysz z płaską listą:

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

Oprócz aspektów opisanych w innych odpowiedziach, append i +[] mają bardzo różne zachowania, gdy próbujesz zbudować listę list.

>>> 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]]

Lista1+['5','6'] dodaje "5" i " 6 " do listy1 jako poszczególne elementy. lista1.Dołącz(['5','6']) dodaje listę ['5', '6'] do listy1 jako pojedynczy element.

Zachowanie rebinding wymienione w innych odpowiedziach ma znaczenie w pewnych okolicznościach:

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

To dlatego, że przydział Rozszerzony zawsze się zmienia, nawet jeśli obiekt został zmutowany na miejscu. Rebinding tutaj jest a[1] = *mutated list*, który nie działa dla krotek.

Weźmy najpierw przykład

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