如何执行两个列表的按元素相乘？

问题：如何执行两个列表的按元素相乘？

``````a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]``````

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.

``````a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]
``````

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

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

回答 0

``[a*b for a,b in zip(lista,listb)]``

Use a list comprehension mixed with `zip()`:.

``````[a*b for a,b in zip(lista,listb)]
``````

回答 1

``````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])``````

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

``````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])
``````

回答 2

``````import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)``````

Use np.multiply(a,b):

``````import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)
``````

回答 3

``ab = [a[i]*b[i] for i in range(len(a))]``

You can try multiplying each element in a loop. The short hand for doing that is

``````ab = [a[i]*b[i] for i in range(len(a))]
``````

回答 4

`-1`...需要导入
`+1`...非常易读

``````import operator
a = [1,2,3,4]
b = [10,11,12,13]

list(map(operator.mul, a, b))``````

`-1` ... requires import
`+1` ... is very readable

``````import operator
a = [1,2,3,4]
b = [10,11,12,13]

list(map(operator.mul, a, b))
``````

outputs [10, 22, 36, 52]

回答 5

``````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``````

Fairly intuitive way of doing this:

``````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
``````

回答 6

``````foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)``````

you can multiplication using `lambda`

``````foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
``````

回答 7

``product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])``

`product_iter_object.next()` 给出输出列表中的每个元素。

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

``````product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])
``````

`product_iter_object.next()` gives each of the element in the output list.

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

回答 8

``````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]``````

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

``````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]
``````

回答 9

gahooa的答案对于标题中所述的问题是正确的，但是如果列表已经是numpy格式大于十，它将更快（3个数量级）并且可读性更高，如NPE。我得到这些时间：

``````0.0049ms -> N = 4, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0075ms -> N = 4, a = [i for i in range(N)], c = a * b
0.0167ms -> N = 4, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 4, a = np.arange(N), c = a * b
0.0171ms -> N = 40, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0095ms -> N = 40, a = [i for i in range(N)], c = a * b
0.1077ms -> N = 40, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 40, a = np.arange(N), c = a * b
0.1485ms -> N = 400, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0397ms -> N = 400, a = [i for i in range(N)], c = a * b
1.0348ms -> N = 400, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0020ms -> N = 400, a = np.arange(N), c = a * b``````

``````import timeit

init = ['''
import numpy as np
N = {}
a = {}
b = np.linspace(0.0, 0.5, len(a))
'''.format(i, j) for i in [4, 40, 400]
for j in ['[i for i in range(N)]', 'np.arange(N)']]

func = ['''c = [a*b for a,b in zip(a, b)]''',
'''c = a * b''']

for i in init:
for f in func:
lines = i.split('\n')
print('{:6.4f}ms -> {}, {}, {}'.format(
timeit.timeit(f, setup=i, number=1000), lines[2], lines[3], f))``````

gahooa's answer is correct for the question as phrased in the heading, but if the lists are already numpy format or larger than ten it will be MUCH faster (3 orders of magnitude) as well as more readable, to do simple numpy multiplication as suggested by NPE. I get these timings:

``````0.0049ms -> N = 4, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0075ms -> N = 4, a = [i for i in range(N)], c = a * b
0.0167ms -> N = 4, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 4, a = np.arange(N), c = a * b
0.0171ms -> N = 40, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0095ms -> N = 40, a = [i for i in range(N)], c = a * b
0.1077ms -> N = 40, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 40, a = np.arange(N), c = a * b
0.1485ms -> N = 400, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0397ms -> N = 400, a = [i for i in range(N)], c = a * b
1.0348ms -> N = 400, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0020ms -> N = 400, a = np.arange(N), c = a * b
``````

i.e. from the following test program.

``````import timeit

init = ['''
import numpy as np
N = {}
a = {}
b = np.linspace(0.0, 0.5, len(a))
'''.format(i, j) for i in [4, 40, 400]
for j in ['[i for i in range(N)]', 'np.arange(N)']]

func = ['''c = [a*b for a,b in zip(a, b)]''',
'''c = a * b''']

for i in init:
for f in func:
lines = i.split('\n')
print('{:6.4f}ms -> {}, {}, {}'.format(
timeit.timeit(f, setup=i, number=1000), lines[2], lines[3], f))
``````

回答 10

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

ab = [val * b[i] for i, val in enumerate(a)]``````

Can use enumerate.

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

ab = [val * b[i] for i, val in enumerate(a)]
``````

回答 11

`map`功能在这里可能非常有用。使用`map`我们可以将任何函数应用于可迭代对象的每个元素。

Python 3.x

``````>>> 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]
>>>``````

``map(f, iterable)``

``[f(x) for x in iterable]``

``````>>> [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
>>>``````

Python 2.7

``````>>>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]
>>>``````

Python 3.5+

``````>>> from operator import mul
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>> [*map(mul,a,b)]
[2, 6, 12, 20]
>>>``````

``````>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>``````

The `map` function can be very useful here. Using `map` we can apply any function to each element of an iterable.

Python 3.x

``````>>> 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]
>>>
``````

Of course:

``````map(f, iterable)
``````

is equivalent to

``````[f(x) for x in iterable]
``````

So we can get our solution via:

``````>>> [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
>>>
``````

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

Instead of `my_mul` we could use `mul` operator

Python 2.7

``````>>>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]
>>>
``````

Python 3.5+

``````>>> from operator import mul
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>> [*map(mul,a,b)]
[2, 6, 12, 20]
>>>
``````

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

``````>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>
``````

回答 12

``list(np.array([1,2,3,4]) * np.array([2,3,4,5]))``

``list(np.array(a) * np.array(b))``

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

``````list(np.array([1,2,3,4]) * np.array([2,3,4,5]))
``````

or

``````list(np.array(a) * np.array(b))
``````

回答 13

``````def lstsum(a, b):
c=0
pos = 0
for element in a:
c+= element*b[pos]
pos+=1
return c``````

you can use this for lists of the same length

``````def lstsum(a, b):
c=0
pos = 0
for element in a:
c+= element*b[pos]
pos+=1
return c
``````