Menggabungkan dua daftar - perbedaan antara '+ =' dan extended ()

Saya telah melihat sebenarnya ada dua (mungkin lebih) cara untuk menggabungkan daftar dengan Python: Salah satu caranya adalah dengan menggunakan metode extended ():

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

yang lain untuk menggunakan operator plus (+):

b += a

Sekarang saya bertanya-tanya: Manakah dari dua opsi itu yang merupakan cara 'pythonic' untuk melakukan daftar concatenation dan apakah ada perbedaan di antara keduanya (saya telah melihat tutorial Python resmi tetapi tidak dapat menemukan apa pun tentang topik ini).

Satu-satunya perbedaan pada tingkat bytecode adalah bahwa .extendcara melibatkan pemanggilan fungsi, yang sedikit lebih mahal di Python daripada INPLACE_ADD.

Ini benar-benar tidak perlu Anda khawatirkan, kecuali jika Anda melakukan operasi ini miliaran kali. Namun demikian, kemungkinan kemacetan akan terletak di tempat lain.

Anda tidak dapat menggunakan + = untuk variabel non-lokal (variabel yang bukan lokal untuk fungsi dan juga bukan global)

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

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

    def boo():
        l += [5]

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

main()

Itu karena untuk memperpanjang case compiler akan memuat variabel lmenggunakan LOAD_DEREFinstruksi, tetapi untuk + = itu akan menggunakan LOAD_FAST- dan Anda dapatkan*UnboundLocalError: local variable 'l' referenced before assignment*

Anda dapat membuat panggilan fungsi, tetapi Anda tidak dapat + = melakukan panggilan fungsi secara langsung:

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

Saya akan mengatakan bahwa ada beberapa perbedaan ketika datang dengan numpy (saya hanya melihat bahwa pertanyaannya bertanya tentang menggabungkan dua daftar, bukan array numpy, tetapi karena mungkin menjadi masalah bagi pemula, seperti saya, saya harap ini dapat membantu seseorang yang mencari solusi untuk posting ini), mis.

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

itu akan kembali dengan kesalahan

ValueError: operan tidak dapat disiarkan bersama dengan bentuk (0,) (4,4,4)

b.extend(a) bekerja dengan sempurna

Dari kode sumber CPython 3.5.2 : Tidak ada perbedaan besar.

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

memperpanjang () bekerja dengan iterable *, + = bekerja dengan beberapa tetapi bisa menjadi 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
* cukup yakin .extend () berfungsi dengan iterable tapi tolong beri komentar jika saya salah

Sebenarnya, ada perbedaan antara tiga pilihan: ADD, INPLACE_ADDdanextend . Yang pertama selalu lebih lambat, sementara dua lainnya kira-kira sama.

Dengan informasi ini, saya lebih suka menggunakan extend, yang lebih cepat daripada ADD, dan menurut saya lebih eksplisit dari apa yang Anda lakukan daripada INPLACE_ADD.

Coba kode berikut beberapa kali (untuk 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

Saya telah mencari tutorial resmi Python tetapi tidak dapat menemukan apa pun tentang topik ini

Informasi ini kebetulan terkubur di FAQ Pemrograman :

... untuk daftar, __iadd__[yaitu +=] setara dengan memanggil extenddaftar dan mengembalikan daftar. Itu sebabnya kami mengatakan bahwa untuk daftar, +=adalah "singkatan" untuklist.extend

Anda juga dapat melihatnya sendiri dalam kode sumber CPython: https://github.com/python/cpython/blob/v3.8.2/Objects/listobject.c#L1000-L1011

Menurut Python untuk Analisis Data.

“Perhatikan bahwa daftar gabungan dengan penambahan adalah operasi yang relatif mahal karena daftar baru harus dibuat dan objek disalin. Menggunakan perluasan untuk menambahkan elemen ke daftar yang ada, terutama jika Anda membangun daftar besar, biasanya lebih disukai. " Jadi,

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

lebih cepat daripada alternatif ratenatif:

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