Come trovare la somma cumulativa di numeri in una lista?

Question

time_interval = [4, 6, 12] 

Voglio riassumere i numeri come [4, 4+6, 4+6+12] per ottenere l'elenco t = [4, 10, 22].

ho provato la seguente:

for i in time_interval: 
    t1 = time_interval[0] 
    t2 = time_interval[1] + t1 
    t3 = time_interval[2] + t2 
    print(t1, t2, t3) 

4 10 22 
4 10 22 
4 10 22 

Answer 1

Rispondendo alla domanda iniziale chiedendo come "per riassumere i numeri in un elenco": Controlla la funzione di somma built-in(), probabilmente fa quello che si volere.

Answer 2

In Python 2 è possibile definire la propria funzione di generatore in questo modo:

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

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

E in Python 3.2 + è possibile utilizzare itertools.accumulate():

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

In [2]: from itertools import accumulate 

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

Answer 3

In primo luogo, si vuole un elenco aggiornato dei sottosuccessioni :

subseqs = (seq[:i] for i in range(1, len(seq)+1)) 

Quindi basta chiamare sum su eac h subsequence:

sums = [sum(subseq) for subseq in subseqs] 

(Questo non è il modo più efficace per farlo, perché si sta aggiungendo tutti i prefissi più volte. Ma questo probabilmente non ha importanza per la maggior parte dei casi di utilizzo.)

Se stai usando Python 3.2 o più recente, puoi usare itertools.accumulate in farlo per voi:

sums = itertools.accumulate(seq) 

e se si sta utilizzando 3.1 o versioni precedenti, si può semplicemente copiare il "equivale a" fonte direttamente fuori la documentazione (ad eccezione di cambiare next(it)-it.next() per 2,5 e precedenti).

Answer 4

Prova questo: (? Liste più grandi)

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

Answer 5

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

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

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

L'esecuzione di questo codice dà

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

Answer 6

lst = [4,6,12] 

[sum(lst[:i+1]) for i in xrange(len(lst))] 

Se siete alla ricerca di una soluzione più efficiente un generatore potrebbe essere un buona chiamata (o semplicemente usare numpy se ti interessa davvero il perf).

def gen(lst): 
    acu = 0 
    for num in lst: 
     yield num + acu 
     acu += num 

print list(gen([4, 6, 12])) 

Answer 7

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

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

Questo è slighlty più veloce rispetto al metodo di generatore di cui sopra da @Ashwini per le piccole liste

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

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

Per le liste più grandi, il generatore è la strada da percorrere per certo. . .

In [50]: a = range(1000) 

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

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

Answer 8

Se si sta facendo molto lavoro numerica con gli array come questo, io suggerirei numpy, che viene fornito con una funzione di somma cumulativa cumsum:

import numpy as np 

a = [4,6,12] 

np.cumsum(a) 
#array([4, 10, 22]) 

Numpy è spesso più veloce puro Python per questo genere di cose, vedere in confronto al @Ashwini's accumu:

In [136]: timeit list(accumu(range(1000))) 
10000 loops, best of 3: 161 us per loop 

In [137]: timeit list(accumu(xrange(1000))) 
10000 loops, best of 3: 147 us per loop 

In [138]: timeit np.cumsum(np.arange(1000)) 
100000 loops, best of 3: 10.1 us per loop 

Ma naturalmente se è l'unico posto che verrà utilizzato NumPy, potrebbe non essere w ort avere dipendenza da esso.

Answer 9

Un po 'hacky, ma sembra funzionare:

def cumulative_sum(l): 
    y = [0] 
    def inc(n): 
    y[0] += n 
    return y[0] 
    return [inc(x) for x in l] 

pensavo che la funzione interna sarebbe in grado di modificare la y dichiarato nel scope lessicale esterno, ma che non ha funzionato, così abbiamo giochiamo alcuni brutti hack con modifica della struttura. Probabilmente è più elegante usare un generatore.

Answer 10

Senza dover utilizzare Numpy, è possibile eseguire il ciclo direttamente sull'array e accumulare la somma lungo la strada. Per esempio:

a=range(10) 
i=1 
while((i>0) & (i<10)): 
    a[i]=a[i-1]+a[i] 
    i=i+1 
print a 

risultati in:

[0, 1, 3, 6, 10, 15, 21, 28, 36, 45] 

Answer 11

Ecco:

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

uscita Will (come previsto):

[4, 10, 22] 

Answer 12

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 

Answer 13

T il suo sarebbe Haskell-style:

def wrand(vtlg): 

    def helpf(lalt,lneu): 

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

    return helpf(vtlg,[0]) 

Answer 14

ho fatto una panchina-mark dei primi due risposte con Python 3.4 e ho trovato itertools.accumulate è più veloce di numpy.cumsum in molte circostanze, spesso molto più veloce. Tuttavia, come puoi vedere dai commenti, questo potrebbe non essere sempre il caso, ed è difficile esplorare esaustivamente tutte le opzioni. (Sentiti libero di aggiungere un commento o modificare questo post se hai ulteriori risultati di riferimento di interesse.)

Alcuni tempi ...

Per brevi liste accumulate è di circa 4 volte più veloce:

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 

Per gli elenchi più lunghi accumulate è di circa 3 volte più veloce:

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

Se il numpyarray non è gettato a list, accumulate è ancora circa 2 volte più veloce:

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 

Se si mettono le importazioni al di fuori delle due funzioni ed ancora restituire un numpyarray, accumulate è ancora quasi 2 volte più veloce:

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 

Answer 15

Se vuoi un modo divinatorio senza NumPy lavorare in 2.7 questo sarebbe il mio modo di fare

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

ora proviamo e testarla contro tutte le altre implementazioni

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, [0])[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