# python - total - write a function that takes a list of numbers and returns the cumulative sum

## How to find the cumulative sum of numbers in a list? (11)

Assignment expressions from PEP 572 (expected for Python 3.8) offer yet another way to solve this:

``````time_interval = [4, 6, 12]

total_time = 0
cum_time = [total_time := total_time + t for t in time_interval]
``````
``````time_interval = [4, 6, 12]
``````

I want to sum up the numbers like `[4, 4+6, 4+6+12]` in order to get the list `t = [4, 10, 22]`.

I tried the following:

``````for i in time_interval:
t1 = time_interval
t2 = time_interval + t1
t3 = time_interval + t2
print(t1, t2, t3)

4 10 22
4 10 22
4 10 22
``````

Behold:

``````a = [4, 6, 12]
reduce(lambda c, x: c + [c[-1] + x], a, )[1:]
``````

Will output (as expected):

``````[4, 10, 22]
``````

I did a bench-mark of the top two answers with Python 3.4 and I found `itertools.accumulate` is faster than `numpy.cumsum` under many circumstances, often much faster. However, as you can see from the comments, this may not always be the case, and it's difficult to exhaustively explore all options. (Feel free to add a comment or edit this post if you have further benchmark results of interest.)

Some timings...

For short lists `accumulate` is about 4 times faster:

``````from timeit import timeit

def sum1(l):
from itertools import accumulate
return list(accumulate(l))

def sum2(l):
from numpy import cumsum
return list(cumsum(l))

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

timeit(lambda: sum1(l), number=100000)
# 0.4243644131347537
timeit(lambda: sum2(l), number=100000)
# 1.7077815784141421
``````

For longer lists `accumulate` is about 3 times faster:

``````l = [1, 2, 3, 4, 5]*1000
timeit(lambda: sum1(l), number=100000)
# 19.174508565105498
timeit(lambda: sum2(l), number=100000)
# 61.871223849244416
``````

If the `numpy` `array` is not cast to `list`, `accumulate` is still about 2 times faster:

``````from timeit import timeit

def sum1(l):
from itertools import accumulate
return list(accumulate(l))

def sum2(l):
from numpy import cumsum
return cumsum(l)

l = [1, 2, 3, 4, 5]*1000

print(timeit(lambda: sum1(l), number=100000))
# 19.18597290944308
print(timeit(lambda: sum2(l), number=100000))
# 37.759664884768426
``````

If you put the imports outside of the two functions and still return a `numpy` `array`, `accumulate` is still nearly 2 times faster:

``````from timeit import timeit
from itertools import accumulate
from numpy import cumsum

def sum1(l):
return list(accumulate(l))

def sum2(l):
return cumsum(l)

l = [1, 2, 3, 4, 5]*1000

timeit(lambda: sum1(l), number=100000)
# 19.042188624851406
timeit(lambda: sum2(l), number=100000)
# 35.17324400227517
``````

If You want a pythonic way without numpy working in 2.7 this would be my way of doing it

``````l = [1,2,3,4]
_d={-1:0}
cumsum=[_d.setdefault(idx, _d[idx-1]+item) for idx,item in enumerate(l)]
``````

now let's try it and test it against all other implementations

``````import timeit
L=range(10000)

def sum1(l):
cumsum=[]
total = 0
for v in l:
total += v
cumsum.append(total)
return cumsum

def sum2(l):
import numpy as np
return list(np.cumsum(l))

def sum3(l):
return [sum(l[:i+1]) for i in xrange(len(l))]

def sum4(l):
return reduce(lambda c, x: c + [c[-1] + x], l, )[1:]

def this_implementation(l):
_d={-1:0}
return [_d.setdefault(idx, _d[idx-1]+item) for idx,item in enumerate(l)]

# sanity check
sum1(L)==sum2(L)==sum3(L)==sum4(L)==this_implementation(L)
>>> True

# PERFORMANCE TEST
timeit.timeit('sum1(L)','from __main__ import sum1,sum2,sum3,sum4,this_implementation,L', number=100)/100.
>>> 0.001018061637878418

timeit.timeit('sum2(L)','from __main__ import sum1,sum2,sum3,sum4,this_implementation,L', number=100)/100.
>>> 0.000829620361328125

timeit.timeit('sum3(L)','from __main__ import sum1,sum2,sum3,sum4,this_implementation,L', number=100)/100.
>>> 0.4606760001182556

timeit.timeit('sum4(L)','from __main__ import sum1,sum2,sum3,sum4,this_implementation,L', number=100)/100.
>>> 0.18932826995849608

timeit.timeit('this_implementation(L)','from __main__ import sum1,sum2,sum3,sum4,this_implementation,L', number=100)/100.
>>> 0.002348129749298096
``````

In Python 2 you can define your own generator function like this:

``````def accumu(lis):
total = 0
for x in lis:
total += x
yield total

In : list(accumu([4,6,12]))
Out: [4, 10, 22]
``````

And in Python 3.2+ you can use `itertools.accumulate()`:

``````In : lis = [4,6,12]

In : from itertools import accumulate

In : list(accumulate(lis))
Out: [4, 10, 22]
``````

Replying to the original question asking how "to sum up numbers in a list": Check out the built-in sum() function, it probably does what you want.

``````def wrand(vtlg):

def helpf(lalt,lneu):

if not lalt==[]:
return helpf(lalt[1::],[lalt+lneu]+lneu)
else:
lneu.reverse()
return lneu[1:]

return helpf(vtlg,)
``````

Try this:

``````result = []
acc = 0
for i in time_interval:
acc += i
result.append(acc)
``````

``````In : a = [4, 6, 12]

In : [sum(a[:i+1]) for i in xrange(len(a))]
Out: [4, 10, 22]
``````

This is slighlty faster than the generator method above by @Ashwini for small lists

``````In : %timeit list(accumu([4,6,12]))
100000 loops, best of 3: 2.63 us per loop

In : %timeit [sum(a[:i+1]) for i in xrange(len(a))]
100000 loops, best of 3: 2.46 us per loop
``````

For larger lists, the generator is the way to go for sure. . .

``````In : a = range(1000)

In : %timeit [sum(a[:i+1]) for i in xrange(len(a))]
100 loops, best of 3: 6.04 ms per loop

In : %timeit list(accumu(a))
10000 loops, best of 3: 162 us per loop
``````

``````def cummul_sum(list_arguement):
cumm_sum_lst = []
cumm_val = 0
for eachitem in list_arguement:
cumm_val += eachitem
cumm_sum_lst.append(cumm_val)
return cumm_sum_lst
``````

``````values = [4, 6, 12]
total  = 0
sums   = []

for v in values:
total = total + v
sums.append(total)

print 'Values: ', values
print 'Sums:   ', sums
``````

Running this code gives

``````Values: [4, 6, 12]
Sums:   [4, 10, 22]
`````` 