Multiply all items in a list in Python

Question

How do I multiply the items in a list ?

For example:

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

def multiplyListItems(l):
   # some code here...

The expected calculation and return value is 1 x 2 x 3 x 4 x 5 = 120.

Answer 1

One way is to use reduce:

>>> num_list = [1,2,3,4,5]
>>> reduce(lambda x, y: x*y, num_list)
120

Answer 2

Use functools.reduce, which is faster (see below) and more forward-compatible with Python 3.

import operator
import functools

num_list = [1,2,3,4,5]
accum_value = functools.reduce(operator.mul, num_list)

print(accum_value)
# Output
120

---

Measure the execution time for 3 different ways,

# Way 1: reduce
$ python -m timeit "reduce(lambda x, y: x*y, [1,2,3,4,5])"
1000000 loops, best of 3: 0.727 usec per loop

# Way 2: np.multiply.reduce
$ python -m timeit -s "import numpy as np" "np.multiply.reduce([1,2,3,4,5])"
100000 loops, best of 3: 6.71 usec per loop

# Way 3: functools.reduce
$ python -m timeit -s "import operator, functools" "functools.reduce(operator.mul, [1,2,3,4,5])"
1000000 loops, best of 3: 0.421 usec per loop

---

For a bigger list, it is better to use np.multiply.reduce as mentioned by @MikeMüller.

$ python -m timeit "reduce(lambda x, y: x*y, range(1, int(1e5)))"
10 loops, best of 3: 3.01 sec per loop

$ python -m timeit -s "import numpy as np" "np.multiply.reduce(range(1, int(1e5)))"
100 loops, best of 3: 11.2 msec per loop

$ python -m timeit -s "import operator, functools" "functools.reduce(operator.mul, range(1, int(1e5)))"
10 loops, best of 3: 2.98 sec per loop

Answer 3

A NumPy solution:

>>> import numpy as np
>>> np.multiply.reduce(num_list)
120

Run times for a bit larger list:

In [303]:
from operator import mul
from functools import reduce
import numpy as np
​
a = list(range(1, int(1e5)))

In [304]
%timeit np.multiply.reduce(a)
100 loops, best of 3: 8.25 ms per loop

In [305]:
%timeit reduce(lambda x, y: x*y, a)
1 loops, best of 3: 5.04 s per loop

In [306]:
%timeit reduce(mul, a)
1 loops, best of 3: 5.37 s per loop

NumPy is largely implemented in C. Therefore, it can often be one or two orders of magnitudes faster than writing loops over Python lists. This works for larger arrays. If an array is small and it is used often form Python, things can be slower than using pure Python. This is because of the overhead converting between Python objects and C data types. In fact, it is an anti-pattern to write Python for loops to iterate over NumPy arrays.

Here, the list with five numbers causes considerable overhead compared to gain from the faster numerics.