Подтвердить что ты не робот

Элегантная питоническая кумса

Что будет изящным и путинским способом реализации cumsum?
Альтернативно - если есть уже встроенный способ сделать это, это было бы даже лучше, конечно...

4b9b3361

ОТВЕТЫ

Ответ 1

Он доступен в Numpy:

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

Или используйте itertools.accumulate, поскольку Python 3.2:

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

Если Numpy не является опцией, цикл генератора будет самым элегантным решением, о котором я могу думать:

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

Исх.

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

Ответ 2

Моя идея заключалась в том, чтобы использовать сокращение в функциональном режиме:

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 из операторского модуля обладает уникальным свойством делать добавление на месте и возвращать цель в результате.

Если эта копия [1:] заставит вас съежиться, вы также можете сделать:

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]

Но я обнаружил, что локально первый пример намного быстрее, и генераторы IMO более пифоничны, чем функциональные, такие как "уменьшить":

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

Здесь контрольный показатель script, YMMV:

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)

И вот моя строка версии Python:

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

Ответ 3

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]

Ответ 4

на месте:

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

Ответ 5

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

cumsum([1,2,3])

> [1, 3, 6]

Ответ 6

для циклов питонов

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

Ответ 7

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

Ответ 8

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

Ответ 9

Я обновил ответ @GrantJ и рассчитал все с Python 3 в Jupyter. Я добавил в следующем простом примере accumulate:

def cumsum_acc(iterable):
    return accumulate(iterable)

Время показывает, что этот подход является самым быстрым:

reduce(lambda acc, itm: (iadd(acc[0], [acc[1] + itm]), acc[1] + itm), values_ten, ([], 0))[0]
Average: 4.18553415873987e-06
reduce(lambda acc, itm: (iadd(acc[0], [acc[1] + itm]), acc[1] + itm), values_mil, ([], 0))[0]
Average: 0.4559302114011018
reduce(lambda acc, itm: iadd(acc, [acc[-1] + itm]), values_ten, [0])[1:]
Average: 3.3726942356950078e-06
reduce(lambda acc, itm: iadd(acc, [acc[-1] + itm]), values_mil, [0])[1:]
Average: 0.4217967894903154
cumsum_rking(values_ten)
Average: 2.2734952410773416e-06
cumsum_rking(values_mil)
Average: 0.24106813411868303
list(cumsum_larsmans(values_ten))
Average: 1.5819200433296032e-06
list(cumsum_larsmans(values_mil))
Average: 0.17061943569953542
list(cumsum_acc(values_ten))
Average: 9.456979988264607e-07
list(cumsum_acc(values_mil))
Average: 0.11057746014014924

Код за ним (GrantJ, модифицированный для Python 3):

from timeit import timeit
from itertools import accumulate
from functools import reduce

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

values_ten = list(range(10))
values_mil = list(range(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, reduce, 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, reduce, values_mil', number=10)

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

def cumsum_rking(iterable):
    values = list(iterable)
    for pos in range(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)

def cumsum_acc(iterable):
    return accumulate(iterable)

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

Ответ 10

Начиная с Python 3.8 и введением выражений присваивания (PEP 572) (:= оператор), мы можем использовать и увеличивать переменную в пределах понимания списка:

total = 0
[total := total + x for x in [1, 2, 3 ,4, 5]]
# [1, 3, 6, 10, 15]

Это:

  • Инициализирует переменную total до 0 которая символизирует совокупную сумму
  • Для каждого элемента это оба:
    • увеличивает total с текущим зацикленным элементом (total := total + x) через выражение присваивания
    • и в то же время сопоставьте x с новым значением total