blocks|key|1150362|text|字节码级别上的唯一区别是.extend方式涉及函数调用，这在Python中比在INPLACE_ADD中稍微昂贵一些。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1150363|这真的没什么好担心的，除非你要执行这个操作数十亿次。然而，瓶颈很可能在其他地方。|1150364|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/array.html?#array.array.extend|1|https://docs.python.org/2/library/dis.html?highlight=inplace_add#opcode-INPLACE_ADD^0|C|7|13|B|C|7|0|13|B|1|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]|$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

The only difference on a bytecode level is that the <a href="https://docs.python.org/2/library/array.html?#array.array.extend" rel="noreferrer"><code>.extend</code></a> way involves a function call, which is slightly more expensive in Python than the <a href="https://docs.python.org/2/library/dis.html?highlight=inplace_add#opcode-INPLACE_ADD" rel="noreferrer"><code>INPLACE_ADD</code></a>.

It's really nothing you should be worrying about, unless you're performing this operation billions of times. It is likely, however, that the bottleneck would lie some place else.

blocks|key|936057|text|你可以链接函数调用，但是你不能直接%2B=函数调用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|936058|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")+%2B=+other_list++#SyntaxError:+can't+assign+to+function+call|code-block|syntax|javascript|936059|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can chain function calls, but you can't += a function call directly:

<pre><code>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
</code></pre>

blocks|key|1150457|text|我想说的是与numpy有一些不同(我刚刚看到问题问的是连接两个列表，而不是numpy数组，但由于这可能是像我这样的初学者的问题，我希望这能帮助那些寻求这篇文章的解决方案的人)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1150458|import+numpy+as+np
a+=+np.zeros((4,4,4))
b+=+[]
b+%2B=+a|code-block|syntax|javascript|1150459|它将返回错误|1150460|ValueError:操作数无法与形状(0，)+(4,4,4)一起广播|1150461|b.extend(a)完美工作|offset|length|style|CODE|1150462|entityMap^0|0|0|0|0|0|B|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I would say that there is some difference when it comes with numpy (I just saw that the question ask about concatenating two lists, not numpy array, but since it might be a issue for beginner, such as me, I hope this can help someone who seek the solution to this post), for ex.

<pre><code>import numpy as np
a = np.zeros((4,4,4))
b = []
b += a
</code></pre>

it will return with error

ValueError: operands could not be broadcast together with shapes (0,) (4,4,4)

<code>b.extend(a)</code> works perfectly

blocks|key|936129|text|来自CPython+3.5.2+source+code：没有太大的区别。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|936130|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;
}|code-block|syntax|javascript|936131|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/python/cpython/blob/v3.5.2/Objects/listobject.c#L898-L909^0|2|P|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

From the <a href="https://github.com/python/cpython/blob/v3.5.2/Objects/listobject.c#L898-L909" rel="nofollow noreferrer">CPython 3.5.2 source code</a>:
No big difference.

<pre><code>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;
}
</code></pre>

blocks|key|936323|text|extend()适用于任何可迭代的*，%2B=适用于某些迭代，但可能会变得很时髦。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|936324|import+numpy+as+np

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

l+=+[2,+3,+4]
t+=+np.array((5,+6,+7))
l+%2B=+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]|code-block|syntax|javascript|936325|Python+3.6|936326|*非常确定.extend()适用于任何迭代器，但如果我说的不正确，请发表评论|936327|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

extend() works with any iterable*, += works with some but can get funky. 

<pre><code>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]
</code></pre>

Python 3.6 
*pretty sure .extend() works with any iterable but please comment if I am incorrect

blocks|key|936368|text|实际上，ADD、INPLACE_ADD和extend这三个选项之间存在差异。前者总是较慢，而其他两个大致相同。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|936369|有了这些信息，我宁愿使用extend，它比ADD更快，而且在我看来比INPLACE_ADD更清楚你在做什么。|936370|多次尝试以下代码(对于Python+3)：|936371|import+time

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

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

++++#+ADD
++++t0+=+time.process_time()
++++w+=+x+%2B+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()|code-block|syntax|javascript|936372|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|936373|entityMap^0|4|3|8|B|K|6|0|C|6|L|3|Y|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|17|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|L|7|18|8|@]|D|@]|E|$M|N]]|$1|Q|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|R|$]]

Actually, there are differences among the three options: <code>ADD</code>, <code>INPLACE_ADD</code> and <code>extend</code>. The former is always slower, while the other two are roughly the same.

With this information, I would rather use <code>extend</code>, which is faster than <code>ADD</code>, and seems to me more explicit of what you are doing than <code>INPLACE_ADD</code>.

