blocks|key|2996287|text|在operator.add中使用map|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2996288|>>>+from+operator+import+add
>>>+list(+map(add,+list1,+list2)+)
[5,+7,+9]|code-block|syntax|javascript|2996289|或者使用列表理解的zip：|2996290|>>>+[sum(x)+for+x+in+zip(list1,+list2)]
[5,+7,+9]|2996291|时序比较：|2996292|>>>+list2+=+[4,+5,+6]*10**5
>>>+list1+=+[1,+2,+3]*10**5
>>>+%25timeit+from+operator+import+add;map(add,+list1,+list2)
10+loops,+best+of+3:+44.6+ms+per+loop
>>>+%25timeit+from+itertools+import+izip;+[a+%2B+b+for+a,+b+in+izip(list1,+list2)]
10+loops,+best+of+3:+71+ms+per+loop
>>>+%25timeit+[a+%2B+b+for+a,+b+in+zip(list1,+list2)]
10+loops,+best+of+3:+112+ms+per+loop
>>>+%25timeit+from+itertools+import+izip;[sum(x)+for+x+in+izip(list1,+list2)]
1+loops,+best+of+3:+139+ms+per+loop
>>>+%25timeit+[sum(x)+for+x+in+zip(list1,+list2)]
1+loops,+best+of+3:+177+ms+per+loop|2996293|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/operator.html#operator.add|1|https://docs.python.org/2/library/functions.html#map|2|https://docs.python.org/2/library/functions.html#zip^0|1|C|G|3|1|C|0|G|3|1|0|0|9|3|9|3|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|F|3|G|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|M|3|N|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1N|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]]]

Use <a href="https://docs.python.org/2/library/functions.html#map" rel="noreferrer"><code>map</code></a> with <a href="https://docs.python.org/2/library/operator.html#operator.add" rel="noreferrer"><code>operator.add</code></a>:

<pre><code>&gt;&gt;&gt; from operator import add
&gt;&gt;&gt; list( map(add, list1, list2) )
[5, 7, 9]
</code></pre>

or <a href="https://docs.python.org/2/library/functions.html#zip" rel="noreferrer"><code>zip</code></a> with a list comprehension:

<pre><code>&gt;&gt;&gt; [sum(x) for x in zip(list1, list2)]
[5, 7, 9]
</code></pre>

<h3>Timing comparisons:</h3>

<pre><code>&gt;&gt;&gt; list2 = [4, 5, 6]*10**5
&gt;&gt;&gt; list1 = [1, 2, 3]*10**5
&gt;&gt;&gt; %timeit from operator import add;map(add, list1, list2)
10 loops, best of 3: 44.6 ms per loop
&gt;&gt;&gt; %timeit from itertools import izip; [a + b for a, b in izip(list1, list2)]
10 loops, best of 3: 71 ms per loop
&gt;&gt;&gt; %timeit [a + b for a, b in zip(list1, list2)]
10 loops, best of 3: 112 ms per loop
&gt;&gt;&gt; %timeit from itertools import izip;[sum(x) for x in izip(list1, list2)]
1 loops, best of 3: 139 ms per loop
&gt;&gt;&gt; %timeit [sum(x) for x in zip(list1, list2)]
1 loops, best of 3: 177 ms per loop
</code></pre>

