# Adding two lists element by element?

## Problem

I have now:

``````list1 = [1, 2, 3]
list2 = [4, 5, 6]
``````

I would like to have:

``````[1, 2, 3]
+  +  +
[4, 5, 6]
|| || ||
[5, 7, 9]
``````

It’s just a simple element-by-element addition of two lists.

I could iterate the two lists, but I’m not interested in doing so.

What is the most Pythonic approach to this?

## Solution #1

Use the operator with the map. add:

``````>>> from operator import add
>>> list( map(add, list1, list2) )
[5, 7, 9]
``````

or a comprehension of a list:

``````>>> [sum(x) for x in zip(list1, list2)]
[5, 7, 9]
``````
``````>>> list2 = [4, 5, 6]*10**5
>>> list1 = [1, 2, 3]*10**5
10 loops, best of 3: 44.6 ms per loop
>>> %timeit from itertools import izip; [a + b for a, b in izip(list1, list2)]
10 loops, best of 3: 71 ms per loop
>>> %timeit [a + b for a, b in zip(list1, list2)]
10 loops, best of 3: 112 ms per loop
>>> %timeit from itertools import izip;[sum(x) for x in izip(list1, list2)]
1 loops, best of 3: 139 ms per loop
>>> %timeit [sum(x) for x in zip(list1, list2)]
1 loops, best of 3: 177 ms per loop
``````

## Solution #2

Others demonstrated how to do it in pure Python. Numpy should be used if you wish to perform this with arrays of 100.000 elements:

``````In [1]: import numpy as np
In [2]: vector1 = np.array([1, 2, 3])
In [3]: vector2 = np.array([4, 5, 6])
``````

The element-by-element addition is now as simple as it gets.

``````In [4]: sum_vector = vector1 + vector2
In [5]: print sum_vector
[5 7 9]
``````

in the same way that Matlab does.

To compare with Ashwini’s fastest version, here’s the time:

``````In [16]: from operator import add
In [17]: n = 10**5
In [18]: vector2 = np.tile([4,5,6], n)
In [19]: vector1 = np.tile([1,2,3], n)
In [20]: list1 = [1,2,3]*n
In [21]: list2 = [4,5,6]*n
In [22]: timeit map(add, list1, list2)
10 loops, best of 3: 26.9 ms per loop

In [23]: timeit vector1 + vector2
1000 loops, best of 3: 1.06 ms per loop
``````

As a result, this is a factor of 25 faster! However, utilize whatever works best for you. You probably don’t want to install numpy for a basic program, so stick with normal Python (and Henry’s version is the most Pythonic). Allow numpy to perform the heavy lifting if you’re into serious number crunching. For speed enthusiasts, starting around n = 8, the numpy solution appears to be faster.

## Solution #3

``````[a + b for a, b in zip(list1, list2)]
``````

## Solution #4

As described by others, a fast and also space efficient solution is using numpy (np) with it’s built-in vector manipulation capability:

1. With Numpy

``````x = np.array([1,2,3])
y = np.array([2,3,4])
print x+y
``````

2. With built-ins

2.1 Lambda

``````list1=[1, 2, 3]
list2=[4, 5, 6]
print map(lambda x,y:x+y, list1, list2)
``````

It’s worth noting that map() accepts several arguments.

2.2 understanding of zip files and lists

``````list1=[1, 2, 3]
list2=[4, 5, 6]
print [x + y for x, y in zip(list1, list2)]
``````

## Solution #5

Numpy is, in my perspective, easier to use:

``````import numpy as np
list1=[1,2,3]
list2=[4,5,6]