如何在Python中执行两个列表的元素乘法？-Java 学习之路

我想执行元素明智的乘法，在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, 0.5, num=len(dataset)) =) .

14 回答

2
使用与 zip() 混合的列表推导： .
```
[a*b for a,b in zip(lista,listb)]
```
回复于 2024-04-29T07:25:09+08:00
4
由于您已经在使用 numpy ，因此将数据存储在 numpy 数组而不是列表中是有意义的 . 一旦你这样做，你就可以免费获得元素产品：
```
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])
```
回复于 2024-04-29T07:25:09+08:00
15
使用np.multiply（a，b）：
```
import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)
```
回复于 2024-04-29T07:25:09+08:00
0
您可以尝试在循环中乘以每个元素 . 这样做的简写就是
```
ab = [a[i]*b[i] for i in range(len(a))]
```
回复于 2024-04-29T07:25:09+08:00

相当直观的方式：

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

回复于 2024-04-29T07:25:09+08:00

创建一个数组;将每个列表乘以数组;将数组转换为列表

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]

回复于 2024-04-29T07:25:09+08:00

0
还有一个答案：

-1 ...需要导入
+1 ...非常易读
```
import operator
a = [1,2,3,4]
b = [10,11,12,13]

list(map(operator.mul, a, b))
```
产出[10,22,36,52]
回复于 2024-04-29T07:25:09+08:00
71
对于大型列表，我们可以通过以下方式实现：
```
product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])
```
product_iter_object.next() 给出输出列表中的每个元素 .

输出将是两个输入列表中较短者的长度 .
回复于 2024-04-29T07:25:09+08:00
4
你可以用 lambda 进行乘法运算
```
foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
```
回复于 2024-04-29T07:25:09+08:00

gahooa的答案对于 Headers 中的措辞是正确的，但是如果列表已经是大于10的numpy格式，那么它将更快（3个数量级）以及更具可读性，可以进行简单的numpy乘法，如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))

回复于 2024-04-29T07:25:09+08:00

208
map 函数在这里非常有用 . 使用 map ，我们可以将任何函数应用于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]
>>>
```
当然：
```
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.x中 map() 表示：将函数应用于iterable的每个元素并构造一个新列表 . 在Python 3.x中， map 构造迭代器而不是列表 .

我们可以使用 mul 运算符代替 my_mul

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]
>>>
```
请注意，由于 map() 构造了一个迭代器，我们使用 * iterable unpacking运算符来获取列表 . 解包方法比 list 构造函数快一点：
```
>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>
```
回复于 2024-04-29T07:25:09+08:00

可以使用枚举 .

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

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

回复于 2024-04-29T07:25:09+08:00

1
要保持列表类型，并在一行中执行（当然，将numpy导入为np之后）：
```
list(np.array([1,2,3,4]) * np.array([2,3,4,5]))
```
要么
```
list(np.array(a) * np.array(b))
```
回复于 2024-04-29T07:25:09+08:00

您可以将此用于相同长度的列表

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

回复于 2024-04-29T07:25:09+08:00

如何在Python中执行两个列表的元素乘法？

14 回答

相关问题