blocks|key|2996295|text|[a+%2B+b+for+a,+b+in+zip(list1,+list2)]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2996296|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|2996305|text|其他人给出了如何在纯python中完成此操作的示例。如果想要对包含100.000个元素的数组执行此操作，则应使用numpy：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2996306|In+[1]:+import+numpy+as+np
In+[2]:+vector1+=+np.array([1,+2,+3])
In+[3]:+vector2+=+np.array([4,+5,+6])|code-block|syntax|javascript|2996307|现在，按元素进行加法就像|2996308|In+[4]:+sum_vector+=+vector1+%2B+vector2
In+[5]:+print+sum_vector
[5+7+9]|2996309|就像在Matlab中一样。|2996310|与Ashwini的最快版本进行比较的时间：|2996311|In+[16]:+from+operator+import+add
In+[17]:+n+=+10**5
In+[18]:+vector2+=+np.tile([4,5,6],+n)
In+[19]:+vector1+=+np.tile([1,2,3],+n)
In+[20]:+list1+=+[1,2,3]*n
In+[21]:+list2+=+[4,5,6]*n
In+[22]:+timeit+map(add,+list1,+list2)
10+loops,+best+of+3:+26.9+ms+per+loop

In+[23]:+timeit+vector1+%2B+vector2
1000+loops,+best+of+3:+1.06+ms+per+loop|2996312|所以这比原来快了25倍！但是使用适合你的情况。对于一个简单的程序，您可能不想安装numpy，所以请使用标准的python+(我发现Henry's+version是最具python风格的)。如果您正在进行严重的数字运算，那么让numpy来做繁重的工作。对于速度狂人来说:从n+=+8开始，numpy解决方案似乎更快。|offset|length|style|CODE|2996313|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/18713367^0|0|0|0|0|0|0|0|34|5|3R|5|1T|F|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1B|8|@$S|1C|T|1D|U|V]|$S|1E|T|1F|U|V]]|9|@$S|1G|T|1H|1|1I]]|A|$]]|$1|W|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

The others gave examples how to do this in pure python. If you want to do this with arrays with 100.000 elements, you should use numpy:

<pre><code>In [1]: import numpy as np
In [2]: vector1 = np.array([1, 2, 3])
In [3]: vector2 = np.array([4, 5, 6])
</code></pre>

Doing the element-wise addition is now as trivial as

<pre><code>In [4]: sum_vector = vector1 + vector2
In [5]: print sum_vector
[5 7 9]
</code></pre>

just like in Matlab.

Timing to compare with Ashwini's fastest version:

<pre><code>In [16]: from operator import add
In [17]: n = 10**5
In [18]: vector2 = np.tile([4,5,6], n)
In [19]: vector1 = np.tile([1,2,3], n)
In [20]: list1 = [1,2,3]*n
In [21]: list2 = [4,5,6]*n
In [22]: timeit map(add, list1, list2)
10 loops, best of 3: 26.9 ms per loop

In [23]: timeit vector1 + vector2
1000 loops, best of 3: 1.06 ms per loop
</code></pre>

So this is a factor 25 faster! But use what suits your situation. For a simple program, you probably don't want to install numpy, so use standard python (and I find <a href="https://stackoverflow.com/a/18713367">Henry's version</a> the most Pythonic one). If you are into serious number crunching, let <code>numpy</code> do the heavy lifting. For the speed freaks: it seems that the numpy solution is faster starting around <code>n = 8</code>.

blocks|key|175097|text|也许“最大的蟒蛇方式”应该包括处理list1和list2大小不同的情况。应用其中的一些方法会悄悄地给你一个答案。numpy方法会让您知道，最有可能的是使用ValueError。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175098|示例：|175099|import+numpy+as+np
>>>+list1+=+[+1,+2+]
>>>+list2+=+[+1,+2,+3]
>>>+list3+=+[+1+]
>>>+[a+%2B+b+for+a,+b+in+zip(list1,+list2)]
[2,+4]
>>>+[a+%2B+b+for+a,+b+in+zip(list1,+list3)]
[2]
>>>+a+=+np.array+(list1)
>>>+b+=+np.array+(list2)
>>>+a%2Bb
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
ValueError:+operands+could+not+be+broadcast+together+with+shapes+(2)+(3)|code-block|syntax|javascript|175100|如果这是你的问题中的一个函数，你可能想要什么结果？|175101|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Perhaps "the most pythonic way" should include handling the case where list1 and list2 are not the same size. Applying some of these methods will quietly give you an answer. The numpy approach will let you know, most likely with a ValueError.

