En Python, quelle est la différence entre ".append()" et "+= []"?

Dans l'exemple que vous avez donné, il n'y a pas de différence, en termes de sortie, entre append et +=. Mais il y a une différence entre append et + (que la question a initialement posée).

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

Comme vous pouvez le voir, append et += ont le même résultat; ils ajouter l'élément à la liste, sans la production d'une nouvelle liste. L'utilisation de + Ajoute les deux listes et produit une nouvelle liste.

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

Voir que append ajoute un seul élément à la liste, qui peut être n'importe quoi. +=[] rejoint les listes.

+= est une affectation. Lorsque vous l'utilisez, vous dites vraiment ' some_list2 = some_list2 + ['something']'. Les affectations impliquent un rebinding, donc:

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

L'opérateur += devrait également normalement créer un nouvel objet list comme list + list le fait normalement:

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

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

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

Cependant en réalité:

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

C'est parce que les listes Python implémentent __iadd__() pour faire une affectation augmentée += court-circuit et liste d'appels.extend() à la place. (C'est un peu une verrue étrange ceci: il est généralement fait ce que vous vouliez dire, mais pour des raisons confuses.)

En général, si vous ajoutez/étendez une liste existante, et que vous voulez garder la référence à la même liste (au lieu d'en faire une nouvelle), il est préférable d'être explicite et de s'en tenir aux méthodes append()/extend ().

 some_list2 += ["something"]

Est en fait

 some_list2.extend(["something"])

Pour une valeur, il n'y a pas de différence. La Documentation indique que:

s.append(x) même que s[len(s):len(s)] = [x]
s.extend(x) même que s[len(s):len(s)] = x

Donc évidemment s.append(x) est la même que s.extend([x])

Les tests de performance ici ne sont pas corrects:

1. vous ne devriez pas exécuter le profil une seule fois.
2. Si vous comparez append vs. + = [] nombre de fois, vous devez déclarer append en tant que fonction locale.
3. les résultats temporels sont différents sur différentes versions de python: 64 et 32 bits

Par exemple

Timeit.Timer ('pour i dans xrange (100): app (i)', 's = []; app = s. append').timeit()

Les bons tests peuvent être trouvé ici: http://markandclick.com/1/post/2012/01/python-list-append-vs.html

La différence est que concaténer aplatissement de la liste des résultats, alors que ajouter permettront de maintenir les niveaux intacte:

Donc par exemple avec:

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

Utiliser append, vous vous retrouvez avec une liste de listes:

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

En utilisant concaténate à la place, vous vous retrouvez avec une liste plate:

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

En plus des aspects décrits dans les autres réponses, append et +[] ont des comportements très différents lorsque vous essayez de créer une liste de listes.

>>> 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'] ajoute '5' et ' 6 ' à la liste1 en tant qu'éléments individuels. list1.ajouter(['5','6']) ajoute la liste ['5','6'] pour le list1 comme un seul élément.

Le comportement de rebinding mentionné dans d'autres réponses a de l'importance dans certaines circonstances:

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

C'est parce que l'affectation augmentée se réinvente toujours, même si l'objet a été muté sur place. Le rebinding ici se trouve être a[1] = *mutated list*, ce qui ne fonctionne pas pour les tuples.

Prenons d'abord un exemple

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