如何将列表中的每个元素乘以一个数字？

问题描述：

我有一个清单：

my_list = [1, 2, 3, 4, 5]

如何将每个元素my_list乘以 5？输出应为：

[5, 10, 15, 20, 25]

解决方案 1：

您只需使用列表推导即可：

my_list = [1, 2, 3, 4, 5]
my_new_list = [i * 5 for i in my_list]

>>> print(my_new_list)
[5, 10, 15, 20, 25]

请注意，列表推导通常是执行for循环的更有效的方法：

my_new_list = []
for i in my_list:
    my_new_list.append(i * 5)

>>> print(my_new_list)
[5, 10, 15, 20, 25]

作为替代方案，这里有一个使用流行的 Pandas 包的解决方案：

import pandas as pd

s = pd.Series(my_list)

>>> s * 5
0     5
1    10
2    15
3    20
4    25
dtype: int64

或者，如果你只想要列表：

>>> (s * 5).tolist()
[5, 10, 15, 20, 25]

最后，可以使用map，尽管这通常不被认可。

my_new_list = map(lambda x: x * 5, my_list)

但是，使用通常效率较低。根据ShadowRanger对这个问题已删除答案map的评论：

“没有人”使用它的原因是，总的来说，它是一种性能悲观主义。map在 CPython 中唯一值得考虑的情况是，如果您使用用 C 实现的内置函数作为映射函数；否则，map运行速度将等于或慢于更 Pythonic 的 listcomp 或 genexpr（它们也更明确地表明它们是惰性生成器还是热切创建者；在 Py3 上，如果不将调用包装在 中，list您的代码将无法工作）。如果您正在使用函数，请停止，您做错了。map`listmaplambda`

他在该回复中还发表了另一条评论：

请不要教人们使​​用map；lambda当你需要 时lambda，最好使用列表推导或生成器表达式。如果你聪明的话，你可以不用sa 就可以完成map工作，例如在这种情况下， ，尽管在这种特殊情况下，由于字节码解释器对简单数学进行了一些优化，它更快，也更 Pythonic 和更简单。lambda`map((5).__mul__, my_list)int[x * 5 for x in my_list]`

解决方案 2：

一种更快的方法是以矢量化方式进行乘法，而不是循环遍历列表。Numpy 已经提供了一种非常简单方便的方法供您使用。

>>> import numpy as np
>>> 
>>> my_list = np.array([1, 2, 3, 4, 5])
>>> 
>>> my_list * 5
array([ 5, 10, 15, 20, 25])

请注意，这不适用于 Python 的原生列表。如果你将一个数字与一个列表相乘，它会重复列表中的项目，其大小与该数字的大小相同。

In [15]: my_list *= 1000

In [16]: len(my_list)
Out[16]: 5000

如果您想要一种纯基于 Python 的方法，那么使用列表推导基本上是最 Python 化的方法。

In [6]: my_list = [1, 2, 3, 4, 5]

In [7]: [5 * i for i in my_list]
Out[7]: [5, 10, 15, 20, 25]

除了列表推导式，作为一种纯函数式方法，您还可以使用内置map()函数，如下所示：

In [10]: list(map((5).__mul__, my_list))
Out[10]: [5, 10, 15, 20, 25]

my_list此代码传递了to5方法中的所有项__mul__并返回一个类似迭代器的对象（在 python-3.x 中）。然后，您可以使用list()内置函数将迭代器转换为列表（在 Python-2.x 中，您不需要这样做，因为map默认情况下会返回一个列表）。

基准：

In [18]: %timeit [5 * i for i in my_list]
463 ns ± 10.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [19]: %timeit list(map((5).__mul__, my_list))
784 ns ± 10.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [20]: %timeit [5 * i for i in my_list * 100000]
20.8 ms ± 115 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [21]: %timeit list(map((5).__mul__, my_list * 100000))
30.6 ms ± 169 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)


In [24]: arr = np.array(my_list * 100000)

In [25]: %timeit arr * 5
899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

解决方案 3：

您可以像这样就地执行此操作：

 l = [1, 2, 3, 4, 5]
 l[:] = [x * 5 for x in l]

这不需要额外的导入并且非常符合 Python 风格。

解决方案 4：

因为我认为您是 Python 新手，所以让我们走一条长路，使用 for 循环遍历您的列表，然后将每个元素相乘并附加到新列表中。

使用 for 循环

lst = [5, 20 ,15]
product = []
for i in lst:
    product.append(i*5)
print product

使用列表推导，这也与使用 for 循环相同，但更“pythonic”

lst = [5, 20 ,15]

prod = [i * 5 for i in lst]
print prod

解决方案 5：

使用地图（不太好，但是解决问题的另一种方法）：

list(map(lambda x: x*5,[5, 10, 15, 20, 25]))

另外，如果你碰巧使用 numpy 或 numpy 数组，你可以使用这个：

import numpy as np
list(np.array(x) * 5)

解决方案 6：

from functools import partial as p
from operator import mul
map(p(mul,5),my_list)

是你可以做到的一种方法...你的老师可能知道一种更简单的方法，可能在课堂上讲过。

解决方案 7：

将中的每个元素my_list乘以k：

k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))

导致：[5, 10, 15, 20]

解决方案 8：

我发现使用列表推导或仅使用一个对象名称 x 的映射很有趣。请注意，每当重新分配 x时，其 id(x) 都会发生变化，即指向不同的对象。

x = [1, 2, 3]
id(x)
2707834975552
x = [1.5 * x for x in x]
id(x)
2707834976576
x
[1.5, 3.0, 4.5]
list(map(lambda x : 2 * x / 3, x))
[1.0, 2.0, 3.0]
id(x) # not reassigned
2707834976576
x = list(map(lambda x : 2 * x / 3, x))
x
[1.0, 2.0, 3.0]
id(x)
2707834980928

解决方案 9：

var1 = [2,4,6,8,10,12]

#for Integer multiplier us   int(x).__mull__ with map    
var2 = list( map(int(2).__mul__,var1 ))
#for float multiplier
var2 = list( map(float(2.5).__mul__,var1 ))

解决方案 10：

最好的方法是使用列表理解：

def map_to_list(my_list, n):
# multiply every value in my_list by n
# Use list comprehension!
    my_new_list = [i * n for i in my_list]
    return my_new_list
# To test:
print(map_to_list([1,2,3], -1))

返回：[-1，-2，-3]