blocks|key|589443|text|使用与zip()：混合的列表理解。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|589444|[a*b+for+a,b+in+zip(lista,listb)]|code-block|syntax|javascript|589445|entityMap^0|3|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Use a list comprehension mixed with <code>zip()</code>:.

<pre><code>[a*b for a,b in zip(lista,listb)]
</code></pre>

blocks|key|589407|text|由于您已经在使用numpy，因此将数据存储在numpy数组中而不是列表中是有意义的。一旦你这样做了，你就可以免费获得像element-wise产品这样的东西：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|589408|In+[1]:+import+numpy+as+np

In+[2]:+a+=+np.array([1,2,3,4])

In+[3]:+b+=+np.array([2,3,4,5])

In+[4]:+a+*+b
Out[4]:+array([+2,++6,+12,+20])|code-block|syntax|javascript|589409|entityMap^0|8|5|M|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Since you're already using <code>numpy</code>, it makes sense to store your data in a <code>numpy</code> array rather than a list. Once you do this, you get things like element-wise products for free:

<pre><code>In [1]: import numpy as np

In [2]: a = np.array([1,2,3,4])

In [3]: b = np.array([2,3,4,5])

In [4]: a * b
Out[4]: array([ 2, 6, 12, 20])
</code></pre>

blocks|key|374017|text|使用np.multiply(a，b)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|374018|import+numpy+as+np
a+=+[1,2,3,4]
b+=+[2,3,4,5]
np.multiply(a,b)|code-block|syntax|javascript|374019|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 np.multiply(a,b):

<pre><code>import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)
</code></pre>

blocks|key|373801|text|您可以尝试在循环中将每个元素相乘。这样做的简写是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|373802|ab+=+[a[i]*b[i]+for+i+in+range(len(a))]|code-block|syntax|javascript|373803|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 try multiplying each element in a loop. The short hand for doing that is

<pre><code>ab = [a[i]*b[i] for i in range(len(a))]
</code></pre>

blocks|key|589844|text|还有另一个答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|589845|-1+...需要导入|offset|length|style|CODE|589846|%2B1+...可读性非常好。|589847|import+operator
a+=+[1,2,3,4]
b+=+[10,11,12,13]

list(map(operator.mul,+a,+b))|code-block|syntax|javascript|589848|输出10、22、36、52|589849|entityMap^0|0|0|2|0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Yet another answer:

<code>-1</code> ... requires import 
<code>+1</code> ... is very readable

<pre><code>import operator
a = [1,2,3,4]
b = [10,11,12,13]

list(map(operator.mul, a, b))
</code></pre>

outputs [10, 22, 36, 52]

blocks|key|589461|text|这是一种相当直观的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|589462|a+=+[1,2,3,4]
b+=+[2,3,4,5]
ab+=+[]++++++++++++++++++++++++#Create+empty+list
for+i+in+range(0,+len(a)):
+++++ab.append(a[i]*b[i])++++++#Adds+each+element+to+the+list|code-block|syntax|javascript|589463|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|$]]

Fairly intuitive way of doing this:

<pre><code>a = [1,2,3,4]
b = [2,3,4,5]
ab = [] #Create empty list
for i in range(0, len(a)):
 ab.append(a[i]*b[i]) #Adds each element to the list
</code></pre>

blocks|key|589680|text|可以使用lambda进行乘法运算|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|589681|foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda+x,y:x*y,foo,bar)|code-block|syntax|javascript|589682|entityMap^0|4|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

you can multiplication using <code>lambda</code> 

<pre><code>foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
</code></pre>

blocks|key|373868|text|对于较大的列表，我们可以使用iter-way：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|373869|product_iter_object+=+itertools.imap(operator.mul,+[1,2,3,4],+[2,3,4,5])|code-block|syntax|javascript|373870|product_iter_object.next()给出了输出列表中的每个元素。|offset|length|style|CODE|373871|输出将是两个输入列表中较短的一个的长度。|373872|entityMap^0|0|0|0|Q|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

For large lists, we can do it the iter-way:

<pre><code>product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])
</code></pre>

<code>product_iter_object.next()</code> gives each of the element in the output list.

The output would be the length of the shorter of the two input lists.

