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, который поставляется с функцией суммарной суммы cumsum:
import numpy as np
a = [4,6,12]
np.cumsum(a)
#array([4, 10, 22])
Ненусы часто быстрее, чем чистый питон для такого рода вещей, см. в @Ashwini 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
Если numpy array не отбрасывается до 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
Если вы помещаете импорт за пределы двух функций и все еще возвращаете numpy array, 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 и более ранних версий).
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]
Если вы хотите использовать pythonic без numpy, работая в 2.7, это будет мой способ сделать это
l = [1,2,3,4]
_d={-1:0}
cumsum=[_d.setdefault(idx, _d[idx-1]+item) for idx,item in enumerate(l)]
теперь попробуйте и протестируйте его против всех других реализаций
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
Выражения присваивания из PEP 572 (ожидаемые для Python 3.8) предлагают еще один способ решить эту проблему:
time_interval = [4, 6, 12]
total_time = 0
cum_time = [total_time := total_time + t for t in time_interval]
Попробуйте это: функция накопления вместе с оператором add выполняет текущее сложение.
import itertools
import operator
result = itertools.accumulate([1,2,3,4,5], operator.add)
list(result)
Попробуйте следующее:
result = []
acc = 0
for i in time_interval:
acc += i
result.append(acc)
Вы можете рассчитать список накопленных сумм за линейное время с помощью простого цикла for:
def csum(lst):
s = lst.copy()
for i in range(1, len(s)):
s[i] += s[i-1]
return s
time_interval = [4, 6, 12]
print(csum(time_interval)) # [4, 10, 22]
Стандартная библиотека itertools.accumulate может быть более быстрой альтернативой (поскольку она реализована в C):
from itertools import accumulate
time_interval = [4, 6, 12]
print(list(accumulate(time_interval))) # [4, 10, 22]
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
Чистый python oneliner для суммарной суммы:
cumsum = lambda X: X[:1] + cumsum([X[0]+X[1]] + X[2:]) if X[1:] else X
Это рекурсивная версия, основанная на рекурсивных суммарных суммах. Некоторые объяснения:
X[:1] - это список, содержащий предыдущий элемент и почти такой же, как [X[0]] (который будет жаловаться на пустые списки).cumsum во втором члене обрабатывает текущий элемент [1] и оставшийся список, длина которого будет уменьшена на единицу.if X[1:] короче, if len(X)>1.Контрольная работа:
cumsum([4,6,12])
#[4, 10, 22]
cumsum([])
#[]
И имитирует совокупный продукт:
cumprod = lambda X: X[:1] + cumprod([X[0]*X[1]] + X[2:]) if X[1:] else X
Контрольная работа:
cumprod([4,6,12])
#[4, 24, 288]
l = [1,-1,3]
cum_list = l
def sum_list(input_list):
index = 1
for i in input_list[1:]:
cum_list[index] = i + input_list[index-1]
index = index + 1
return cum_list
print(sum_list(l))
В Python3, чтобы найти совокупную сумму списка, где i -й элемент
сумма первых элементов i + 1 из исходного списка, вы можете сделать:
a = [4 , 6 , 12]
b = []
for i in range(0,len(a)):
b.append(sum(a[:i+1]))
print(b)
ИЛИ вы можете использовать понимание списка:
b = [sum(a[:x+1]) for x in range(0,len(a))]
Выход
[4,10,22]
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]))
Это будет стиль 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(), она, вероятно, делает то, что вы хотите.