कार्यात्मक प्रोग्रामिंग पर एक और लेख नहीं

अब कई वर्षों से, कार्यात्मक प्रोग्रामिंग लोकप्रियता प्राप्त कर रहा है। यह, ज़ाहिर है, इसका मतलब यह नहीं है कि लोग अपनी पुरानी भाषाओं और ओओपी को छोड़ देते हैं और हास्केल, लिस्प या एरलंग पर बड़े पैमाने पर स्विच करते हैं। नहीं। एक कार्यात्मक प्रतिमान बहु-प्रतिमान भाषाओं की खामियों के माध्यम से हमारे कोड में प्रवेश करता है, और उपर्युक्त भाषाएं अक्सर इस आक्रामक में झंडे के रूप में सेवा करती हैं, क्योंकि वे सीधे उपयोग किए जाते हैं।

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

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

मैं कई विशिष्ट कार्यों पर जाऊंगा, जो पाइथोनिक अभ्यास में पाए जाते हैं, और उनकी सरलता के बावजूद, निरंतर प्रश्न उठाते हैं। तो चलिए चलते हैं।

सरल डेटा हेरफेर

1. सूचियों की सूची को मिलाएं। परंपरागत रूप से, मैंने इसे इस तरह किया:

from operator import concat reduce(concat, list_of_lists) #  : sum(list_of_lists, []) #  : from itertools import chain list(chain.from_iterable(list_of_lists)) 

उनमें से सभी खराब नहीं हैं, लेकिन उन्हें या तो अतिरिक्त इशारों की आवश्यकता होती है: आयात और अतिरिक्त कॉल, या प्रतिबंध लगाते हैं: केवल सूचियों के साथ सूचियों और ट्यूपल्स के साथ tuples को जोड़ा जा सकता है, राशि के लिए आपको अभी भी अग्रिम में जानना होगा कि कौन सा प्रकार आएगा। अंत्येष्टि में, यह इस तरह किया जाता है:

 from funcy import cat cat(list_of_lists) 

cat() सूचियों, टुपल्स, पुनरावृत्तियों की एक सूची को जोड़ती है, और वास्तव में किसी भी एक सूची में पुनरावृत्त। यदि आपको फ़ंक्शन कॉल की परिणाम सूचियों को संयोजित करने की आवश्यकता है, तो आप उदाहरण के लिए, mapcat() उपयोग कर सकते हैं:

 from funcy import mapcat mapcat(str.splitlines, bunch_of_texts) 

एक फ्लैट सूची में ग्रंथों में सभी लाइनों को सॉर्ट करेगा। दोनों कार्यों के लिए आलसी संस्करण हैं: icat() और imapcat() ।

2. कई शब्दकोश जोड़ें। अजगर में शब्दकोशों को संयोजित करने के कई अजीब तरीके हैं:

 d1.update(d2) #  d1 dict(d1, **d2) #   > 2  d = d1.copy() d.update(d2) 

मैं हमेशा सोचता था कि वे सिर्फ मुड़े हुए क्यों नहीं हो सकते? लेकिन हमारे पास वही है जो हमारे पास है। किसी भी मामले में, यह आसानी से किया जाता है:

 from funcy import merge, join merge(d1, d2) merge(d1, d2, d3) join(sequence_of_dicts) 

लेकिन merge() और join() न केवल शब्दकोशों को जोड़ सकते हैं, वे लगभग किसी भी संग्रह के लिए काम करते हैं: शब्दकोश, शब्दकोश, सेट, सूचियां, ट्यूपल, पुनरावृत्त, और यहां तक ​​कि तार।

3. नियमित अभिव्यक्ति का उपयोग करके एक विकल्प कैप्चर करना। यह आमतौर पर इस तरह किया जाता है:

 m = re.search(some_re, s) if m: actual_match = m.group() #  m.group(i),  m.groups() ... 

मस्ती के साथ, यह में बदल जाता है:

 from funcy import re_find actual_match = re_find(some_re, s) 

यदि यह आपको बहुत प्रभावशाली नहीं लगता है, तो इस पर एक नज़र डालें:

 from funcy import re_finder, re_all, partial, mapcat #      map(re_finder('\d+'), words) #  ini  (re_finder()      > 1 ) dict(imap(re_finder('(\w+)=(\w+)'), ini.splitlines())) #     (    )      mapcat(partial(re_all, r'\d+'), bunch_of_strings) 

आयात और व्यावहारिकता के बारे में पाचन

