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

time_interval = [4, 6, 12] 

Я хочу подвести цифры, такие как [4, 4+6, 4+6+12] , чтобы получить список t = [4, 10, 22] .

Я попробовал следующее:

 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 

    Если вы много работаете с такими массивами, я предлагаю 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 (), она, вероятно, делает то, что вы хотите.