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: append 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 les éléments tous de la liste de droite dans la liste de gauche.
Mise à jour: Perf analyse
En comparant les bytecodes, nous pouvons supposer que la version append perd les cycles dans LOAD_ATTR + CALL_FUNCTION et + = version - dans BUILD_LIST. Apparemment, BUILD_LIST l'emporte 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 la surcharge LOAD_ATTR:
>>> timeit.Timer('a("something")', 's = []; a = s.append').timeit()
0.15924410999923566
Dans l'exemple que vous avez donné, il n'y a aucune différence, en termes de sortie, entre append et +=. Mais il y a une différence entre append et + (ce à quoi la question avait été posée à 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 constater, append et += ont le même résultat; ils ajoutent l'élément à la liste, sans produire une nouvelle liste. Utiliser + ajoute les deux listes et génère 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 cession. Lorsque vous l’utilisez, vous dites vraiment "some_list2 = some_list2 + ['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 + = doit également normalement créer un nouvel objet de liste, comme le fait par exemple 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
Cela est dû au fait que les listes Python implémentent __iadd __ () pour créer un court-circuit d’affectation augmentée + = et call list.extend (). (C'est un peu étrange comme ceci: cela fait habituellement ce que vous vouliez dire, mais pour des raisons confuses.)
En général, si vous ajoutez/prolongez 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 à la méthode 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)identique às[len(s):len(s)] = x
Donc, évidemment, s.append(x) est identique à s.extend([x])
La différence est que enchaîner va aplatir la liste résultante, alors que ajouter 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 obtenez une liste plate:
>> myList += listA + listB
>> myList
[1,2,3,"a","b","c"]
Les tests de performance ici ne sont pas corrects:
- Vous ne devriez pas exécuter le profil une seule fois.
- Si vous comparez append contre + = [] nombre de fois, vous devez déclarer append en tant que fonction locale.
- les résultats temporels sont différents selon les versions de python: 64 et 32 bits
par exemple.
timeit.Timer ('pour i dans 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
Outre les aspects décrits dans les autres réponses, les expressions 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'] à list1 en tant qu'élément unique.
Le comportement de réinsertion 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 liée, même si l'objet a été muté sur place. La reliure ici se trouve être a[1] = *mutated list*, ce qui ne fonctionne pas pour les n-uplets.
La méthode append () ajoute un seul élément à la liste existante. Il ne renvoie pas de nouvelle liste, mais modifie la liste d'origine.
some_list1 = []
some_list1.append("something")
Donc ici la some_list1 sera modifiée.
Alors que l'utilisation de + pour combiner les éléments de listes renvoie une nouvelle liste.
some_list2 = []
some_list2 += ["something"]
Donc, ici, some_list2 et ["quelque chose"] sont les deux listes qui sont combinées et une nouvelle liste est renvoyée, qui est assignée à some_list2
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