我有一个清单：
my_list = [1, 2, 3, 4, 5]
如何将my_list 中的每个元素乘以 5？输出应该是：
[5, 10, 15, 20, 25]
【问题讨论】：
map优于for-loop。
map （如果map 需要lambda 总是更好）。
你可以使用list comprehension:
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]
【讨论】：
l1 和l2 作为变量名。
l1，例如l_1、list_1等。这些都比Num_1好。
一种更快的方法是以向量化的方式进行乘法运算，而不是循环遍历列表。 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 的方法，使用列表推导基本上是最 Pythonic 的方法。
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 中的所有项目传递给5 的__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)
【讨论】：
你可以像这样就地做：
l = [1, 2, 3, 4, 5]
l[:] = [x * 5 for x in l]
这不需要额外的导入并且非常 Pythonic。
【讨论】：
l = [x * 5 for x in l] 而不是l[:] = [x * 5 for x in l]。后者创建一个新列表，然后使用它覆盖l 的内容，而不是仅仅重新分配更便宜的引用。如果您真的担心空间问题，只需使用循环进行迭代并就地变异。
因为我认为您是 Python 新手，所以让我们从长远来看，使用 for 循环遍历您的列表，然后将每个元素相乘并将其附加到一个新列表中。
使用for循环
lst = [5, 20 ,15]
product = []
for i in lst:
product.append(i*5)
print product
使用列表推导，这也与使用 for-loop 相同，但更“pythonic”
lst = [5, 20 ,15]
prod = [i * 5 for i in lst]
print prod
【讨论】：
使用地图（不是那么好，但解决问题的另一种方法）：
list(map(lambda x: x*5,[5, 10, 15, 20, 25]))
另外，如果你碰巧使用的是 numpy 或 numpy 数组，你可以使用这个：
import numpy as np
list(np.array(x) * 5)
【讨论】：
from functools import partial as p
from operator import mul
map(p(mul,5),my_list)
是您可以做到的一种方法...您的老师可能知道一种简单得多可能在课堂上介绍过的方法
【讨论】：
map与lambda一起使用；当您需要lambda 时，最好使用列表理解或生成器表达式。如果你很聪明，你可以让map 在没有lambdas 的情况下工作很多，例如在这种情况下，map((5).__mul__, my_list)，尽管在这种特殊情况下，由于字节码解释器对简单的int 数学进行了一些优化，[x * 5 for x in my_list] 更快，并且更 Pythonic 和更简单。
将my_list 中的每个元素乘以k：
k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))
导致：[5, 10, 15, 20]
【讨论】：
我发现使用列表推导式或只有一个对象名称 x 的映射很有趣。 请注意，每当x is reassigned 时，它的 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
【讨论】：
最好的方法是使用列表推导：
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]
【讨论】：