我已经看到实际上有两种(可能更多)方法在Python中连接列表:一种方法是使用extend()方法:
a = [1, 2]
b = [2, 3]
b.extend(a)
另一个使用加号(+)运算符:
b += a
现在我想知道:这两个选项中的哪一个是"pythonic"方式进行列表连接,两者之间是否存在差异(我查阅了官方Python教程但未找到任何关于此主题的内容).
Sil*_*ost 198
字节码级别的唯一区别在于,这种.extend方式涉及函数调用,这在Python中略高于INPLACE_ADD.
除非你执行这项行动数十亿次,否则你应该担心的事情真的没什么.但是,瓶颈可能会出现在其他地方.
mon*_*ius 163
您不能将+ =用于非局部变量(对于函数而言不是本地的变量,也不是全局变量)
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*
isa*_*ndi 31
你可以链接函数调用,但你不能直接+ =函数调用:
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
dal*_*soa 11
ADD实际上， 、INPLACE_ADD和三个选项之间存在差异extend。前者总是较慢，而其他两者大致相同。
有了这些信息，我宁愿使用extend，它比 更快ADD，并且在我看来比 更明确您正在做什么INPLACE_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
我会说,当它出现numpy时会有一些区别(我刚看到问题是关于连接两个列表,而不是numpy数组,但是因为它可能是初学者的问题,比如我,我希望这可以帮助某人谁寻求这个帖子的解决方案),例如.
import numpy as np
a = np.zeros((4,4,4))
b = []
b += a
它将返回错误
ValueError:操作数无法与形状(0,)一起广播(4,4,4)
b.extend(a) 工作得很好
小智 7
ary += ext 创建一个新的 List 对象，然后将列表“ary”和“ext”中的数据复制到其中。
\nary.extend(ext) 只是将对“ext”列表的引用添加到“ary”列表的末尾，从而减少内存事务。
\n因此，.extend 的工作速度要快几个数量级，并且不使用正在扩展的列表和正在扩展的列表之外的任何额外内存。
\n\xe2\x95\xb0\xe2\x94\x80\xe2\x9e\xa4 time ./list_plus.py\n./list_plus.py 36.03s user 6.39s system 99% cpu 42.558 total\n\xe2\x95\xb0\xe2\x94\x80\xe2\x9e\xa4 time ./list_extend.py\n./list_extend.py 0.03s user 0.01s system 92% cpu 0.040 total\n第一个脚本还使用超过 200MB 的内存，而第二个脚本使用的内存并不比“裸”python3 进程多。
\n话虽如此，就地添加似乎确实与 .extend 做了同样的事情。
\n来自python 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;
}
extend() 适用于任何可迭代*，+= 适用于某些，但可能会变得时髦。
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
*很确定 .extend() 适用于任何可迭代对象，但如果我不正确，请发表评论