You can just use a 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]
Note that a list comprehension is generally a more efficient way to do a for
loop:
my_new_list = []
for i in my_list:
my_new_list.append(i * 5)
>>> print(my_new_list)
[5, 10, 15, 20, 25]
As an alternative, here is a solution using the popular Pandas package:
import pandas as pd
s = pd.Series(my_list)
>>> s * 5
0 5
1 10
2 15
3 20
4 25
dtype: int64
Or, if you just want the list:
>>> (s * 5).tolist()
[5, 10, 15, 20, 25]
Finally, one could use map
, although this is generally frowned upon.
my_new_list = map(lambda x: x * 5, my_list)
Using map
, however, is generally less efficient. Per a comment from ShadowRanger on a deleted answer to this question:
The reason “no one” uses it is that, in general, it’s a performance
pessimization. The only time it’s worth consideringmap
in CPython is
if you’re using a built-in function implemented in C as the mapping
function; otherwise,map
is going to run equal to or slower than the
more Pythonic listcomp or genexpr (which are also more explicit about
whether they’re lazy generators or eagerlist
creators; on Py3, your
code wouldn’t work without wrapping themap
call inlist
). If you’re
usingmap
with alambda
function, stop, you’re doing it wrong.
And another one of his comments posted to this reply:
Please don’t teach people to use
map
withlambda
; the instant you
need alambda
, you’d have been better off with a list comprehension
or generator expression. If you’re clever, you can makemap
work
withoutlambda
s a lot, e.g. in this case,map((5).__mul__, my_list)
, although in this particular case, thanks to some
optimizations in the byte code interpreter for simpleint
math,[x * 5 for x in my_list]
is faster, as well as being more Pythonic and simpler.