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

Quelle est la différence entre:

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

et

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

Pour votre cas, la seule différence est la performance: l'ajout est deux fois plus rapide.

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

En général append, ajoutera un élément à la liste, tandis que +=copiera tous les éléments de la liste de droite dans la liste de gauche.

Mise à jour: analyse des performances

En comparant les bytecodes, nous pouvons supposer que la appendversion gaspille des cycles en LOAD_ATTR+ CALL_FUNCTIONet + = version - en BUILD_LIST. Apparemment, l' BUILD_LISTemporte sur LOAD_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

Nous pouvons encore améliorer les performances en supprimant les LOAD_ATTRfrais généraux:

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

Dans l'exemple que vous avez donné, il n'y a pas de différence, en termes de rendement, entre appendet +=. Mais il y a une différence entre appendet +(que la question posait à l'origine).

>>> 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, appendet +=avoir le même résultat; ils ajoutent l'élément à la liste, sans produire de nouvelle liste. L'utilisation +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. Quand vous l'utilisez, vous dites vraiment "une_liste2 = une_liste2 + [" quelque chose "]". Les affectations impliquent une nouvelle liaison, 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 créer normalement un nouvel objet de liste comme le fait normalement list + list:

>>> 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 créer un court-circuit d'affectation + = augmenté et appeler à la place list.extend (). (C'est un peu une verrue étrange ceci: cela fait généralement ce que vous vouliez dire, mais pour des raisons déroutantes.)

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

 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) identique s[len(s):len(s)] = [x]
s.extend(x) às[len(s):len(s)] = x

C'est donc évidemment la s.append(x)même chose ques.extend([x])

La différence est que concaténer aplatit la liste résultante, tandis que append gardera les niveaux intacts:

Donc par exemple avec:

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

En utilisant 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éner à la place, vous vous retrouvez avec une liste plate:

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

Les tests de performance ici ne sont pas corrects:

1. Vous ne devez pas exécuter le profil une seule fois.
2. Si vous comparez append à + = [] nombre de fois, vous devez déclarer append comme une fonction locale.
3. les résultats temporels sont différents selon les versions de python: 64 et 32 ​​bits

par exemple

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

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

En plus des aspects décrits dans les autres réponses, ajouter et + [] ont des comportements très différents lorsque vous essayez de construire 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.append (['5', '6']) ajoute la liste ['5', '6'] à la liste1 en tant qu'élément unique.

Le comportement de réengagement 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

En effet, l'affectation augmentée est toujours reliée, même si l'objet a été muté sur place. La reliure se trouve ici 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 

La méthode append () ajoute un seul élément à la liste existante

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

Donc, ici, some_list1 sera modifié.

Actualisé:

Tandis que l'utilisation de + pour combiner les éléments de listes (plus d'un élément) dans la liste existante similaire à l'extension (comme corrigé par Flux ).

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

Alors ici, some_list2 et ["something"] sont les deux listes qui sont combinées.

"+" ne modifie pas la liste

.append () mute l'ancienne liste