You can just use a list comprehension:
Copymy_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:
Copymy_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:
Copyimport 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:
Copy>>> (s * 5).tolist()
[5, 10, 15, 20, 25]
Finally, one could use map, although this is generally frowned upon.
Copymy_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 considering
mapin CPython is if you're using a built-in function implemented in C as the mapping function; otherwise,mapis 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 eagerlistcreators; on Py3, your code wouldn't work without wrapping themapcall inlist). If you're usingmapwith alambdafunction, stop, you're doing it wrong.
And another one of his comments posted to this reply:
Answer from Alexander on Stack OverflowPlease don't teach people to use
mapwithlambda; the instant you need alambda, you'd have been better off with a list comprehension or generator expression. If you're clever, you can makemapwork withoutlambdas 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 simpleintmath,[x * 5 for x in my_list]is faster, as well as being more Pythonic and simpler.
You can just use a list comprehension:
Copymy_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:
Copymy_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:
Copyimport 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:
Copy>>> (s * 5).tolist()
[5, 10, 15, 20, 25]
Finally, one could use map, although this is generally frowned upon.
Copymy_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 considering
mapin CPython is if you're using a built-in function implemented in C as the mapping function; otherwise,mapis 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 eagerlistcreators; on Py3, your code wouldn't work without wrapping themapcall inlist). If you're usingmapwith alambdafunction, stop, you're doing it wrong.
And another one of his comments posted to this reply:
Please don't teach people to use
mapwithlambda; the instant you need alambda, you'd have been better off with a list comprehension or generator expression. If you're clever, you can makemapwork withoutlambdas 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 simpleintmath,[x * 5 for x in my_list]is faster, as well as being more Pythonic and simpler.
A blazingly faster approach is to do the multiplication in a vectorized manner instead of looping over the list. Numpy has already provided a very simply and handy way for this that you can use.
Copy>>> import numpy as np
>>>
>>> my_list = np.array([1, 2, 3, 4, 5])
>>>
>>> my_list * 5
array([ 5, 10, 15, 20, 25])
Note that this doesn't work with Python's native lists. If you multiply a number with a list it will repeat the items of the as the size of that number.
CopyIn [15]: my_list *= 1000
In [16]: len(my_list)
Out[16]: 5000
If you want a pure Python-based approach using a list comprehension is basically the most Pythonic way to go.
CopyIn [6]: my_list = [1, 2, 3, 4, 5]
In [7]: [5 * i for i in my_list]
Out[7]: [5, 10, 15, 20, 25]
Beside list comprehension, as a pure functional approach, you can also use built-in map() function as following:
CopyIn [10]: list(map((5).__mul__, my_list))
Out[10]: [5, 10, 15, 20, 25]
This code passes all the items within the my_list to 5's __mul__ method and returns an iterator-like object (in python-3.x). You can then convert the iterator to list using list() built in function (in Python-2.x you don't need that because map return a list by default).
benchmarks:
CopyIn [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)
Videos
ar = [0] * 3 ar[0] = 10 print(ar) # 10, 0, 0
ar = [ [0] * 3 ] * 3 ar[0][0] = 10 print(ar) # 10, 0, 0 , 10, 0, 0 , 10, 0, 0
-
operator on list creates n references to the same list hence the second case is digestible. But if that's the case why don't in 1d list we are getting 10, 10, 10?
Python 3.8+: use math.prod:
Copy>>> import math
>>> math.prod([1, 2, 3, 4, 5, 6])
720
Python <= 3.7: use functools.reduce:
Copy>>> from functools import reduce
>>> reduce(lambda x, y: x*y, [1, 2, 3, 4, 5, 6], 1)
720
You can use:
Copyimport operator
import functools
functools.reduce(operator.mul, [1,2,3,4,5,6], 1)
See reduce and operator.mul documentations for an explanation.
You need the import functools line in Python 3+.