I have a list:
my_list = [1, 2, 3, 4, 5]
How can I multiply each element in my_list by 5? The output should be:
[5, 10, 15, 20, 25]
Answers:
Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.
Method 1
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 consideringmapin 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.
Method 2
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.
>>> 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.
In [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.
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]
Beside list comprehension, as a pure functional approach, you can also use built-in map() function as following:
In [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:
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)
Method 3
You can do it in-place like so:
l = [1, 2, 3, 4, 5] l[:] = [x * 5 for x in l]
This requires no additional imports and is very pythonic.
Method 4
Since I think you are new with Python, lets do the long way, iterate thru your list using for loop and multiply and append each element to a new list.
using for loop
lst = [5, 20 ,15]
product = []
for i in lst:
product.append(i*5)
print product
using list comprehension, this is also same as using for-loop but more ‘pythonic’
lst = [5, 20 ,15] prod = [i * 5 for i in lst] print prod
Method 5
With map (not as good, but another approach to the problem):
list(map(lambda x: x*5,[5, 10, 15, 20, 25]))
also, if you happen to be using numpy or numpy arrays, you could use this:
import numpy as np list(np.array(x) * 5)
Method 6
from functools import partial as p from operator import mul map(p(mul,5),my_list)
is one way you could do it … your teacher probably knows a much less complicated way that was probably covered in class
Method 7
Multiplying each element in my_list by k:
k = 5 my_list = [1,2,3,4] result = list(map(lambda x: x * k, my_list))
resulting in: [5, 10, 15, 20]
Method 8
I found it interesting to use list comprehension or map with just one object name x.
Note that whenever x is reassigned, its id(x) changes, i.e. points to a different object.
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
Method 9
Best way is to use list comprehension:
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))
Returns:
[-1, -2, -3]
All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0