Example:

<pre><code>import numpy as np
&gt;&gt;&gt; list1 = [ 1, 2 ]
&gt;&gt;&gt; list2 = [ 1, 2, 3]
&gt;&gt;&gt; list3 = [ 1 ]
&gt;&gt;&gt; [a + b for a, b in zip(list1, list2)]
[2, 4]
&gt;&gt;&gt; [a + b for a, b in zip(list1, list3)]
[2]
&gt;&gt;&gt; a = np.array (list1)
&gt;&gt;&gt; b = np.array (list2)
&gt;&gt;&gt; a+b
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
ValueError: operands could not be broadcast together with shapes (2) (3)
</code></pre>

Which result might you want if this were in a function in your problem?

blocks|key|2996399|text|将map与lambda函数一起使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2996400|>>>+map(lambda+x,+y:+x+%2B+y,+list1,+list2)
[5,+7,+9]|code-block|syntax|javascript|2996401|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|$]]

Use map with lambda function:

<pre><code>&gt;&gt;&gt; map(lambda x, y: x + y, list1, list2)
[5, 7, 9]
</code></pre>

blocks|key|2996409|text|我还没有计时，但我想这会很快的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2996410|import+numpy+as+np
list1=[1,+2,+3]
list2=[4,+5,+6]

list_sum+=+(np.add(list1,+list2)).tolist()

[5,+7,+9]|code-block|syntax|javascript|2996411|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|$]]

I haven't timed it but I suspect this would be pretty quick: 

<pre><code>import numpy as np
list1=[1, 2, 3]
list2=[4, 5, 6]

list_sum = (np.add(list1, list2)).tolist()

[5, 7, 9]
</code></pre>

blocks|key|175115|text|这将适用于2个或更多列表；迭代列表列表，但使用numpy加法来处理每个列表的元素|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175116|import+numpy+as+np
list1=[1,+2,+3]
list2=[4,+5,+6]

lists+=+[list1,+list2]
list_sum+=+np.zeros(len(list1))
for+i+in+lists:
+++list_sum+%2B=+i
list_sum+=+list_sum.tolist()++++

[5.0,+7.0,+9.0]|code-block|syntax|javascript|175117|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|$]]

This will work for 2 or more lists; iterating through the list of lists, but using numpy addition to deal with elements of each list

<pre><code>import numpy as np
list1=[1, 2, 3]
list2=[4, 5, 6]

lists = [list1, list2]
list_sum = np.zeros(len(list1))
for i in lists:
 list_sum += i
list_sum = list_sum.tolist() 

[5.0, 7.0, 9.0]
</code></pre>

blocks|key|175119|text|[list1[i]+%2B+list2[i]+for+i+in+range(len(list1))]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|175120|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>[list1[i] + list2[i] for i in range(len(list1))]
</code></pre>

blocks|key|178880|text|如果你需要处理不同大小的列表，不用担心！精彩的itertools模块为您提供了以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|178881|>>>+from+itertools+import+zip_longest
>>>+list1+=+[1,2,1]
>>>+list2+=+[2,1,2,3]
>>>+[sum(x)+for+x+in+zip_longest(list1,+list2,+fillvalue=0)]
[3,+3,+3,+3]
>>>|code-block|syntax|javascript|178882|在Python2中，zip_longest被称为izip_longest。|style|CODE|178883|另请参见this+relevant+answer+and+comment+on+another+question。|178884|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/itertools.html#itertools.zip_longest|1|https://docs.python.org/2.7/library/itertools.html#itertools.izip_longest|2|https://stackoverflow.com/questions/2407398/python-merge-items-of-two-lists-into-a-list-of-tuples#comment2388427_2407405^0|N|9|0|0|0|A|B|O|C|O|C|1|0|4|1G|2|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@$A|16|B|17|K|L]|$A|18|B|19|K|L]]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|M|3|N|5|6|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|O|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]|Y|$5|R|S|T|C|$U|Z]]]]

