¿Cuál es la diferencia entre LIST.append (1) y la LISTA DE LISTA = + [1] (Python)

Question

Cuando ejecuto (estoy usando el shell interactivo) estas declaraciones me sale esto:

L=[1,2,3] 
K=L 

L.append(4) 

L 
[1,2,3,4] 
K 
[1,2,3,4] 

pero cuando lo haga exactamente lo mismo que la sustitución de L.append (4) con L = L + [4] me sale:

L 
[1,2,3,4] 
K 
[1,2,3] 

Es esto algún tipo de cosas referencia? ¿Por qué pasó esto?

Otra cosa graciosa que noté es que L + = [4] actúa como .append, lo cual es extraño ya que pensé que actuaría como L = L + [4].

La aclaración de todo esto sería muy apreciada.

Gracias

Answer 1

Con append que se está modificando la lista directamente. Con L=L+[4], está haciendo una copia del original L y agrega un nuevo elemento, luego asignando ese resultado a L y rompiendo su equivalencia a K.

No estoy seguro del comportamiento de +=.

Answer 2

L.append(4) 

Esto agrega un elemento al final de la lista existente L.

L += [4] 

El operador += invoca el método mágico __iadd__(). Resulta que list anula el método __iadd__() y lo hace equivalente a extend() que, como append(), agrega elementos directamente a una lista existente.

L = L + [4] 

L + [4] genera una nueva lista que es igual a L con 4 agregado al final. Esta nueva lista se asigna de nuevo a L. Como ha creado un nuevo objeto de lista, esta tarea no modifica el K.

Podemos utilizar id() para identificar cuando se crea una nueva referencia de objeto:

>>> L = [1, 2, 3] 
>>> id(L) 
152678284 
>>> L.append(4) 
>>> id(L) 
152678284 

>>> L = [1, 2, 3] 
>>> id(L) 
152680524 
>>> L = L + [4] 
>>> id(L) 
152678316 

Answer 3

En el primer ejemplo K y L nombres de las variables se refieren al mismo objeto, por lo que cuando se invoca un método de mutación de ese objeto, los cambios se ven obviamente a través de ambas referencias. En el segundo ejemplo + operador invoca list.__add__ que devuelve nuevo objeto (concatenación de dos listas) y L nombre ahora se refiere a este nuevo objeto, mientras que K está intacto.

Answer 4

Si eres curioso acerca de los códigos de bytes:

>>> def L_app(): 
...  L.append(4) 
... 
>>> def L_add(): 
...  L = L + [ 4 ] 
... 
>>> def L_add_inplace(): 
...  L += [ 4 ] 
... 
>>> dis.dis(L_app) 
    2   0 LOAD_GLOBAL    0 (L) 
       3 LOAD_ATTR    1 (append) 
       6 LOAD_CONST    1 (4) 
       9 CALL_FUNCTION   1 
      12 POP_TOP 
      13 LOAD_CONST    0 (None) 
      16 RETURN_VALUE 
>>> dis.dis(L_add) 
    2   0 LOAD_FAST    0 (L) 
       3 LOAD_CONST    1 (4) 
       6 BUILD_LIST    1 
       9 BINARY_ADD 
      10 STORE_FAST    0 (L) 
      13 LOAD_CONST    0 (None) 
      16 RETURN_VALUE 
>>> dis.dis(L_add_inplace) 
    2   0 LOAD_FAST    0 (L) 
       3 LOAD_CONST    1 (4) 
       6 BUILD_LIST    1 
       9 INPLACE_ADD 
      10 STORE_FAST    0 (L) 
      13 LOAD_CONST    0 (None) 
      16 RETURN_VALUE