जैसा कि आपने देखा होगा, मैं किसी भी उप-पैकेज का उपयोग किए बिना, फ़ंसी से सीधे फ़ंक्शन आयात करता हूं। इस तरह के इंटरफ़ेस पर मैंने जो कारण तय किया है वह व्यावहारिकता है; मेरे लाइब्रेरी के सभी उपयोगकर्ताओं को यह याद रखने के लिए उबाऊ होना उबाऊ होगा कि वे फ़्रीसी.कोल्स या फ़ंसी.सेक से कहाँ आयात करें (यह याद रखें कि इसके अलावा, प्रत्येक फ़ाइल की शुरुआत में मल्टी-लाइन आयात होता है और मेरे बिना कोई सामान है।

इस समाधान का एक अतिरिक्त लाभ केवल लिखने की क्षमता है:

 from funcy import * 

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

कुछ और कार्यात्मक बातें

हमने उच्च-क्रम के कार्यों का उपयोग करने के कुछ उदाहरण पहले ही देख लिए हैं - re_finder() और partial() । यह जोड़ने योग्य है कि re_finder() फ़ंक्शन स्वयं एक आंशिक re_find() अनुप्रयोग है जो map() में उपयोग में आसानी के लिए बनाया गया है map() और इसी तरह। और स्वाभाविक रूप से, filter() साथ filter() यह re_tester() का उपयोग करने के लिए सुविधाजनक है:

 #      is_private = re_tester('^_') filter(is_private, dir(some_obj)) 

महान, हम कुछ विधेयकों को सेट कर सकते हैं, जैसे कि is_private() , और उनके द्वारा ऑब्जेक्ट की विशेषताओं को फ़िल्टर करें:

 is_special = re_tester('^__.+__$') is_const = re_tester('^[A-Z_]+$') filter(...) 

लेकिन, क्या होगा यदि हम सार्वजनिक विशेषताओं या निजी स्थिरांक की सूची प्राप्त करना चाहते हैं, कुछ जिसमें विधेय का संयोजन शामिल है? आसान:

 is_public = complement(is_private) is_private_const = all_fn(is_private, is_const) either_const_or_public = any_fn(is_const, is_public) 

सुविधा के लिए, एक फ़ंक्शन भी है जो filter() पूरक filter() :

 remove(is_private, ...) #  ,  filter(is_public) 

मुझे आशा है कि सभी ने अपनी कार्यात्मक भूख को बुझा दिया है, इसलिए यह कुछ कम सार पर आगे बढ़ने का समय है।

संग्रह के साथ काम करें

अनुक्रमों के साथ काम करने के लिए उपयोगिताओं के अलावा, जिनमें से कई का वर्णन मैंने यहां किया है, फ़ंसीकरण भी संग्रह के साथ काम करने में मदद करता है। आधार फ़ंक्शंस walk() और select() , जो map() और filter() , लेकिन संसाधित किए जा रहे संग्रह का प्रकार बनाए रखें:

 walk(inc, {1, 2, 3}) # -> {2, 3, 4} walk(inc, (1, 2, 3)) # -> (2, 3, 4) #        - swap = lambda (k, v): (v, k) walk(swap, {1: 10, 2: 20}) # -> {10: 1, 20: 2} select(even, {1, 2, 3, 10, 20}) # -> {2, 10, 20} select(lambda (k, v): k == v, {1: 1, 2: 3}) # -> {1: 1} 

फ़ंक्शंस की यह जोड़ी शब्दकोशों के साथ काम करने के लिए एक सेट द्वारा समर्थित है: walk_keys(), walk_values(), select_keys(), select_values() :

 #       select_keys(is_public, instance.__dict__) #      select_values(bool, some_dict) 

इस श्रृंखला में अंतिम उदाहरण एक बार में कई नए कार्यों का उपयोग करेगा: silent() - लिपटे फ़ंक्शन द्वारा फेंके गए सभी अपवादों को दबा देता है, None वापस None ; compact() - संग्रह से None मूल्य None निकालता है; walk_values() - पारित शब्दकोश के मूल्यों को walk_values() करते हैं, पारित फ़ंक्शन द्वारा परिवर्तित मूल्यों के साथ एक नया शब्दकोश का निर्माण करते हैं। सामान्य तौर पर, यह रेखा क्वेरी मापदंडों से पूर्णांक मापदंडों के शब्दकोश का चयन करती है:

 compact(walk_values(silent(int), request_dict)) 

डेटा हेरफेर

ओह! हमें सबसे दिलचस्प हिस्सा मिला। मैंने यहां कुछ उदाहरणों को केवल इसलिए शामिल किया क्योंकि वे मुझे अच्छे लगते हैं। हालांकि, ईमानदार होने के लिए, मैंने इसे ऊपर किया। अब हम बांटेंगे और समूह बनाएंगे:

 #   URL   absolute, relative = split(re_tester(r'^http://'), urls) #     group_by(lambda post: post.category, posts) 

नेस्टेड संरचनाओं में फ्लैट डेटा ले लीजिए:

 #       dict(partition(2, flat_list_of_pairs)) #     {id: (name, password) for id, name, password in partition(3, users)} # ,     assert all(prev + 1 == next for prev, next in partition(2, 1, versions)): #    for chunk in chunks(CHUNK_SIZE, lots_of_data): process(chunk) 

और कुछ और उदाहरण, सिर्फ ढेर के लिए:

 #     for line, prev in with_prev(text.splitlines()): if not prev: print ' ', print line #     1611  where(plays, author="Shakespeare", year=1611) # => [{"title": "Cymbeline", "author": "Shakespeare", "year": 1611}, # {"title": "The Tempest", "author": "Shakespeare", "year": 1611}] 

सिर्फ एक पुस्तकालय नहीं है

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

और एक और सोचा। हमें प्रोग्रामिंग भाषाओं को कॉल करने के लिए उपयोग किया जाता है, लेकिन हम शायद ही कभी महसूस करते हैं कि वाक्य रचना और मानक कार्य इन भाषाओं के शब्द हैं। हम फ़ंक्शंस को परिभाषित करके अपने शब्दों को जोड़ सकते हैं, लेकिन आमतौर पर ऐसे शब्द रोजमर्रा की भाषा के शब्दकोश में आने के लिए बहुत विशिष्ट होते हैं। इसके विपरीत, अंत्येष्टि से उपयोगिताओं, आवेदनों की एक विस्तृत श्रृंखला के अनुरूप हैं, इसलिए इस पुस्तकालय को अजगर विस्तार, साथ ही अंडरस्कोर या jQuery - एक जावास्क्रिप्ट एक्सटेंशन के रूप में व्याख्या की जा सकती है। इसलिए, हर कोई जो अपनी शब्दावली को फिर से भरना चाहता है, उसका स्वागत है ।