blocks|key|373944|text|创建1的数组；将每个列表乘以该数组；将数组转换为列表|type|unstyled|depth|inlineStyleRanges|entityRanges|data|373945|import+numpy+as+np

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

c+=+(np.ones(len(a))*a*b).tolist()

[2.0,+6.0,+12.0,+20.0]|code-block|syntax|javascript|373946|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|$]]

create an array of ones;
multiply each list times the array; 
convert array to a list

<pre><code>import numpy as np

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

c = (np.ones(len(a))*a*b).tolist()

[2.0, 6.0, 12.0, 20.0]
</code></pre>

blocks|key|373998|text|可以使用枚举。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|373999|a+=+[1,+2,+3,+4]
b+=+[2,+3,+4,+5]

ab+=+[val+*+b[i]+for+i,+val+in+enumerate(a)]|code-block|syntax|javascript|374000|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|$]]

Can use enumerate.

<pre><code>a = [1, 2, 3, 4]
b = [2, 3, 4, 5]

ab = [val * b[i] for i, val in enumerate(a)]
</code></pre>

blocks|key|374158|text|map函数在这里非常有用。使用map，我们可以将任何函数应用于迭代器的每个元素。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|374159|Python+3.x|374160|>>>+def+my_mul(x,y):
...+++++return+x*y
...
>>>+a+=+[1,2,3,4]
>>>+b+=+[2,3,4,5]
>>>
>>>+list(map(my_mul,a,b))
[2,+6,+12,+20]
>>>|code-block|syntax|javascript|374161|当然：|374162|map(f,+iterable)|374163|等同于|374164|[f(x)+for+x+in+iterable]|374165|因此，我们可以通过以下方式获得解决方案：|374166|>>>+[my_mul(x,y)+for+x,+y+in+zip(a,b)]
[2,+6,+12,+20]
>>>|374167|在Python2.x中，map()意味着:对迭代器的每个元素应用一个函数，并构造一个新的列表。在Python3.x中，map构造迭代器而不是列表。|374168|我们可以使用mul运算符来代替my_mul|374169|Python+2.7|374170|>>>from+operator+import+mul+#+import+mul+operator
>>>a+=+[1,2,3,4]
>>>b+=+[2,3,4,5]
>>>map(mul,a,b)
[2,+6,+12,+20]
>>>|374171|Python+3.5%2B|374172|>>>+from+operator+import+mul
>>>+a+=+[1,2,3,4]
>>>+b+=+[2,3,4,5]
>>>+[*map(mul,a,b)]
[2,+6,+12,+20]
>>>|374173|请注意，由于map()构造了一个迭代器，因此我们使用*可迭代解包运算符来获取列表。解包方法比list构造函数要快一点：|374174|>>>+list(map(mul,a,b))
[2,+6,+12,+20]
>>>|374175|entityMap^0|0|3|F|3|0|0|0|0|0|0|0|0|0|C|5|1N|3|0|6|3|F|6|0|0|0|0|0|6|5|Q|1|1A|4|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1L|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1N|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1O|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1P|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1R|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1S|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|23|8|@]|D|@]|E|$]]|$1|14|3|15|5|J|7|24|8|@]|D|@]|E|$K|L]]|$1|16|3|17|5|6|7|25|8|@]|D|@]|E|$]]|$1|18|3|19|5|J|7|26|8|@]|D|@]|E|$K|L]]|$1|1A|3|1B|5|6|7|27|8|@$9|28|A|29|B|C]|$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|J|7|2E|8|@]|D|@]|E|$K|L]]|$1|1E|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]]|1F|$]]

The <code>map</code> function can be very useful here.
Using <code>map</code> we can apply any function to each element of an iterable.

Python 3.x

<pre><code>&gt;&gt;&gt; def my_mul(x,y):
... return x*y
...
&gt;&gt;&gt; a = [1,2,3,4]
&gt;&gt;&gt; b = [2,3,4,5]
&gt;&gt;&gt;
&gt;&gt;&gt; list(map(my_mul,a,b))
[2, 6, 12, 20]
&gt;&gt;&gt;
</code></pre>

Of course: 

<pre><code>map(f, iterable)
</code></pre>

is equivalent to 

<pre><code>[f(x) for x in iterable]
</code></pre>

So we can get our solution via:

