असामान्य अजगर कार्यात्मक प्रोग्रामिंग

प्रोग्रामिंग लैंग्वेज कोर्स देखने और फंक्शनल जावास्क्रिप्ट पढ़ने के बाद , मैं अजगर में इन सभी शांत चीजों को दोहराना चाहता था। कुछ चीजें सुंदर और आसानी से की जाने लगीं, बाकी चीजें डरावनी और बेकार हो गईं।

लेख में शामिल हैं:

• कुछ समझ से बाहर शब्द;
• currying;
• पैटर्न मिलान;
• पुनरावर्तन (पूंछ सहित)।

लेख को अजगर 3.3+ के लिए डिज़ाइन किया गया है।

कुछ भ्रामक शब्द

आप एक कार्यात्मक शैली में अजगर में लिख सकते हैं, क्योंकि इसके अनाम कार्य हैं:

sum_x_y = lambda x, y: x + y print(sum_x_y(1, 2)) # 3 

उच्च-क्रम के कार्य (अन्य कार्यों को स्वीकार करना या वापस करना):

 def call_and_twice(fnc, x, y): return fnc(x, y) * 2 print(call_and_twice(sum_x_y, 3, 4)) # 14 

शॉर्ट सर्किट:

 def closure_sum(x): fnc = lambda y: x + y return fnc sum_with_3 = closure_sum(3) print(sum_with_3(12)) # 15 

टपल अनपैकिंग (लगभग पैटर्न मिलान):

 a, b, c = [1, 2, 3] print(a, b, c) # 1 2 3 hd, *tl = range(5) print(hd, 'tl:', *tl) # 0 tl: 1 2 3 4 

और कूल मॉड्यूल कन्फ़िगरेशन और इटर्टूल ।

currying

एक फ़ंक्शन को कई तर्कों से एक फ़ंक्शन में परिवर्तित करना जो एक समय में अपने तर्कों को लेता है।

सरलतम मामले पर विचार करें, sum_x_y फ़ंक्शन को करें:

 sum_x_y_carry = lambda x: lambda y: sum_x_y(x, y) print(sum_x_y_carry(5)(12)) # 17 

कुछ शांत नहीं है, यह कोशिश करो:

 sum_with_12 = sum_x_y_carry(12) print(sum_with_12(1), sum_with_12(12)) # 13 24 sum_with_5 = sum_x_y_carry(5) print(sum_with_5(10), sum_with_5(17)) # 15 22 

पहले से ही अधिक दिलचस्प है, अब हम दो तर्कों के साथ करी कार्यों के लिए एक सार्वभौमिक कार्य करेंगे, क्योंकि हर बार lambda x: lambda y: zzzz लिखते हुए शांत नहीं होता है:

 curry_2 = lambda fn: lambda x: lambda y: fn(x, y) 

और इसे वास्तविक परियोजनाओं में उपयोग किए जाने वाले map फ़ंक्शन पर लागू map :

 curry_map_2 = curry_2(map) @curry_map_2 def twice_or_increase(n): if n % 2 == 0: n += 1 if n % 3: n *= 2 return n print(*twice_or_increase(range(10))) # 2 2 3 3 10 10 14 14 9 9 print(*twice_or_increase(range(30))) # 2 2 3 3 10 10 14 14 9 9 22 22 26 26 15 15 34 34 38... 

हां, हां, मैंने डेकोरेटर के रूप में एक घुमावदार map उपयोग किया था और मल्टी-लाइन लैम्ब्डा की कमी को ऑफसेट किया था।

लेकिन सभी फ़ंक्शंस में 2 तर्क नहीं होते हैं, इसलिए हम आंशिक , curry_n और थोड़ी सी पुनरावृत्ति का उपयोग करके curry_n फ़ंक्शन करेंगे:

 from functools import partial def curry_n(fn, n): def aux(x, n=None, args=None): #   args = args + [x] #       return partial(aux, n=n - 1, args=args) if n > 1 else fn(*args) #     ,   aux       return partial(aux, n=n, args=[]) 

