tutorial panda examples example español documentacion python list concatenation

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:

  1. No deberías ejecutar el perfil solo una vez.
  2. Si compara append vs. + = [] número de veces, debe declarar append como función local.
  3. 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 que s[len(s):len(s)] = [x]
s.extend(x) igual que s[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.