किसी सूची में संख्याओं का संचयी योग कैसे ज्ञात करें?

Question 1

time_interval = [4, 6, 12]

मैं [4, 4+6, 4+6+12]सूची प्राप्त करने के लिए संख्याओं को समेटना चाहता हूं t = [4, 10, 22]।

मैंने निम्नलिखित कोशिश की:

t1 = time_interval[0]
t2 = time_interval[1] + t1
t3 = time_interval[2] + t2
print(t1, t2, t3)  # -> 4 10 22

Question 2

यदि आप इस तरह के सरणियों के साथ बहुत अधिक संख्यात्मक कार्य कर रहे हैं, तो मेरा सुझाव है numpy, जो एक संचयी योग फ़ंक्शन के साथ आता है cumsum:

import numpy as np

a = [4,6,12]

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

इस तरह की चीज़ों के लिए नम्पी अक्सर शुद्ध अजगर से अधिक तेज़ होता है, @ अश्विनी की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

लेकिन निश्चित रूप से अगर यह एकमात्र जगह है जिसका आप उपयोग करेंगे, तो यह उस पर निर्भरता के लायक नहीं हो सकता है।

Question 3

अजगर 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]

और पायथन 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]

Question 4

देखो:

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

आउटपुट होगा (उम्मीद के मुताबिक):

[4, 10, 22]

Question 5

मैंने पायथन 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

Question 6

इसे आज़माएं: फंक्शन को संचित करें, साथ में ऑपरेटर ऐड रनिंग एडिशन करता है।

import itertools  
import operator  
result = itertools.accumulate([1,2,3,4,5], operator.add)  
list(result)

Question 7

PEP 572 (पायथन 3.8 में नया) से असाइनमेंट अभिव्यक्तियाँ इसे हल करने का एक और तरीका प्रदान करती हैं:

time_interval = [4, 6, 12]

total_time = 0
cum_time = [total_time := total_time + t for t in time_interval]

Question 8

आप एक साधारण 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]

Question 9

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]

Question 10

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]

Question 11

यदि आप 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, sys
L=list(range(10000))
if sys.version_info >= (3, 0):
    reduce = functools.reduce
    xrange = range


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

Question 12

सूची की लंबाई और प्रदर्शन के आधार पर इसके लिए कई उत्तर हो सकते हैं। एक बहुत ही सरल तरीका जिसे मैं प्रदर्शन के बारे में सोचे बिना सोच सकता हूं वह यह है:

a = [1, 2, 3, 4]
a = [sum(a[0:x:1]) for x in range(len(a)+1)][1:]
print(a)

[1, 3, 6, 10]

यह सूची समझ का उपयोग करके है और यह काफी अच्छी तरह से काम कर सकता है यह सिर्फ यह है कि यहां मैं कई बार सबर्रे को जोड़ रहा हूं, आप संभवतः इस पर सुधार कर सकते हैं और इसे सरल बना सकते हैं!

अपने प्रयास को चीयर्स!

Question 13

सबसे पहले, आप बाद की दौड़ की सूची चाहते हैं:

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

फिर आप sumप्रत्येक बाद में फोन करते हैं:

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

(ऐसा करने का यह सबसे कारगर तरीका नहीं है, क्योंकि आप सभी उपसर्गों को बार-बार जोड़ रहे हैं। लेकिन यह कि ज्यादातर उपयोग के मामलों के लिए कोई फर्क नहीं पड़ेगा, और यह समझना आसान है कि क्या आपको सोचना नहीं है। चल रहे योग।)

यदि आप पायथन 3.2 या नए का उपयोग कर रहे हैं, तो आप इसे आपके लिए itertools.accumulateकरने के लिए उपयोग कर सकते हैं :

sums = itertools.accumulate(seq)

और यदि आप 3.1 या इससे पहले का उपयोग कर रहे हैं, तो आप केवल डॉक्स से सीधे "बराबर" स्रोत को कॉपी कर सकते हैं (केवल 2.5 और पूर्व के लिए बदलने next(it)के it.next()लिए छोड़कर )।

Question 14

इसे इस्तेमाल करे:

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

Question 15

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

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

ये है slighlty छोटे सूचियों के लिए @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

Question 16

थोड़े हॅसी, लेकिन काम करने लगता है:

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

मैंने सोचा था कि आंतरिक फ़ंक्शन yबाहरी लेक्सिकल दायरे में घोषित को संशोधित करने में सक्षम होगा , लेकिन यह काम नहीं किया, इसलिए हम संरचना संशोधन के साथ कुछ बुरा हैक खेलते हैं। जनरेटर का उपयोग करना संभवतः अधिक सुरुचिपूर्ण है।

Question 17

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]

Question 18

संचयी राशि के लिए एक शुद्ध अजगर 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([])
#[]

और संचयी उत्पाद के लिए simular:

cumprod = lambda X: X[:1] + cumprod([X[0]*X[1]] + X[2:]) if X[1:] else X

परीक्षा:

cumprod([4,6,12])
#[4, 24, 288]

Question 19

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

Question 20

यहाँ एक और मजेदार उपाय है। यह locals()एक समझ के हुक्म का लाभ उठाता है , यानी सूची समझ के दायरे में उत्पन्न स्थानीय चर:

>>> [locals().setdefault(i, (elem + locals().get(i-1, 0))) for i, elem 
     in enumerate(time_interval)]
[4, 10, 22]

यहाँ locals()प्रत्येक पुनरावृत्ति के लिए लग रहा है:

>>> [[locals().setdefault(i, (elem + locals().get(i-1, 0))), locals().copy()][1] 
     for i, elem in enumerate(time_interval)]
[{'.0': <enumerate at 0x21f21f7fc80>, 'i': 0, 'elem': 4, 0: 4},
 {'.0': <enumerate at 0x21f21f7fc80>, 'i': 1, 'elem': 6, 0: 4, 1: 10},
 {'.0': <enumerate at 0x21f21f7fc80>, 'i': 2, 'elem': 12, 0: 4, 1: 10, 2: 22}]

प्रदर्शन छोटी सूचियों के लिए भयानक नहीं है:

>>> %timeit list(accumulate([4, 6, 12]))
387 ns ± 7.53 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

>>> %timeit np.cumsum([4, 6, 12])
5.31 µs ± 67.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

>>> %timeit [locals().setdefault(i, (e + locals().get(i-1,0))) for i,e in enumerate(time_interval)]
1.57 µs ± 12 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

और स्पष्ट रूप से बड़ी सूची के लिए सपाट हो जाता है।

>>> l = list(range(1_000_000))
>>> %timeit list(accumulate(l))
95.1 ms ± 5.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

>>> %timeit np.cumsum(l)
79.3 ms ± 1.07 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

>>> %timeit np.cumsum(l).tolist()
120 ms ± 1.23 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

>>> %timeit [locals().setdefault(i, (e + locals().get(i-1, 0))) for i, e in enumerate(l)]
660 ms ± 5.14 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

भले ही यह तरीका बदसूरत है और व्यावहारिक नहीं है, यह सुनिश्चित है कि यह मजेदार है।

Question 21

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

Question 22

यह हास्केल-शैली होगी:

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