Try the following code a few times (for Python 3):

<pre class="lang-py prettyprint-override"><code>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()
</code></pre>

<pre><code>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
</code></pre>

blocks|key|936423|text|当列表位于元组中时，只能使用.extend()|type|unstyled|depth|inlineStyleRanges|entityRanges|data|936424|这将会起作用|936425|t+=+([],[])
t[0].extend([1,2])|code-block|syntax|javascript|936426|虽然这不会|936427|t+=+([],[])
t[0]+%2B=+[1,2]|936428|原因是%2B=生成了一个新对象。如果你看一下长版本：|offset|length|style|CODE|936429|t[0]+=+t[0]+%2B+[1,2]|936430|您可以看到这将如何更改元组中的对象，这是不可能的。使用.extend()修改元组中的对象，这是允许的。|936431|entityMap^0|0|0|0|0|0|3|2|0|0|R|9|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|17|8|@$O|18|P|19|Q|R]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

<h1>Only .extend() can be used when the list is in a tuple</h1>
This will work
<pre><code>t = ([],[])
t[0].extend([1,2])
</code></pre>
while this won't
<pre><code>t = ([],[])
t[0] += [1,2]
</code></pre>
The reason is that <code>+=</code> generates a new object. If you look at the long version:
<pre><code>t[0] = t[0] + [1,2]
</code></pre>
you can see how that would change which object is in the tuple, which is not possible. Using <code>.extend()</code> modifies an object in the tuple, which is allowed.

blocks|key|936233|text|根据Python+for+Data+Analysis。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|936234|“请注意，通过添加来连接列表是一个相对昂贵的操作，因为必须创建一个新的列表并复制对象。使用extend将元素追加到现有列表中通常是更可取的，尤其是当您正在构建一个大型列表时。“因此，|936235|everything+=+[]
for+chunk+in+list_of_lists:
++++everything.extend(chunk)|code-block|syntax|javascript|936236|比连接的替代方案更快：|936237|everything+=+[]
for+chunk+in+list_of_lists:
++++everything+=+everything+%2B+chunk|936238|​|936239|📷|atomic|offset|length|936240|936241|936242|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/8a9fa7d47d9df36485e09d1323e47f64.jpeg|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/9c0beb0cdb181e3b05d4118828dfcc2a.jpeg^0|0|0|0|0|0|0|0|1|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1C|8|@]|9|@$R|1D|S|1E|1|1F]]|A|$]]|$1|T|3|P|5|Q|7|1G|8|@]|9|@$R|1H|S|1I|1|1J]]|A|$]]|$1|U|3|N|5|6|7|1K|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12|13|-4]]|14|$5|Y|Z|10|A|$11|15|13|-4]]]]

According to the Python for Data Analysis.

“Note that list concatenation by addition is a comparatively expensive operation since a new list must be created and the objects copied over. Using extend to append elements to an existing list, especially if you are building up a large list, is usually preferable. ” 
Thus,

<pre><code>everything = []
for chunk in list_of_lists:
 everything.extend(chunk)
</code></pre>

is faster than the concatenative alternative:

<pre><code>everything = []
for chunk in list_of_lists:
 everything = everything + chunk
</code></pre>

<a href="https://i.stack.imgur.com/B7FC2.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/B7FC2.jpg" alt="enter image description here"></a>
<a href="https://i.stack.imgur.com/6zlI1.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/6zlI1.jpg" alt="enter image description here"></a>

I've seen there are actually two (maybe more) ways to concatenate lists in Python:
One way is to use the extend() method:

<pre><code>a = [1, 2]
b = [2, 3]
b.extend(a)
</code></pre>

the other to use the plus(+) operator:

<pre><code>b += a
</code></pre>

Now I wonder: Which of those two options is the 'pythonic' way to do list concatenation and is there a difference between the two (I've looked up the official Python tutorial but couldn't find anything anything about this topic).

Concatenating two lists - difference between '+=' and extend()

Python

我已经看到，在Python中有两种(也许更多)方法可以连接列表:一种方法是使用extend()方法：a = [1, 2]b = [2, 3]b.extend(a)另一个使用加号(+)运算符：b += a现在我想知道:这两个选项中哪一个是列表连接的“pythonic”方式，两个之间有什么不同(我已经查找了官方的Python教程，但是找不到任何关于这个主题的东西)。

问连接两个列表- '+=‘和extend()之间的差异
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问连接两个列表- '+=‘和extend()之间的差异EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问连接两个列表- '+=‘和extend()之间的差异
EN