En Python, ¿cuál es la diferencia entre “.append()” y “+= []”?
-
05-09-2019 - |
Pregunta
Cuál es la diferencia entre:
some_list1 = []
some_list1.append("something")
y
some_list2 = []
some_list2 += ["something"]
Solución
En su caso, la única diferencia es el rendimiento:. Append 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 el caso general, append
añadirá un elemento de la lista, mientras +=
copiará todos elementos de la lista del lado derecho en la lista del lado de la mano izquierda.
Actualización: Potencia del análisis
La comparación de los códigos de bytes que podemos asumir que la versión append
desechos ciclos en LOAD_ATTR
+ CALL_FUNCTION
y + = Versión - en BUILD_LIST
. Al parecer 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 aún más el rendimiento mediante la eliminación de sobrecarga LOAD_ATTR
:
>>> timeit.Timer('a("something")', 's = []; a = s.append').timeit()
0.15924410999923566
Otros consejos
En el ejemplo que diste, no hay ninguna diferencia, en términos de producción, entre append
y +=
. Pero hay una diferencia entre append
y +
(que la pregunta originalmente preguntó acerca).
>>> 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 se puede ver, append
y +=
tienen el mismo resultado; agregan el elemento a la lista, sin que se produzca una nueva lista. Usando +
añade las dos listas y produce una nueva lista.
>>> a=[]
>>> a.append([1,2])
>>> a
[[1, 2]]
>>> a=[]
>>> a+=[1,2]
>>> a
[1, 2]
Vea que append añade un único elemento a la lista, que puede ser cualquier cosa. +=[]
se une a las listas.
+ = es una asignación. Cuando lo utiliza en realidad está diciendo ‘some_list2 = some_list2 + [ 'algo']’. Asignaciones implican reencuadernación, así:
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 + = debe también normalmente crear un nuevo objeto de lista como lista + lista normalmente hace:
>>> l1= []
>>> l2= l1
>>> l1.append('x')
>>> l1 is l2
True
>>> l1= l1+['x']
>>> l1 is l2
False
Sin embargo, en la realidad:
>>> l2= l1
>>> l1+= ['x']
>>> l1 is l2
True
Esto se debe a las listas de Python implementar __iadd __ () para hacer una + = aumentada asignación cortocircuito y llamar lista.extend () en su lugar. (Es un poco de una extraña verruga esto:. Normalmente lo hace lo que quería decir, pero por razones confusas)
En general, si usted está añadiendo / extendido una lista existente, y que desea mantener la referencia a la misma lista (en lugar de hacer una nueva), que es mejor que ser explícita y seguir con el modo de adición () / extend () métodos.
some_list2 += ["something"]
es en realidad
some_list2.extend(["something"])
para un valor, no hay diferencia. estados de documentación, lo siguiente:
s.append(x)
mismo ques[len(s):len(s)] = [x]
s.extend(x)
mismo ques[len(s):len(s)] = x
Así obviamente s.append(x)
es igual que s.extend([x])
La diferencia es que concatenate a aplanar la lista resultante, mientras que append a mantener los niveles de intacta:
Así, por ejemplo, con:
myList = [ ]
listA = [1,2,3]
listB = ["a","b","c"]
Uso de datos anexados, termina con una lista de listas:
>> myList.append(listA)
>> myList.append(listB)
>> myList
[[1,2,3],['a',b','c']]
El uso de concatenar en cambio, se termina con una lista plana:
>> myList += listA + listB
>> myList
[1,2,3,"a","b","c"]
Las pruebas de rendimiento de aquí no son correctas:
- No debe ejecutar el perfil de una sola vez.
- Si la comparación de anexar vs. + = [] Número de veces que se debe declarar anexados como una función local.
- Resultados de tiempo son diferentes en diferentes versiones Python: 64 y 32 bit
por ejemplo.
timeit.Timer ( 'para i en xrange (100): app (i)', 's = []; aplicación = s.append'). Timeit ()
buenas pruebas se pueden encontrar aquí: http: / /markandclick.com/1/post/2012/01/python-list-append-vs.html
Además de los aspectos que se describen en las otras respuestas, añadir y + [] tienen comportamientos muy diferentes cuando se está tratando de construir 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'] añade '5' y '6' a la lista1 como elementos individuales. list1.append ([ '5', '6']) añade la lista [ '5', '6'] a la lista1 como un único elemento.
El comportamiento reencuadernación 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 la asignación aumentada siempre vuelve a enlazar, incluso si el objeto se mutó en el lugar. La reconsolidación aquí pasa a ser a[1] = *mutated list*
, lo que no funciona para tuplas.
tomemos un ejemplo primero
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
El método append() agrega un solo elemento a la lista existente.No devuelve una lista nueva, sino que modifica la lista original.
some_list1 = []
some_list1.append("something")
Entonces aquí se modificará some_list1.
Mientras que usar + para combinar los elementos de las listas devuelve una nueva lista.
some_list2 = []
some_list2 += ["something"]
Entonces aquí some_list2 y ["algo"] son las dos listas que se combinan y se devuelve una nueva lista que se asigna a some_list2