<pre><code>&gt;&gt;&gt; [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
&gt;&gt;&gt;
</code></pre>

In Python 2.x <code>map()</code> means: apply a function to each element of an iterable and construct a new list.
In Python 3.x, <code>map</code> construct iterators instead of lists. 

Instead of <code>my_mul</code> we could use <code>mul</code> operator

Python 2.7

<pre><code>&gt;&gt;&gt;from operator import mul # import mul operator
&gt;&gt;&gt;a = [1,2,3,4]
&gt;&gt;&gt;b = [2,3,4,5]
&gt;&gt;&gt;map(mul,a,b)
[2, 6, 12, 20]
&gt;&gt;&gt;
</code></pre>

Python 3.5+

<pre><code>&gt;&gt;&gt; from operator import mul
&gt;&gt;&gt; a = [1,2,3,4]
&gt;&gt;&gt; b = [2,3,4,5]
&gt;&gt;&gt; [*map(mul,a,b)]
[2, 6, 12, 20]
&gt;&gt;&gt;
</code></pre>

Please note that since <code>map()</code> constructs an iterator we use <code>*</code> iterable unpacking operator to get a list.
The unpacking approach is a bit faster then the <code>list</code> constructor:

<pre><code>&gt;&gt;&gt; list(map(mul,a,b))
[2, 6, 12, 20]
&gt;&gt;&gt;
</code></pre>

blocks|key|374241|text|维护list类型，并在一行中完成(当然，在将numpy导入为np之后)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|374242|list(np.array([1,2,3,4])+*+np.array([2,3,4,5]))|code-block|syntax|javascript|374243|或|374244|list(np.array(a)+*+np.array(b))|374245|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|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To maintain the list type, and do it in one line (after importing numpy as np, of course):

<pre><code>list(np.array([1,2,3,4]) * np.array([2,3,4,5]))
</code></pre>

or

<pre><code>list(np.array(a) * np.array(b))
</code></pre>

blocks|key|374276|text|您可以将其用于相同长度的列表|type|unstyled|depth|inlineStyleRanges|entityRanges|data|374277|def+lstsum(a,+b):
++++c=0
++++pos+=+0
for+element+in+a:
+++c%2B=+element*b[pos]
+++pos%2B=1
return+c|code-block|syntax|javascript|374278|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 use this for lists of the same length

<pre><code>def lstsum(a, b):
 c=0
 pos = 0
for element in a:
 c+= element*b[pos]
 pos+=1
return c
</code></pre>

blocks|key|589982|text|import+ast,sys
input_str+=+sys.stdin.read()

input_list+=+ast.literal_eval(input_str)

list_1+=+input_list[0]

list_2+=+input_list[1]

import+numpy+as+np

array_1+=+np.array(list_1)

array_2+=+np.array(list_2)

array_3+=+array_1*array_2


print(list(array_3))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|589983|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>import ast,sys
input_str = sys.stdin.read()

input_list = ast.literal_eval(input_str)

list_1 = input_list[0]

list_2 = input_list[1]

import numpy as np

array_1 = np.array(list_1)

array_2 = np.array(list_2)

array_3 = array_1*array_2


print(list(array_3))
</code></pre>

I want to perform an element wise multiplication, to multiply two lists together by value in Python, like we can do it in Matlab.

This is how I would do it in Matlab.

<pre><code>a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]
</code></pre>

A list comprehension would give 16 list entries, for every combination <code>x * y</code> of <code>x</code> from <code>a</code> and <code>y</code> from <code>b</code>. Unsure of how to map this.

If anyone is interested why, I have a dataset, and want to multiply it by <code>Numpy.linspace(1.0, 0.5, num=len(dataset)) =)</code>.

How to perform element-wise multiplication of two lists?

数据存储

Python

我想执行一个元素乘法，在Python中用值将两个列表相乘，就像我们在Matlab中做的那样。这就是我在Matlab中的方法。a = [1,2,3,4]b = [2,3,4,5]a .* b = [2, 6, 12, 20]对于来自a的x和来自b的y的每个组合，列表理解将给出16个列表条目。不确定如何映射它。如果任何人对原因感兴趣，我有一个数据集，并希望将其乘以Numpy.linspace(1.0,

问如何执行两个列表的元素乘法？
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何执行两个列表的元素乘法？EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何执行两个列表的元素乘法？
EN