recorrer - comparar si dos listas son iguales c#

Concatenación de dos listas: diferencia entre ''+='' y extender()

Question

He visto que en realidad hay dos (quizás más) formas de concatenar listas en Python: una forma es usar el método extend ():

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

el otro para usar el operador más (+):

b += a

Ahora me pregunto: ¿Cuál de esas dos opciones es la forma ''pitónica'' de hacer una concatenación de listas y hay una diferencia entre las dos (he buscado el tutorial oficial de Python pero no pude encontrar nada sobre este tema).

Answer 1

De acuerdo con el Zen de Python :

Simple es mejor que complejo.

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

Los comandos incorporados están tan optimizados que no existe una diferencia de rendimiento real.

Answer 2

Desde el código fuente de Python 3.5.2: 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;
}

Answer 3

Diría que hay alguna 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 buscan la solución a esta publicación), por ej.

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

volverá con error

ValueError: los operandos no se pudieron transmitir junto con las formas (0,) (4,4,4)

b.extend(a) funciona a la perfección

Answer 4

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

En realidad 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 5

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

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 el caso LOAD_DEREF compilador cargará la variable l usando la instrucción LOAD_DEREF , pero para + = usará LOAD_FAST - y obtendrá *UnboundLocalError: local variable ''l'' referenced before assignment*

Answer 6

Puede encadenar llamadas de función, pero no puede llamar directamente a + = una función:

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