# How to perform element-wise multiplication of two lists?

## Question:

I want to perform an element wise multiplication, to multiply two lists together by value in Python, like we can do it in Matlab.

This is how I would do it in Matlab.

```
a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]
```

A list comprehension would give 16 list entries, for every combination `x * y`

of `x`

from `a`

and `y`

from `b`

. Unsure of how to map this.

If anyone is interested why, I have a dataset, and want to multiply it by `Numpy.linspace(1.0, 0.5, num=len(dataset)) =)`

.

## Answers:

Since you’re already using `numpy`

, it makes sense to store your data in a `numpy`

array rather than a list. Once you do this, you get things like element-wise products for free:

```
In [1]: import numpy as np
In [2]: a = np.array([1,2,3,4])
In [3]: b = np.array([2,3,4,5])
In [4]: a * b
Out[4]: array([ 2, 6, 12, 20])
```

Use a list comprehension mixed with `zip()`

:.

```
[a*b for a,b in zip(lista,listb)]
```

Fairly intuitive way of doing this:

```
a = [1,2,3,4]
b = [2,3,4,5]
ab = [] #Create empty list
for i in range(0, len(a)):
ab.append(a[i]*b[i]) #Adds each element to the list
```

You can try multiplying each element in a loop. The short hand for doing that is

```
ab = [a[i]*b[i] for i in range(len(a))]
```

For large lists, we can do it the iter-way:

```
product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])
```

`product_iter_object.next()`

gives each of the element in the output list.

The output would be the length of the shorter of the two input lists.

create an array of ones;

multiply each list times the array;

convert array to a list

```
import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
c = (np.ones(len(a))*a*b).tolist()
[2.0, 6.0, 12.0, 20.0]
```

you can multiplication using `lambda`

```
foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
```

Can use enumerate.

```
a = [1, 2, 3, 4]
b = [2, 3, 4, 5]
ab = [val * b[i] for i, val in enumerate(a)]
```

gahooa’s answer is correct for the question as phrased in the heading, but if the lists are already numpy format ** or** larger than ten it will be MUCH faster (3 orders of magnitude) as well as more readable, to do simple numpy multiplication as suggested by NPE. I get these timings:

```
0.0049ms -> N = 4, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0075ms -> N = 4, a = [i for i in range(N)], c = a * b
0.0167ms -> N = 4, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 4, a = np.arange(N), c = a * b
0.0171ms -> N = 40, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0095ms -> N = 40, a = [i for i in range(N)], c = a * b
0.1077ms -> N = 40, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 40, a = np.arange(N), c = a * b
0.1485ms -> N = 400, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0397ms -> N = 400, a = [i for i in range(N)], c = a * b
1.0348ms -> N = 400, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0020ms -> N = 400, a = np.arange(N), c = a * b
```

i.e. from the following test program.

```
import timeit
init = ['''
import numpy as np
N = {}
a = {}
b = np.linspace(0.0, 0.5, len(a))
'''.format(i, j) for i in [4, 40, 400]
for j in ['[i for i in range(N)]', 'np.arange(N)']]
func = ['''c = [a*b for a,b in zip(a, b)]''',
'''c = a * b''']
for i in init:
for f in func:
lines = i.split('n')
print('{:6.4f}ms -> {}, {}, {}'.format(
timeit.timeit(f, setup=i, number=1000), lines[2], lines[3], f))
```

Use np.multiply(a,b):

```
import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)
```

Yet another answer:

`-1`

… requires import

`+1`

… is very readable

```
import operator
a = [1,2,3,4]
b = [10,11,12,13]
list(map(operator.mul, a, b))
```

outputs [10, 22, 36, 52]

## Edit

For Python3.6+ map does not automatically unpack values.

```
import itertools
import operator
itertools.starmap(operator.mul, zip(a, b)))
```

The `map`

function can be very useful here.

Using `map`

we can apply any function to each element of an iterable.

Python 3.x

```
>>> def my_mul(x,y):
... return x*y
...
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>>
>>> list(map(my_mul,a,b))
[2, 6, 12, 20]
>>>
```

Of course:

```
map(f, iterable)
```

is equivalent to

```
[f(x) for x in iterable]
```

So we can get our solution via:

```
>>> [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
>>>
```

In Python 2.x `map()`

means: apply a function to each element of an iterable and construct a new list.

In Python 3.x, `map`

construct iterators instead of lists.

Instead of `my_mul`

we could use `mul`

operator

Python 2.7

```
>>>from operator import mul # import mul operator
>>>a = [1,2,3,4]
>>>b = [2,3,4,5]
>>>map(mul,a,b)
[2, 6, 12, 20]
>>>
```

Python 3.5+

```
>>> from operator import mul
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>> [*map(mul,a,b)]
[2, 6, 12, 20]
>>>
```

Please note that since `map()`

constructs an iterator we use `*`

iterable unpacking operator to get a list.

The unpacking approach is a bit faster then the `list`

constructor:

```
>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>
```

To maintain the list type, and do it in one line (after importing numpy as np, of course):

```
list(np.array([1,2,3,4]) * np.array([2,3,4,5]))
```

or

```
list(np.array(a) * np.array(b))
```

you can use this for lists of the same length

```
def lstsum(a, b):
c=0
pos = 0
for element in a:
c+= element*b[pos]
pos+=1
return c
```

```
import ast,sys
input_str = sys.stdin.read()
input_list = ast.literal_eval(input_str)
list_1 = input_list[0]
list_2 = input_list[1]
import numpy as np
array_1 = np.array(list_1)
array_2 = np.array(list_2)
array_3 = array_1*array_2
print(list(array_3))
```