कार्यात्मक प्रोग्रामिंग से 'फोल्ड' फ़ंक्शन के समतुल्य 'पायथनिक' क्या है?

Question

क्या निम्नलिखित की तरह कुछ, हास्केल में प्राप्त करने के लिए सबसे मुहावरेदार तरीका है:

foldl (+) 0 [1,2,3,4,5] 
--> 15 

या रूबी में उसके बराबर:

[1,2,3,4,5].inject(0) {|m,x| m + x} 
#> 15 

जाहिर है, अजगर reduce समारोह प्रदान करता है, एक कार्यान्वयन है जो ठीक है, ठीक है, हालांकि, मुझे बताया गया था कि प्रोग्रामिंग का 'पायथनिक' तरीका lambda नियमों और उच्च-आदेश कार्यों से बचने के लिए था, जहां संभव हो वहां सूची-समझों को पसंद करना था। इसलिए, क्या एक सूची को फोल्ड करने का एक पसंदीदा तरीका है, या पायथन में सूची जैसी संरचना है जो reduce फ़ंक्शन नहीं है, या reduce यह प्राप्त करने का मूर्ख तरीका है?

Answer 1

एक सरणी को जोड़ने का पाइथोनिक तरीका sum है। अन्य उद्देश्यों के लिए, आप कभी-कभी reduce और operator मॉड्यूल के कुछ संयोजन का उपयोग कर सकते हैं, उदा।

def product(xs): 
    return reduce(operator.mul, xs, 1) 

जानते हैं कि वास्तव में एक reducefoldl है, हास्केल मामले में रहें। फ़ोल्ड करने के लिए कोई विशेष वाक्यविन्यास नहीं है, कोई निर्मित foldr नहीं है, और वास्तव में reduce का उपयोग गैर-सहयोगी ऑपरेटरों को खराब शैली माना जाता है।

उच्च-आदेश कार्यों का उपयोग करना काफी पाइथनिक है; यह पायथन के सिद्धांत का अच्छा उपयोग करता है कि सबकुछ एक वस्तु है, जिसमें कार्य और कक्षाएं शामिल हैं। आप सही हैं कि कुछ पाइथोनिस्टस द्वारा लैम्ब्डा फेंकते हैं, लेकिन अधिकतर क्योंकि वे जटिल होने पर बहुत पठनीय नहीं होते हैं।

Answer 2

इस (कम) समस्या का वास्तविक उत्तर है: बस एक लूप का उपयोग करें!

initial_value = 0 
for x in the_list: 
    initial_value += x #or any function. 

यह तुलना में तेजी से हो जाएगा एक कम करने और PyPy तरह बातें उस तरह छोरों अनुकूलन कर सकते हैं।

Btw, योग मामले sum समारोह

Answer 3

के साथ हल किया जाना चाहिए साथ ही आप पहिया बदलने कर सकते हैं:

def fold(f, l, a): 
    """ 
    f: the function to apply 
    l: the list to fold 
    a: the accumulator, who is also the 'zero' on the first call 
    """ 
    return a if(len(l) == 0) else fold(f, l[1:], f(a, l[0])) 

print "Sum:", fold(lambda x, y : x+y, [1,2,3,4,5], 0) 

print "Any:", fold(lambda x, y : x or y, [False, True, False], False) 

print "All:", fold(lambda x, y : x and y, [False, True, False], True) 

# Prove that result can be of a different type of the list's elements 
print "Count(x==True):", 
print fold(lambda x, y : x+1 if(y) else x, [False, True, True], 0) 

Answer 4

हास्केल

foldl (+) 0 [1,2,3,4,5]

अजगर

reduce(lambda a,b: a+b, [1,2,3,4,5], 0)

जाहिर है, यह एक बिंदु को चित्रित करने के लिए एक मामूली उदाहरण है। पायथन में आप केवल sum([1,2,3,4,5]) करेंगे और यहां तक ​​कि हास्केल purists भी आमतौर पर sum [1,2,3,4,5] पसंद करेंगे।

गैर तुच्छ परिदृश्यों के लिए जब कोई स्पष्ट सुविधा समारोह है वहाँ, मुहावरेदार pythonic दृष्टिकोण स्पष्ट रूप से पाश के लिए बाहर लिख सकते हैं और बजाय reduce या एक fold का उपयोग करने का परिवर्तनशील चर काम का प्रयोग है।

यह सभी कार्यात्मक शैली में नहीं है, लेकिन यह "पायथनिक" तरीका है। पाइथन कार्यात्मक शुद्धवादियों के लिए डिज़ाइन नहीं किया गया है। देखें कि कैसे पाइथन प्रवाह नियंत्रण के लिए अपवादों का पक्ष लेता है यह देखने के लिए कि गैर-कार्यात्मक मुहावरेदार पायथन कैसा है।

Answer 5

नहीं वास्तव में सवाल का जवाब है, लेकिन foldl और foldr के लिए एक लाइनर्स:

a = [8,3,4] 

## Foldl 
reduce(lambda x,y: x**y, a) 
#68719476736 

## Foldr 
reduce(lambda x,y: y**x, a[::-1]) 
#14134776518227074636666380005943348126619871175004951664972849610340958208L 

Answer 6

अजगर 3 में, reduce हटा दिया गया है: Release notes। फिर भी आप functools module

import operator, functools 
def product(xs): 
    return functools.reduce(operator.mul, xs, 1) 

उपयोग कर सकते हैं दूसरी ओर, प्रलेखन reduce के बजाय for -loop की ओर वरीयता व्यक्त करता है, इसलिए:

def product(xs): 
    result = 1 
    for i in xs: 
     result *= i 
    return result