If you need to handle lists of different sizes, worry not! The wonderful <a href="https://docs.python.org/3/library/itertools.html#itertools.zip_longest" rel="nofollow noreferrer">itertools</a> module has you covered:

<pre><code>&gt;&gt;&gt; from itertools import zip_longest
&gt;&gt;&gt; list1 = [1,2,1]
&gt;&gt;&gt; list2 = [2,1,2,3]
&gt;&gt;&gt; [sum(x) for x in zip_longest(list1, list2, fillvalue=0)]
[3, 3, 3, 3]
&gt;&gt;&gt;
</code></pre>

In Python 2, <code>zip_longest</code> is called <a href="https://docs.python.org/2.7/library/itertools.html#itertools.izip_longest" rel="nofollow noreferrer"><code>izip_longest</code></a>.

See also <a href="https://stackoverflow.com/questions/2407398/python-merge-items-of-two-lists-into-a-list-of-tuples#comment2388427_2407405">this relevant answer and comment on another question</a>.

blocks|key|2996477|text|正如其他人所描述的，一种快速且空间高效的解决方案是使用numpy+(np)及其内置的向量操作功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2996478|1.使用Numpy|offset|length|style|BOLD|2996479|x+=+np.array([1,2,3])
y+=+np.array([2,3,4])
print+x%2By|code-block|syntax|javascript|2996480|2.内置|2996481|2.1λ|2996482|list1=[1,+2,+3]
list2=[4,+5,+6]
print+map(lambda+x,y:x%2By,+list1,+list2)|2996483|注意，map()支持多个参数。|2996484|2.2压缩和列表理解|2996485|list1=[1,+2,+3]
list2=[4,+5,+6]
print+[x+%2B+y+for+x,+y+in+zip(list1,+list2)]|2996486|entityMap^0|0|0|9|0|0|0|4|0|0|4|0|0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1B|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|W|3|X|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|Y|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|Z|$]]

As described by others, a fast and also space efficient solution is using numpy (np) with it's built-in vector manipulation capability:

1. With Numpy

<pre><code>x = np.array([1,2,3])
y = np.array([2,3,4])
print x+y
</code></pre>

2. With built-ins

2.1 Lambda

<pre><code>list1=[1, 2, 3]
list2=[4, 5, 6]
print map(lambda x,y:x+y, list1, list2)
</code></pre>

Notice that map() supports multiple arguments.

2.2 zip and list comprehension

<pre><code>list1=[1, 2, 3]
list2=[4, 5, 6]
print [x + y for x, y in zip(list1, list2)]
</code></pre>

blocks|key|178932|text|虽然，实际问题并不想通过迭代列表来生成结果，但所有提出的解决方案都在幕后实现了这一点！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|178933|刷新:如果不查看所有向量元素，则无法添加两个向量。因此，大多数解决方案的算法复杂度都是Big-O(n)。其中n是向量的维数。|178934|因此，从算法的角度来看，使用for循环迭代地生成结果列表也是逻辑和pythonic的。但是，此外，此方法没有调用或导入任何附加库的开销。|178935|#+Assumption:+The+lists+are+of+equal+length.
resultList+=+[list1[i]+%2B+list2[i]+for+i+in+range(len(list1))]|code-block|syntax|javascript|178936|这里显示/讨论的计时依赖于系统和实现，不能作为衡量操作效率的可靠措施。在任何情况下，向量加法运算的大O复杂度都是线性的，这意味着O(n)。|178937|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Although, the actual question does not want to iterate over the list to generate the result, but all the solutions that has been proposed does exactly that under-neath the hood! 

To refresh: You cannot add two vectors without looking into all the vector elements. So, the algorithmic complexity of most of these solutions are Big-O(n). Where n is the dimension of the vector.

