Elegante cumsum pitónico

Question

¿Cuál sería una manera elegante y pitónica de implementar cumsum? Alternativamente
- si there'a ya una forma integrada de hacerlo, que sería aún mejor por supuesto ...

Answer 1

Está disponible en Numpy:

>>> import numpy as np 
>>> np.cumsum([1,2,3,4,5]) 
array([ 1, 3, 6, 10, 15]) 

O utilice itertools.accumulate desde Python 3.2 :

>>> from itertools import accumulate 
>>> list(accumulate([1,2,3,4,5])) 
[ 1, 3, 6, 10, 15] 

Si Numpy no es una opción, un circuito generador sería la solución más elegante que se me ocurre:

def cumsum(it): 
    total = 0 
    for x in it: 
     total += x 
     yield total 

Ej.

>>> list(cumsum([1,2,3,4,5])) 
>>> [1, 3, 6, 10, 15] 

Answer 2

para los bucles son Pythonic

def cumsum(vec): 
    r = [vec[0]] 
    for val in vec[1:]: 
     r.append(r[-1] + val) 
    return r 

Answer 3

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

def cumsum(a): 
    a=iter(a) 
    cc=[next(a)] 
    for i in a: 
     cc.append(cc[-1]+i) 
    return cc 

print cumsum(a) 
"[1, 3, 6, 10, 15]" 

Answer 4

en su lugar:

a=[1,2,3,4,5] 
def cumsum(a): 
    for i in range(1,len(a)): 
     a[i]+=a[i-1] 

cumsum(a) 
print a 
"[1, 3, 6, 10, 15]" 

Answer 5

a=[1,2,3,4,5] 
def cumsum(a): 
    b=a[:] 
    for i in range(1,len(a)): 
     b[i]+=b[i-1] 
    return b 

print cumsum(a) 
"[1, 3, 6, 10, 15]" 

Answer 6

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

# Using list comprehention 
cumsum = [sum(a[:i+1]) for i in range(len(a))]   # [1, 3, 6, 10, 15] 

# Using map() 
cumsum = map(lambda i: sum(a[:i+1]), range(len(a)))  # [1, 3, 6, 10, 15] 

Answer 7

Mi idea era utilizar reducir de manera funcional:

from operator import iadd 
reduce(lambda acc, itm: iadd(acc, [acc[-1] + itm]), [1, 2, 3, 4, 5], [0])[1:] 
>>> [1, 3, 6, 10, 15] 

iadd del módulo del operador tiene la propiedad exclusiva de realizar una adición in situ y devolver el destino como resultado.

Si eso [1:] copia hace que usted está nervioso, que asimismo podría hacer:

from operator import iadd 
reduce(lambda acc, itm: (iadd(acc[0], [acc[1] + itm]), acc[1] + itm), 
     [1, 2, 3, 4, 5], ([], 0))[0] 
>>> [1, 3, 6, 10, 15] 

Pero descubrí que localmente el primer ejemplo es mucho más rápido y generadores de la OMI son más Pythonic de programación funcional como 'reducir ':

reduce(lambda acc, itm: (iadd(acc[0], [acc[1] + itm]), acc[1] + itm), values_ten, ([], 0))[0] 
Average: 6.4593828736e-06 
reduce(lambda acc, itm: (iadd(acc[0], [acc[1] + itm]), acc[1] + itm), values_mil, ([], 0))[0] 
Average: 0.727404361961 
reduce(lambda acc, itm: iadd(acc, [acc[-1] + itm]), values_ten, [0])[1:] 
Average: 5.16271911336e-06 
reduce(lambda acc, itm: iadd(acc, [acc[-1] + itm]), values_mil, [0])[1:] 
Average: 0.524223491301 
cumsum_rking(values_ten) 
Average: 1.9828751369e-06 
cumsum_rking(values_mil) 
Average: 0.234241141632 
list(cumsum_larsmans(values_ten)) 
Average: 2.02786211569e-06 
list(cumsum_larsmans(values_mil)) 
Average: 0.201473119335 

Aquí está la secuencia de comandos de referencia, tu caso es distinto:

from timeit import timeit 

def bmark(prog, setup, number): 
    duration = timeit(prog, setup=setup, number=number) 
    print prog 
    print 'Average:', duration/number 

values_ten = list(xrange(10)) 
values_mil = list(xrange(1000000)) 

from operator import iadd 

bmark('reduce(lambda acc, itm: (iadd(acc[0], [acc[1] + itm]), acc[1] + itm), \ 
values_ten, ([], 0))[0]', 
     setup='from __main__ import iadd, values_ten', number=1000000) 
bmark('reduce(lambda acc, itm: (iadd(acc[0], [acc[1] + itm]), acc[1] + itm), \ 
values_mil, ([], 0))[0]', 
     setup='from __main__ import iadd, values_mil', number=10) 

bmark('reduce(lambda acc, itm: iadd(acc, [acc[-1] + itm]), \ 
values_ten, [0])[1:]', 
     setup='from __main__ import iadd, values_ten', number=1000000) 
bmark('reduce(lambda acc, itm: iadd(acc, [acc[-1] + itm]), \ 
values_mil, [0])[1:]', 
     setup='from __main__ import iadd, values_mil', number=10) 

def cumsum_rking(iterable): 
    values = list(iterable) 
    for pos in xrange(1, len(values)): 
     values[pos] += values[pos - 1] 
    return values 

bmark('cumsum_rking(values_ten)', 
     setup='from __main__ import cumsum_rking, values_ten', number=1000000) 
bmark('cumsum_rking(values_mil)', 
     setup='from __main__ import cumsum_rking, values_mil', number=10) 

def cumsum_larsmans(iterable): 
    total = 0 
    for value in iterable: 
     total += value 
     yield total 

bmark('list(cumsum_larsmans(values_ten))', 
     setup='from __main__ import cumsum_larsmans, values_ten', number=1000000) 
bmark('list(cumsum_larsmans(values_mil))', 
     setup='from __main__ import cumsum_larsmans, values_mil', number=10) 

Y aquí está mi versión de Python cadena:

Python 2.7 (r27:82525, Jul 4 2010, 09:01:59) [MSC v.1500 32 bit (Intel)] on win32 

Answer 8

def cumsum(a): 
    return map(lambda x: sum(a[0:x+1]), range(0, len(a))) 

cumsum([1,2,3]) 

> [1, 3, 6]