python - examples - pandas manual
En Python, ¿cuál es la diferencia entre ".append()" y "+=[]"? (9)
+ = es una tarea. Cuando lo usas, realmente estás diciendo ''some_list2 = some_list2 + ['' something '']''. Las asignaciones implican volver a vincular, entonces:
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
El operador + = normalmente también debería crear un nuevo objeto de lista como list + list normalmente:
>>> l1= []
>>> l2= l1
>>> l1.append(''x'')
>>> l1 is l2
True
>>> l1= l1+[''x'']
>>> l1 is l2
False
Sin embargo, en realidad:
>>> l2= l1
>>> l1+= [''x'']
>>> l1 is l2
True
Esto se debe a que las listas de Python implementan __iadd__() para hacer un cortocircuito de asignación aumentada + = y en su lugar invocar a list.extend (). (Es un poco extraño ver esto: generalmente hace lo que usted quiso decir, pero por razones confusas).
En general, si agrega / amplía una lista existente y desea mantener la referencia a la misma lista (en lugar de crear una nueva), es mejor ser explícito y apegarse al append () / extend () métodos.
Cuál es la diferencia entre:
some_list1 = []
some_list1.append("something")
y
some_list2 = []
some_list2 += ["something"]
Además de los aspectos descritos en las otras respuestas, agregar y + [] tienen comportamientos muy diferentes cuando intentas crear una lista de listas.
>>> 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''] agrega ''5'' y ''6'' a la lista1 como elementos individuales. list1.append ([''5'', ''6'']) agrega la lista [''5'', ''6''] a la lista1 como un elemento único.
El comportamiento de reenlace mencionado en otras respuestas sí importa en ciertas circunstancias:
>>> 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
Esto se debe a que la asignación aumentada siempre se reencuentra, incluso si el objeto fue mutado in situ. El reenlace aquí pasa a ser a[1] = *mutated list*
, que no funciona para tuplas.
En el ejemplo que proporcionó, no hay diferencia, en términos de salida, entre append
y +=
. Pero hay una diferencia entre append
y +
(sobre lo que originalmente se preguntó la pregunta).
>>> 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
Como puede ver, append
y +=
tienen el mismo resultado; agregan el artículo a la lista, sin producir una nueva lista. El uso de +
agrega las dos listas y produce una nueva lista.
La diferencia es que la concatenación aplanará la lista resultante, mientras que append mantendrá los niveles intactos:
Entonces, por ejemplo, con:
myList = [ ]
listA = [1,2,3]
listB = ["a","b","c"]
Usando append, terminas con una lista de listas:
>> myList.append(listA)
>> myList.append(listB)
>> myList
[[1,2,3],[''a'',b'',''c'']]
Usando concatenar en su lugar, terminas con una lista plana:
>> myList += listA + listB
>> myList
[1,2,3,"a","b","c"]
Las pruebas de rendimiento aquí no son correctas:
- No deberías ejecutar el perfil solo una vez.
- Si compara append vs. + = [] número de veces, debe declarar append como función local.
- los resultados de tiempo son diferentes en las diferentes versiones de Python: 64 y 32 bits
p.ej
timeit.Timer (''para i en xrange (100): app (i)'', ''s = []; app = s.append''). timeit ()
buenas pruebas se pueden encontrar aquí: http://markandclick.com/1/post/2012/01/python-list-append-vs.html
Para su caso, la única diferencia es el rendimiento: agregar es dos veces más rápido.
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 general, append
agregará un elemento a la lista, mientras que +=
copiará todos los elementos de la lista del lado derecho en la lista del lado izquierdo.
Actualización: análisis de perf
Comparando bytecodes podemos suponer que la versión LOAD_ATTR
desperdicia ciclos en LOAD_ATTR
+ CALL_FUNCTION
, y + = versión - en BUILD_LIST
. Aparentemente, BUILD_LIST
supera 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
Podemos mejorar el rendimiento aún más al eliminar la LOAD_ATTR
general LOAD_ATTR
:
>>> timeit.Timer(''a("something")'', ''s = []; a = s.append'').timeit()
0.15924410999923566
some_list2 += ["something"]
es en realidad
some_list2.extend(["something"])
por un valor, no hay diferencia. La documentación dice que:
s.append(x)
igual ques[len(s):len(s)] = [x]
s.extend(x)
igual ques[len(s):len(s)] = x
Por lo tanto, obviamente, s.append(x)
es lo mismo que s.extend([x])
>>> a=[]
>>> a.append([1,2])
>>> a
[[1, 2]]
>>> a=[]
>>> a+=[1,2]
>>> a
[1, 2]
Ver que agregar agrega un solo elemento a la lista, que puede ser cualquier cosa. +=[]
une a las listas.