Как найти суммарную сумму чисел в списке?

Если вы много работаете с такими массивами, я предлагаю numpy , который поставляется с кумулятивной функцией sum cumsum :

 import numpy as np a = [4,6,12] np.cumsum(a) #array([4, 10, 22]) 

Numpy часто быстрее, чем чистый питон для такого рода вещей, см. В сравнении с accumu @ 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 

Но, конечно, если это единственное место, где вы будете использовать numpy, возможно, не стоит зависеть от него.

В Python 2 вы можете определить свою собственную функцию генератора следующим образом:

 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] 

А в Python 3.2+ вы можете использовать itertools.accumulate() :

 In [1]: lis = [4,6,12] In [2]: from itertools import accumulate In [3]: list(accumulate(lis)) Out[3]: [4, 10, 22] 

Вот:

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

Будет выводиться (как и ожидалось):

 [4, 10, 22] 

Я сделал оценку двух лучших ответов с Python 3.4, и я обнаружил, что itertools.accumulate быстрее, чем numpy.cumsum при многих обстоятельствах, часто намного быстрее. Однако, как вы можете видеть из комментариев, это может быть не всегда так, и трудно исчерпывающе изучить все варианты. (Не стесняйтесь добавлять комментарий или редактировать этот пост, если у вас есть дополнительные результаты для сравнения.)

Некоторые тайминги …

Для коротких списков accumulate примерно в 4 раза быстрее:

 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 

Для более длинных списков accumulate примерно в 3 раза быстрее:

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

Если array numpy не отображается в list , accumulate его все равно примерно в 2 раза быстрее:

 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 

Если вы поместите импорт за пределы двух функций и по-прежнему возвращаете array numpy , accumulate все равно почти в 2 раза быстрее:

 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 

Во-первых, вам нужен бегущий список подпоследовательностей:

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

Затем вы просто называете sum по каждой подпоследовательности:

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

(Это не самый эффективный способ сделать это, потому что вы добавляете все префиксы несколько раз. Но это, вероятно, не имеет значения для большинства случаев использования, и это легче понять, если вам не нужно думать о текущие итоги.)

Если вы используете Python 3.2 или новее, вы можете использовать itertools.accumulate чтобы сделать это за вас:

 sums = itertools.accumulate(seq) 

И если вы используете 3.1 или более раннюю версию, вы можете просто скопировать источник «эквивалент» прямо из документов (за исключением изменения next(it) на it.next() для 2.5 и более ранних it.next() ).

 values = [4, 6, 12] total = 0 sums = [] for v in values: total = total + v sums.append(total) print 'Values: ', values print 'Sums: ', sums 

Выполнение этого кода дает

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

Попробуй это:

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

 lst = [4,6,12] [sum(lst[:i+1]) for i in xrange(len(lst))] 

Если вы ищете более эффективное решение (более крупные списки?), Генератор может быть хорошим звонком (или просто использовать numpy если вы действительно заботитесь о перфомансе).

 def gen(lst): acu = 0 for num in lst: yield num + acu acu += num print list(gen([4, 6, 12])) 

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

Это слабее быстрее, чем метод генератора, описанный @Ashwini для небольших списков

 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 

Для больших списков генератор – это путь к уверенности. , ,

 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 

Немного взломанный, но, похоже, работает:

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

Я думал, что внутренняя функция сможет модифицировать y объявленную во внешней лексической области, но это не сработало, поэтому вместо этого мы играем с некоторыми неприятными хаками с модификацией структуры. Возможно, более изящно использовать генератор.

Без необходимости использовать Numpy, вы можете напрямую перебирать массив и накапливать сумму на этом пути. Например:

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

Результаты в:

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

 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 

Это будет стиль Haskell:

 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]) 

Проверьте встроенную функцию sum (), она, вероятно, делает то, что вы хотите.