การต่อสองรายการ - ความแตกต่างระหว่าง '+ =' และขยาย ()

ฉันเคยเห็นมีสองวิธี (อาจมากกว่า) เชื่อมรายการใน Python: วิธีหนึ่งคือการใช้วิธีขยาย ()

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

อีกอันใช้ตัวดำเนินการบวก (+):

b += a

ตอนนี้ฉันสงสัยว่า: ตัวเลือกใดในสองวิธีนี้คือ 'pythonic' ในการทำรายการ concatenation และมีความแตกต่างระหว่างทั้งสอง (ฉันได้ค้นหา Python tutorial อย่างเป็นทางการ แต่ไม่พบอะไรเกี่ยวกับหัวข้อนี้)

ความแตกต่างเพียงอย่างเดียวในระดับ bytecode ก็คือ.extendวิธีนี้เกี่ยวข้องกับการเรียกใช้ฟังก์ชันซึ่งมีราคาแพงกว่าใน Python INPLACE_ADDเล็กน้อย

มันไม่มีอะไรที่คุณควรกังวลเลยนอกจากว่าคุณจะทำสิ่งนี้เป็นพันล้านครั้ง อย่างไรก็ตามมีโอกาสที่คอขวดจะอยู่ที่อื่น

คุณไม่สามารถใช้ + = สำหรับตัวแปรที่ไม่ใช่โลคัล (ตัวแปรที่ไม่ใช่โลคอลสำหรับฟังก์ชั่นและไม่ใช่โกลบอล)

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

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

    def boo():
        l += [5]

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

main()

เป็นเพราะการขยายตัวรวบรวมเคสจะโหลดตัวแปรlโดยใช้LOAD_DEREFคำสั่ง แต่สำหรับ + ​​= มันจะใช้LOAD_FAST- และคุณจะได้รับ*UnboundLocalError: local variable 'l' referenced before assignment*

คุณสามารถโยงการเรียกฟังก์ชั่นได้ แต่คุณไม่สามารถ + = การเรียกใช้ฟังก์ชันโดยตรง:

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

ฉันจะบอกว่ามีความแตกต่างบางอย่างเมื่อมันมาพร้อมกับ numpy (ฉันเพิ่งเห็นว่าคำถามถามเกี่ยวกับการต่อสองรายการไม่ใช่อาร์เรย์ numpy แต่เนื่องจากมันอาจเป็นปัญหาสำหรับมือใหม่เช่นฉันฉันหวังว่าสิ่งนี้จะช่วยคนได้ ผู้ที่หาทางแก้ไขโพสต์นี้) เช่น

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

มันจะกลับมาพร้อมกับข้อผิดพลาด

ValueError: ตัวถูกดำเนินการไม่สามารถออกอากาศพร้อมกับรูปร่าง (0,) (4,4,4)

b.extend(a) ทำงานได้อย่างสมบูรณ์แบบ

จากซอร์สโค้ด CPython 3.5.2 : ไม่แตกต่างกันมาก

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

ขยาย () ทำงานร่วมกับ iterable ใด ๆ *, + = ทำงานร่วมกับบางส่วน แต่จะได้รับขี้ขลาด

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
* ค่อนข้างมั่นใจ. ภาคผนวก () ใช้ได้กับ iterable ใด ๆ แต่โปรดแสดงความคิดเห็นหากฉันไม่ถูกต้อง

ที่จริงมีความแตกต่างระหว่างสามตัวเลือก: ADD, และINPLACE_ADD extendอดีตมักจะช้ากว่าเสมอในขณะที่อีกสองคนจะเป็นแบบเดียวกัน

ด้วยข้อมูลนี้ผมค่อนข้างจะใช้extendซึ่งจะเร็วกว่าและดูเหมือนว่าฉันมากขึ้นอย่างชัดเจนของสิ่งที่คุณกำลังทำมากกว่าADDINPLACE_ADD

ลองใช้รหัสต่อไปนี้สองสามครั้ง (สำหรับ 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

ฉันค้นหาบทช่วยสอนของ Python อย่างเป็นทางการแล้ว แต่ไม่พบสิ่งใดเกี่ยวกับหัวข้อนี้

ข้อมูลนี้จะถูกฝังอยู่ในคำถามที่พบบ่อยการเขียนโปรแกรม :

... สำหรับรายการ__iadd__[ie +=] เทียบเท่ากับการโทรextendในรายการและส่งคืนรายการ นั่นเป็นเหตุผลที่เราพูดว่าสำหรับรายการ+=เป็น "ชวเลข" สำหรับlist.extend

คุณสามารถดูได้ด้วยตัวคุณเองในซอร์สโค้ดของ CPython: https://github.com/python/cpython/blob/v3.8.2/Objects/listobject.c#L1000-L1011

ตาม Python สำหรับการวิเคราะห์ข้อมูล

“ โปรดทราบว่าการต่อข้อมูลแบบเรียงลำดับโดยการเพิ่มเป็นการดำเนินการที่ค่อนข้างแพงเนื่องจากต้องสร้างรายการใหม่และคัดลอกวัตถุไป การใช้ขยายเพื่อผนวกองค์ประกอบเข้ากับรายการที่มีอยู่โดยเฉพาะอย่างยิ่งถ้าคุณกำลังสร้างรายการขนาดใหญ่มักจะดีกว่า ” ดังนั้น

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

เร็วกว่าทางเลือกที่ต่อกัน:

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