और एक बार फिर, map लागू होते हैं, लेकिन 3 तर्क के साथ:

 curry_3_map = curry_n(map, 3) 

और हम सूची आइटम 1.10 आइटम सूची में जोड़ने के लिए एक कार्य करेंगे:

 sum_arrays = curry_3_map(lambda x, y: x + y) sum_with_range_10 = sum_arrays(range(10)) print(*sum_with_range_10(range(100, 0, -10))) # 100 91 82 73 64 55 46 37 28 19 print(*sum_with_range_10(range(10))) # 0 2 4 6 8 10 12 14 16 18 

चूँकि curry_2 का एक विशेष मामला है, आप यह कर सकते हैं:

 curry_2 = partial(curry_n, n=2) 

और उदाहरण के लिए, इसे filter करने के लिए लागू करें:

 curry_filter = curry_2(filter) only_odd = curry_filter(lambda n: n % 2) print(*only_odd(range(10))) # 1 3 5 7 9 print(*only_odd(range(-10, 0, 1))) # -9 -7 -5 -3 -1 

पैटर्न मिलान

निर्दिष्ट नमूनों की उपस्थिति के लिए सूचियों या अन्य डेटा संरचनाओं का विश्लेषण करने के लिए एक विधि।

पैटर्न मिलान जो मुझे sml में सबसे अधिक पसंद है और अजगर में सबसे खराब है।
हम एक लक्ष्य के साथ आएंगे - एक फ़ंक्शन लिखने के लिए:

• यदि यह संख्याओं की सूची स्वीकार करता है, तो उनके उत्पाद लौटाता है;
• यदि यह स्ट्रिंग्स की एक सूची को स्वीकार करता है, तो एक बड़ा संघनित स्ट्रिंग लौटाता है।

आइए इसके "फेंक" के लिए एक सहायक अपवाद और एक फ़ंक्शन बनाएं, जिसका उपयोग हम तब करेंगे जब तुलना पास नहीं होगी:

 class NotMatch(Exception): """Not match""" def not_match(x): raise NotMatch(x) 

और एक फ़ंक्शन जो एक चेक करता है और एक ऑब्जेक्ट लौटाता है, या एक अपवाद फेंकता है:

 match = lambda check, obj: obj if check(obj) else not_match(obj) match_curry = curry_n(match, 2) 

अब हम एक प्रकार की जाँच बना सकते हैं:

 instance_of = lambda type_: match_curry(lambda obj: isinstance(obj, type_)) 

तो int :

 is_int = instance_of(int) print(is_int(2)) # 2 try: is_int('str') except NotMatch: print('not int') # not int 

सूची के लिए एक प्रकार की जाँच बनाएँ, प्रत्येक तत्व की जाँच:

 is_array_of = lambda matcher: match_curry(lambda obj: all(map(matcher, obj))) 

और फिर int :

 is_array_of_int = is_array_of(is_int) print(is_array_of_int([1, 2, 3])) # 1 2 3 try: is_array_of_int('str') except NotMatch: print('not int') # not int 

और अब इसी तरह str :

 is_str = instance_of(str) is_array_of_str = is_array_of(is_str) 

हम एक फ़ंक्शन भी जोड़ते हैं जो अपना तर्क देता है, idempotent =)

 identity = lambda x: x print(identity(10)) # 10 print(identity(20)) # 20 

और एक खाली सूची की जाँच करें:

 is_blank = match_curry(lambda xs: len(xs) == 0) print(is_blank([])) # [] try: is_blank([1, 2, 3]) except NotMatch: print('not blank') # not blank 

अब हम सूची को पहले तत्व में और शेष को "चेक" के उपयोग से विभाजित करने के लिए एक फंक्शन बनाएंगे:

 def hd_tl(match_x, match_xs, arr): x, *xs = arr return match_x(x), match_xs(xs) hd_tl_partial = lambda match_x, match_xs: partial(hd_tl, match_x, match_xs) 

