我想执行元素明智的乘法，将两个列表按值在Python中相乘，就像我们在Matlab中可以做到的那样。

这就是我在Matlab中要做的。

对于a中x的x * y和b中y的每个组合，列表理解将给出16个列表条目。 不确定如何映射。

如果有人对为什么感兴趣，我有一个数据集，并想将其乘以Numpy.linspace(1.0, 0.5, num=len(dataset)) =)。

为什么现在已经有关于numpy的问题呢？

顺便说一下，这是逐元素乘法，这不是点积。

可选：map(lambda x，y：x * y，list1，list2)#derp ...

使用列表理解与zip()：混合。

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

另一方面，如果他们想做一些琐碎的事，OP最好使用Numpy。

在Python 2上，izip()可能是更好的选择。

完美，可在Python3中使用

您也可以使用map(lambda x,y:x*y,lista,listb)。

如果给出而不是listb的话，答案将如何变化？给出了listb类型的元素的相当列表，我们需要操作以获得一个列表。例如[x，pi，e)与[(4，5，2)，(1,2,4)，(4，5，6)，(1，1，2)，(3，3，4)]，取(x，pi，e)用(4，5，2)运算，然后(x，pi，e)用(1,2，4)运算...等等。

@gxyd您应该问一个单独的问题

只是添加了mbomb007所说的内容。要将其放入列表形式，您需要使用list(map(lambda x ,y: x * y, lista, listb))

由于您已经在使用numpy，因此将数据存储在numpy数组而不是列表中很有意义。完成此操作后，您将免费获得类似智能元素的产品：

也许不是最科学的方法，但我使用timeit将其与gahooas答案相对应。 Numpy实际上比zip方法要慢一些。

就我而言，列表包含二进制值，因此numpy解决方案比使用izip快得多。

为了其他人从谷歌搜索到达这里的利益，我在下面提供了一个时间比较。

解决方案是好的，但不是优化的。

使用np.multiply(a，b)：

您可以尝试将每个元素乘以一个循环。这样做的捷径是

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

欢迎来到stackoverflow！通常不建议仅使用代码的答案-请添加一些有关如何解决发问者问题的解释。

@CorleyBrigman我不同意；答案"这里是一种执行方法："和仅" "之间的区别很小。在这种特殊情况下，除了"此代码解决了您的问题"之外，几乎没有其他解释。

@CorleyBrigman我不同意；显示结果的示例数据实际上会更有帮助

这是一位Python新手的C，C ++或Java程序员如何解决该问题。可接受的答案是惯用的Python。

相当直观的方法：

还有一个答案：

-1 ...需要导入

+1 ...可读性强

1

2

3

4

5import operator

a = [1,2,3,4]

b = [10,11,12,13]

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

输出[10、22、36、52]

您可以使用lambda进行乘法

1

2

3foo=[1,2,3,4]

bar=[1,2,5,55]

l=map(lambda x,y:x*y,foo,bar)

没有任何导入的模块，很好的答案。

创建一个数组；

将每个列表乘以数组；

将数组转换为列表

1

2

3

4

5

6

7

8import 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]

对于大型列表，我们可以反复进行：

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

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

输出将是两个输入列表中较短者的长度。

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

1

2

3

4

5

6

7

8

9

10

11

120.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

即来自以下测试程序。

map函数在这里可能非常有用。

使用map，我们可以将任何函数应用于可迭代对象的每个元素。

Python 3.x

当然：

1map(f, iterable)

相当于

1[f(x) for x in iterable]

因此，我们可以通过以下方式获得解决方案：

1

2

3>>> [my_mul(x,y) for x, y in zip(a,b)]

[2, 6, 12, 20]

>>>

在Python 2.x中，map()的意思是：将函数应用于可迭代对象的每个元素并构造一个新列表。

在Python 3.x中，map构造迭代器而不是列表。

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

Python 2.7

1

2

3

4

5

6>>>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+

1

2

3

4

5

6>>> from operator import mul

>>> a = [1,2,3,4]

>>> b = [2,3,4,5]

>>> [*map(mul,a,b)]

[2, 6, 12, 20]

>>>

请注意，由于map()构造了迭代器，因此我们使用*可迭代的拆包运算符来获取列表。

解压缩方法比list构造函数快一点：

1

2

3>>> list(map(mul,a,b))

[2, 6, 12, 20]

>>>

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

1

2

3

4

5

6

7def lstsum(a, b):

c=0

pos = 0

for element in a:

c+= element*b[pos]

pos+=1

return c

要维护列表类型，并单行执行(当然，在将numpy导入为np之后)：

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

要么

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

可以使用枚举。

1

2

3

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

b = [2, 3, 4, 5]

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