Concatenazione di due elenchi: differenza tra '+ =' ed extension ()

Ho visto che in realtà ci sono due (forse più) modi per concatenare elenchi in Python: un modo è usare il metodo extend ():

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

l'altro per usare l'operatore più (+):

b += a

Ora mi chiedo: quale di queste due opzioni sia il modo 'pythonic' di fare la concatenazione di elenchi e c'è una differenza tra i due (ho cercato il tutorial ufficiale di Python ma non ho trovato nulla su questo argomento).

L'unica differenza a livello di bytecode è che il .extendmodo in cui comporta una chiamata di funzione, che è leggermente più costoso in Python rispetto a INPLACE_ADD.

È davvero niente di cui dovresti preoccuparti, a meno che tu non stia eseguendo questa operazione miliardi di volte. È probabile, tuttavia, che il collo di bottiglia risieda in qualche altro posto.

Non puoi usare + = per variabile non locale (variabile che non è locale per funzione e non è globale)

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

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

    def boo():
        l += [5]

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

main()

È perché per il compilatore di case di estensione caricherà la variabile lusando l' LOAD_DEREFistruzione, ma per + = utilizzerà LOAD_FAST- e otterrai*UnboundLocalError: local variable 'l' referenced before assignment*

Puoi concatenare le chiamate di funzione, ma non puoi + = una chiamata di funzione direttamente:

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

Direi che c'è una certa differenza quando si tratta di intorpidimento (ho appena visto che la domanda si pone sulla concatenazione di due elenchi, non sull'array intorpidito, ma poiché potrebbe essere un problema per i principianti, come me, spero che questo possa aiutare qualcuno che cercano la soluzione a questo post), ad es.

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

tornerà con errore

ValueError: gli operandi non possono essere trasmessi insieme alle forme (0,) (4,4,4)

b.extend(a) funziona perfettamente

Dal codice sorgente CPython 3.5.2 : nessuna grande differenza.

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;
}

extension () funziona con qualsiasi iterabile *, + = funziona con alcuni ma può diventare funky.

import numpy as np

l = [2, 3, 4]
t = (5, 6, 7)
l += t
l
[2, 3, 4, 5, 6, 7]

l = [2, 3, 4]
t = np.array((5, 6, 7))
l += t
l
array([ 7,  9, 11])

l = [2, 3, 4]
t = np.array((5, 6, 7))
l.extend(t)
l
[2, 3, 4, 5, 6, 7]

Python 3.6
* abbastanza sicuro .extend () funziona con qualsiasi iterabile ma per favore commenta se non sono corretto

In realtà, ci sono differenze tra le tre opzioni: ADD, INPLACE_ADDe extend. Il primo è sempre più lento, mentre gli altri due sono più o meno gli stessi.

Con queste informazioni, preferirei utilizzare extend, che è più veloce di ADD, e mi sembra più esplicito di quello che stai facendo INPLACE_ADD.

Prova alcune volte il codice seguente (per Python 3):

import time

def test():
    x = list(range(10000000))
    y = list(range(10000000))
    z = list(range(10000000))

    # INPLACE_ADD
    t0 = time.process_time()
    z += x
    t_inplace_add = time.process_time() - t0

    # ADD
    t0 = time.process_time()
    w = x + y
    t_add = time.process_time() - t0

    # Extend
    t0 = time.process_time()
    x.extend(y)
    t_extend = time.process_time() - t0

    print('ADD {} s'.format(t_add))
    print('INPLACE_ADD {} s'.format(t_inplace_add))
    print('extend {} s'.format(t_extend))
    print()

for i in range(10):
    test()

ADD 0.3540440000000018 s
INPLACE_ADD 0.10896000000000328 s
extend 0.08370399999999734 s

ADD 0.2024550000000005 s
INPLACE_ADD 0.0972940000000051 s
extend 0.09610200000000191 s

ADD 0.1680199999999985 s
INPLACE_ADD 0.08162199999999586 s
extend 0.0815160000000077 s

ADD 0.16708400000000267 s
INPLACE_ADD 0.0797719999999913 s
extend 0.0801490000000058 s

ADD 0.1681250000000034 s
INPLACE_ADD 0.08324399999999343 s
extend 0.08062700000000689 s

ADD 0.1707760000000036 s
INPLACE_ADD 0.08071900000000198 s
extend 0.09226200000000517 s

ADD 0.1668420000000026 s
INPLACE_ADD 0.08047300000001201 s
extend 0.0848089999999928 s

ADD 0.16659500000000094 s
INPLACE_ADD 0.08019399999999166 s
extend 0.07981599999999389 s

ADD 0.1710910000000041 s
INPLACE_ADD 0.0783479999999912 s
extend 0.07987599999999873 s

ADD 0.16435900000000458 s
INPLACE_ADD 0.08131200000001115 s
extend 0.0818660000000051 s

Ho cercato il tutorial ufficiale di Python ma non sono riuscito a trovare nulla su questo argomento

Queste informazioni sembrano essere sepolte nelle FAQ sulla programmazione :

... per gli elenchi, __iadd__[vale a dire +=] equivale a richiamare extendl'elenco e restituire l'elenco. Ecco perché diciamo che per gli elenchi, +=è una "scorciatoia" perlist.extend

Puoi anche vederlo da solo nel codice sorgente di CPython: https://github.com/python/cpython/blob/v3.8.2/Objects/listobject.c#L1000-L1011

Secondo Python per l'analisi dei dati.

“Si noti che la concatenazione di elenchi per addizione è un'operazione relativamente costosa poiché è necessario creare un nuovo elenco e copiare gli oggetti. L'utilizzo di extendi per aggiungere elementi a un elenco esistente, specialmente se si sta creando un elenco di grandi dimensioni, è generalmente preferibile. "Quindi,

everything = []
for chunk in list_of_lists:
    everything.extend(chunk)

è più veloce dell'alternativa concatenativa:

everything = []
for chunk in list_of_lists:
    everything = everything + chunk