So, from an algorithmic point of view, using a for loop to iteratively generate the resulting list is logical and pythonic too. However, in addition, this method does not have the overhead of calling or importing any additional library.

<pre><code># Assumption: The lists are of equal length.
resultList = [list1[i] + list2[i] for i in range(len(list1))]
</code></pre>

The timings that are being showed/discussed here are system and implementation dependent, and cannot be reliable measure to measure the efficiency of the operation. In any case, the big O complexity of the vector addition operation is linear, meaning O(n).

blocks|key|2784068|text|在我看来，使用numpy更简单：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2784069|import+numpy+as+np
list1=[1,2,3]
list2=[4,5,6]
np.add(list1,list2)|code-block|syntax|javascript|2784070|结果：|2784071|​|2784072|📷|atomic|2784073|2784074|有关详细参数信息，请查看：numpy.add|2784075|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/085470483c71b8dd7456aa1d13ccd47e.png|imageAlt|1|LINK|MUTABLE|url|https://docs.scipy.org/doc/numpy/reference/generated/numpy.add.html^0|7|5|0|0|0|0|0|1|0|0|0|D|9|1|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1C|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1D|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1E|8|@]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|R|3|N|5|6|7|1I|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1J|8|@]|D|@$9|1K|A|1L|1|1M]]|E|$]]|$1|U|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11|12|-4]]|13|$5|14|Y|15|E|$16|17]]]]

It's simpler to use <code>numpy</code> from my opinion:

<pre><code>import numpy as np
list1=[1,2,3]
list2=[4,5,6]
np.add(list1,list2)
</code></pre>

Results:

<a href="https://i.stack.imgur.com/CLi2t.png" rel="noreferrer"><img src="https://i.stack.imgur.com/CLi2t.png" alt="Terminal execution"></a>

For detailed parameter information, check here: <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.add.html" rel="noreferrer">numpy.add</a>

blocks|key|2996558|text|使用numpy.add()很容易做到这一点|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|2996559|import+numpy

list1+=+numpy.array([1,+2,+3])
list2+=+numpy.array([4,+5,+6])
result+=+numpy.add(list1,+list2)+#+result+receive+element-wise+addition+of+list1+and+list2
print(result)
array([5,+7,+9])|code-block|syntax|javascript|2996560|See+doc+here|2996561|如果你想接收一个python列表：|2996562|result.tolist()|2996563|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.add.html#numpy-add^0|2|B|2|B|0|0|0|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|14|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|15|8|@]|E|@$9|16|A|17|1|18]]|F|$]]|$1|N|3|O|5|6|7|19|8|@]|E|@]|F|$]]|$1|P|3|Q|5|I|7|1A|8|@]|E|@]|F|$J|K]]|$1|R|3|-4|5|6|7|1B|8|@]|E|@]|F|$]]]|S|$T|$5|U|V|W|F|$X|Y]]]]

This is simple with <code>numpy.add()</code>

<pre><code>import numpy

list1 = numpy.array([1, 2, 3])
list2 = numpy.array([4, 5, 6])
result = numpy.add(list1, list2) # result receive element-wise addition of list1 and list2
print(result)
array([5, 7, 9])
</code></pre>

<a href="https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.add.html#numpy-add" rel="noreferrer">See doc here</a>

If you want to receiver a python list:

<pre><code>result.tolist()
</code></pre>

blocks|key|2784099|text|如果你有一个未知数量的列表，并且不需要导入任何东西，那么这可能是pythonic式的，并且有一点用处。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2784100|只要列表的长度相同，就可以使用下面的函数。|2784101|在这里，*args接受数量可变的列表参数(但每个参数中只包含相同数量的元素)。|2784102|在返回的列表中再次使用*对每个列表中的元素进行解包。|2784103|def+sum_lists(*args):
++++return+list(map(sum,+zip(*args)))