और identity साथ सबसे सरल उदाहरण पर विचार करें:

 hd_tl_identity = hd_tl_partial(identity, identity) print(hd_tl_identity(range(5))) # 0 [1, 2, 3, 4] 

और अब संख्याओं के साथ:

 hd_tl_ints = hd_tl_partial(is_int, is_array_of_int) print(hd_tl_ints(range(2, 6))) # 2 [3, 4, 5] try: hd_tl_ints(['str', 1, 2]) except NotMatch: print('not ints') # not ints 

और अब फ़ंक्शन ही, जो सभी चेक पर पुनरावृति करेगा। वह बहुत सरल है:

 def pattern_match(patterns, args): for pattern, fnc in patterns: try: return fnc(pattern(args)) except NotMatch: continue raise NotMatch(args) pattern_match_curry = curry_n(pattern_match, 2) 

लेकिन फिर इसका उपयोग करना असुविधाजनक है और इसके लिए कोष्ठक की एक पूरी दुनिया की आवश्यकता है, उदाहरण के लिए, हमें जिस फ़ंक्शन की आवश्यकता है वह इस तरह दिखाई देगा:

 sum_or_multiply = pattern_match_curry(( (hd_tl_partial(identity, is_blank), lambda arr: arr[0]), # x::[] -> x (hd_tl_ints, lambda arr: arr[0] * sum_or_multiply(arr[1])), # x::xs -> x * sum_or_multiply (xs)  type(x) == int (hd_tl_partial(is_str, is_array_of_str), lambda arr: arr[0] + sum_or_multiply(arr[1])), # x::xs -> x + sum_or_multiply (xs)  type(x) == str )) 

अब इसे कार्रवाई में देखें:

 print(sum_or_multiply(range(1, 10))) # 362880 print(sum_or_multiply(['a', 'b', 'c'])) # abc 

हुर्रे! यह काम करता है =)

प्रत्यावर्तन

सभी शांत प्रोग्रामिंग भाषाओं में, कठिन लोग पुनरावृत्ति के माध्यम से map को लागू करते हैं, हम बदतर क्यों हैं? इसके अलावा, हम पहले से ही जानते हैं कि कैसे मिलान पैटर्न:

 r_map = lambda fn, arg: pattern_match(( (hd_tl_partial(identity, is_blank), lambda arr: [fn(arr[0])]), # x::[] -> fn(x) ( hd_tl_partial(identity, identity), lambda arr: [fn(arr[0])] + r_map(fn, arr[1]) # x::xs -> fn(x)::r_map(fn, xs) ), ), arg) print(r_map(lambda x: x**2, range(10))) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

अब करी:

 r_map_curry = curry_n(r_map, 2) twice = r_map_curry(lambda x: x * 2) print(twice(range(10))) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] try: print(twice(range(1000))) except RuntimeError as e: print(e) # maximum recursion depth exceeded in comparison 

कुछ गलत हो गया था, पूंछ पुनरावृत्ति की कोशिश करो।
ऐसा करने के लिए, None पर "चेक" बनाएं:

 is_none = match_curry(lambda obj: obj is None) 

और एक जोड़े की जाँच करें:

 pair = lambda match_x, match_y: lambda arr: (match_x(arr[0]), match_y(arr[1])) 

और अब खुद map :

 def r_map_tail(fn, arg): aux = lambda arg: pattern_match(( (pair(identity, is_none), lambda arr: aux([arr[0], []])), #   None,   [] ( pair(hd_tl_partial(identity, is_blank), identity), lambda arr: arr[1] + [fn(arr[0][0])] #  (x::[], acc),     fn(x)    ), ( pair(hd_tl_partial(identity, identity), identity), lambda arr: aux([arr[0][1], arr[1] + [fn(arr[0][0])]]) #  (x::xs, acc),      xs   + fn(x) ), ), arg) return aux([arg, None]) 

अब हमारे चमत्कार की कोशिश करो:

 r_map_tail_curry = curry_n(r_map_tail, 2) twice_tail = r_map_tail_curry(lambda x: x * 2) print(twice_tail(range(10))) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] try: print(twice_tail(range(10000))) except RuntimeError as e: print(e) # maximum recursion depth exceeded 

यह दुर्भाग्य है - अजगर पूंछ पुनरावृत्ति का अनुकूलन नहीं करता है। लेकिन अब बैसाखी हमारी सहायता के लिए आएगी:

 def tail_fnc(fn): called = False calls = [] def run(): while len(calls): #       res = fn(*calls.pop()) return res def call(*args): nonlocal called calls.append(args) #     if not called: #    ,   -   called = True return run() return call 

अब हम इस map लागू करते हैं:

 def r_map_really_tail(fn, arg): aux = tail_fnc(lambda arg: pattern_match(( #    (pair(identity, is_none), lambda arr: aux([arr[0], []])), #   None,   [] ( pair(hd_tl_partial(identity, is_blank), identity), lambda arr: arr[1] + [fn(arr[0][0])] #  (x::[], acc),     fn(x)    ), ( pair(hd_tl_partial(identity, identity), identity), lambda arr: aux([arr[0][1], arr[1] + [fn(arr[0][0])]]) #  (x::xs, acc),      xs   + fn(x) ), ), arg)) return aux([arg, None]) r_map_really_tail_curry = curry_n(r_map_really_tail, 2) twice_really_tail = r_map_really_tail_curry(lambda x: x * 2) print(twice_really_tail(range(1000))) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18... 

अब यह काम किया =)

इतना डरावना नहीं

यदि हम अपने भयानक पैटर्न मिलान के बारे में भूल जाते हैं, तो पुनरावर्ती map को काफी सटीक रूप से लागू किया जा सकता है:

 def tail_r_map(fn, arr_): @tail_fnc def aux(arr, acc=None): x, *xs = arr if xs: return aux(xs, acc + [fn(x)]) else: return acc + [fn(x)] return aux(arr_, []) curry_tail_r_map = curry_2(tail_r_map) 

और इसे सूची के सभी विषम संख्याओं को 2 से गुणा करें:

 @curry_tail_r_map def twice_if_odd(x): if x % 2 == 0: return x * 2 else: return x print(twice_if_odd(range(10000))) # [0, 1, 4, 3, 8, 5, 12, 7, 16, 9, 20, 11, 24, 13, 28, 15, 32, 17, 36, 19... 

यह धीरे-धीरे और अनावश्यक रूप से काफी साफ हो गया। कम से कम गति के कारण। विभिन्न map विकल्पों के प्रदर्शन की तुलना करें:

 from time import time checker = lambda x: x ** 2 + x limit = 10000 start = time() xs = [checker(x) for x in range(limit)][::-1] print('inline for:', time() - start) start = time() xs = list(map(checker, range(limit)))[::-1] print('map:', time() - start) calculate = curry_tail_r_map(checker) start = time() xs = calculate(range(limit))[::-1] print('r_map without pattern matching:', time() - start) calculate = r_map_really_tail_curry(checker) start = time() xs = calculate(range(limit))[::-1] print('r_map with pattern matching:', time() - start) 

जिसके बाद हमें मिलता है:
इनलाइन के लिए: 0.011110067367553711
नक्शा: 0.011012554168701172
पैटर्न मिलान के बिना r_map: 3.7527310848236084
पैटर्न मिलान के साथ r_map: 5.926968812942505
बिल्ट-इन मैप और सबसे तेज़ होने के लिए पैटर्न मिलान विकल्प सबसे धीमा निकला।

निष्कर्ष

इस लेख से, वास्तविक अनुप्रयोगों में, शायद केवल करी का उपयोग किया जा सकता है। बाकी या तो अपठनीय है या एक ब्रेक बाइक =)
सभी उदाहरण github पर उपलब्ध हैं।