La concatenación de dos listas - diferencia entre '+ =' y extender()

Question

que he visto en realidad hay dos (quizás más) formas de concatenar las listas en Python: Una forma es utilizar el método extend():

a = [1, 2] 
b = [2, 3] 
b.extend(a) 

el otro para utilizar el signo más (+) del operador:

b += a 

Ahora me pregunto: ¿Cuál de estas dos opciones es la forma 'Pythonic' para hacer la lista de concatenación y hay una diferencia entre los dos (He buscado el tutorial oficial de Python pero no pude encontrar nada sobre este tema).

Answer 1

La única diferencia en un nivel de bytecode es que el modo .extend implica una llamada de función, que es un poco más costosa en Python que el INPLACE_ADD.

No es nada de lo que deba preocuparse, a menos que realice esta operación miles de millones de veces. Sin embargo, es probable que el cuello de botella se encuentre en otro lugar.

Answer 2

De acuerdo con la Zen of Python:

Simple is better than complex.

b += a es más simple que b.extend(a).

Las construcciones internas están tan optimizadas que no existe una diferencia de rendimiento real.

Answer 3

No puede utilizar + = para la variable no local (variable que no es local para la función y tampoco mundial)

def main(): 
    l = [1, 2, 3] 

    def foo(): 
     l.extend([4]) 

    def boo(): 
     l += [5] 

    foo() 
    print l 
    boo() # this will fail 

main() 

Es porque para extender compilador caso se carga la variable l usando LOAD_DEREF instrucción, pero por + = utilizará LOAD_FAST - y se obtiene *UnboundLocalError: local variable 'l' referenced before assignment*

Answer 4

puede llamadas a funciones de cadena, pero no se puede + = una llamada de función directa:

class A: 
    def __init__(self): 
     self.listFoo = [1, 2] 
     self.listBar = [3, 4] 

    def get_list(self, which): 
     if which == "Foo": 
      return self.listFoo 
     return self.listBar 

a = A() 
other_list = [5, 6] 

a.get_list("Foo").extend(other_list) 
a.get_list("Foo") += other_list #SyntaxError: can't assign to function call 

Answer 5

Diría que hay algo de diferencia cuando se trata de numpy (Acabo de ver que la pregunta es acerca de concatenar dos listas, no numpy array, pero dado que podría ser un problema para principiantes, como yo, Espero que esto pueda ayudar a alguien que busque la solución a esta publicación), por ej.

import numpy as np 
a = np.zeros((4,4,4)) 
b = [] 
b += a 

volverá con el error

ValueError: operandos no podían ser transmitidos junto con formas (0), (4,4,4)

b.extend(a) funciona perfectamente

Answer 6

De pitón 3.5.2 código fuente: No hay gran diferencia.

static PyObject * 
list_inplace_concat(PyListObject *self, PyObject *other) 
{ 
    PyObject *result; 

    result = listextend(self, other); 
    if (result == NULL) 
     return result; 
    Py_DECREF(result); 
    Py_INCREF(self); 
    return (PyObject *)self; 
}