a+=+[1,2,3]
b+=+[1,2,3]++

sum_lists(a,b)|code-block|syntax|javascript|2784104|输出：|2784105|[2,+4,+6]|2784106|或使用3个列表|2784107|sum_lists([5,5,5,5,5],+[10,10,10,10,10],+[4,4,4,4,4])|2784108|2784109|[19,+19,+19,+19,+19]|2784110|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|13|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|16|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|U|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|V|3|W|5|J|7|19|8|@]|9|@]|A|$K|L]]|$1|X|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|Y|$]]

Perhaps this is pythonic and slightly useful if you have an unknown number of lists, and without importing anything.

As long as the lists are of the same length, you can use the below function.

Here the *args accepts a variable number of list arguments (but only sums the same number of elements in each). 

The * is used again in the returned list to unpack the elements in each of the lists.

<pre><code>def sum_lists(*args):
 return list(map(sum, zip(*args)))

a = [1,2,3]
b = [1,2,3] 

sum_lists(a,b)
</code></pre>

Output:

<pre><code>[2, 4, 6]
</code></pre>

Or with 3 lists

<pre><code>sum_lists([5,5,5,5,5], [10,10,10,10,10], [4,4,4,4,4])
</code></pre>

Output:

<pre><code>[19, 19, 19, 19, 19]
</code></pre>

blocks|key|2996599|text|a_list+=+[]
b_list+=+[]
for+i+in+range(1,100):
++++a_list.append(random.randint(1,100))

for+i+in+range(1,100):
++++a_list.append(random.randint(101,200))
[sum(x)+for+x+in+zip(a_list+,+b_list+)]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2996600|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>a_list = []
b_list = []
for i in range(1,100):
 a_list.append(random.randint(1,100))

for i in range(1,100):
 a_list.append(random.randint(101,200))
[sum(x) for x in zip(a_list , b_list )]
</code></pre>

blocks|key|176458|text|当你有一个列表的列表(而不是只有两个列表)你可以使用不同长度的v3.|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|176459|For列表(例如:在第一个/第二个列表的末尾加1)，然后你可以尝试这样(使用zip_longest)+-+v4|unordered-list-item|176460|
，|176461|这个函数在这里很有用，和列表理解函数一起使用|176462|176463|first+=+[1,+2,+3,+1]
second+=+[4,+5,+6]

output:+[5,+7,+9,+1]|code-block|syntax|javascript|176464|如果具有相同长度的未知数量的列表，则可以使用函数v5.+|176465|176466|176467|176468|v6+-运算符模块导出一组与Python的内部运算符相对应的有效函数。例如，operator.add(x,+y)等效于表达式x%2By.|176469|176470|176471|v7+-假设列表first和second的长度相同，则不需要压缩或其他任何内容。|176472|176473|################
first+=+[1,+2,+3]
second+=+[4,+5,+6]

#######+v1+########
third1+=+[sum(i)+for+i+in+zip(first,second)]

#######+v2+########
third2+=+[x+%2B+y+for+x,+y+in+zip(first,+second)]

#######+v3+########
lists_of_lists+=+[[1,+2,+3],+[4,+5,+6]]
third3+=+[sum(x)+for+x+in+zip(*lists_of_lists)]

#######+v4+########
from+itertools+import+zip_longest
third4+=+list(map(sum,+zip_longest(first,+second,+fillvalue=0)))

#######+v5+########
def+sum_lists(*args):
++++return+list(map(sum,+zip(*args)))

third5+=+sum_lists(first,+second)

#######+v6+########
import+operator
third6+=+list(map(operator.add,+first,second))

#######+v7+########
third7+=[first[i]%2Bsecond[i]+for+i+in+range(len(first))]

#######+v(i)+########

print(third1)+#+[5,+7,+9]
print(third2)+#+[5,+7,+9]
print(third3)+#+[5,+7,+9]
print(third4)+#+[5,+7,+9]
print(third5)+#+[5,+7,+9]
print(third6)+#+[5,+7,+9]
print(third7)+#+[5,+7,+9]|176474|entityMap^0|V|2|0|1H|2|0|0|0|0|0|O|2|0|0|0|0|0|2|12|I|1Q|3|0|0|0|0|2|8|5|E|6|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1E|8|@]|D|@]|E|$]]|$1|K|3|L|5|H|7|1F|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1H|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|H|7|1L|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]|$1|X|3|Y|5|H|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]|$1|11|3|12|5|H|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@]|E|$]]|$1|13|3|-4|5|6|7|24|8|@]|D|@]|E|$]]|$1|14|3|15|5|P|7|25|8|@]|D|@]|E|$Q|R]]|$1|16|3|-4|5|6|7|26|8|@]|D|@]|E|$]]]|17|$]]

<ul>
<li>The zip function is useful here, used with a list comprehension <code>v1</code>, <code>v2</code>.</li>
<li>If you have a list of lists (instead of just two lists) you can use <code>v3</code>.</li>
<li>For lists with different length (for example: By adding 1 to the end of the first/secound list), then you can try something like this (using zip_longest) - <code>v4</code></li>
</ul>
<pre><code>first = [1, 2, 3, 1]
second = [4, 5, 6]

output: [5, 7, 9, 1]
</code></pre>
<ul>
<li>If you have an unknown number of lists of the same length, you can use the function <code>v5</code>.
</li>
<li><code>v6</code> - The operator module exports a set of efficient functions corresponding to the intrinsic operators of Python. For example, <code>operator.add(x, y)</code> is equivalent to the expression <code>x+y</code>.
</li>
<li><code>v7</code> - Assuming both lists <code>first</code> and <code>second</code> have same length, you do not need zip or anything else.
</li>
</ul>
<pre class="lang-py prettyprint-override"><code>################
first = [1, 2, 3]
second = [4, 5, 6]

####### v1 ########
third1 = [sum(i) for i in zip(first,second)]

####### v2 ########
third2 = [x + y for x, y in zip(first, second)]

####### v3 ########
lists_of_lists = [[1, 2, 3], [4, 5, 6]]
third3 = [sum(x) for x in zip(*lists_of_lists)]

####### v4 ########
from itertools import zip_longest
third4 = list(map(sum, zip_longest(first, second, fillvalue=0)))

####### v5 ########
def sum_lists(*args):
 return list(map(sum, zip(*args)))

third5 = sum_lists(first, second)

####### v6 ########
import operator
third6 = list(map(operator.add, first,second))

####### v7 ########
third7 =[first[i]+second[i] for i in range(len(first))]

####### v(i) ########

print(third1) # [5, 7, 9]
print(third2) # [5, 7, 9]
print(third3) # [5, 7, 9]
print(third4) # [5, 7, 9]
print(third5) # [5, 7, 9]
print(third6) # [5, 7, 9]
print(third7) # [5, 7, 9]
</code></pre>

I have now:

<pre><code>list1 = [1, 2, 3]
list2 = [4, 5, 6]
</code></pre>

I wish to have:

<pre class="lang-none prettyprint-override"><code>[1, 2, 3]
 + + +
[4, 5, 6]
|| || ||
[5, 7, 9]
</code></pre>

Simply an element-wise addition of two lists.

I can surely iterate the two lists, but I don't want do that.

What is the most Pythonic way of doing so?

Element-wise addition of 2 lists?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我现在有了：list1 = [1, 2, 3]list2 = [4, 5, 6]我希望：[1, 2, 3] +  +  +[4, 5, 6]|| || ||[5, 7, 9]简单地按元素添加两个列表。我当然可以迭代这两个列表，但我不想这样做。什么是最具Pythonic风格的方式呢？

问2个列表的元素相加？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问2个列表的元素相加？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问2个列表的元素相加？
EN