🆑 🗽 🤶🏻 10 मिनट में पायथन में कार्यात्मक प्रोग्रामिंग सीखें 🛌🏼 😮 ⚕️

फोटो: क्रिस राइड

इस लेख में, आप समझेंगे कि एक कार्यात्मक प्रतिमान क्या है और पायथन में कार्यात्मक प्रोग्रामिंग का उपयोग कैसे करें। तुम भी सूची अमूर्त और अन्य सूची समझ के बारे में सीखना होगा।

क्रियात्मक प्रतिमान

एक अनिवार्य प्रतिमान में, आप बाद में किए गए कार्यों के अनुक्रम को निर्दिष्ट करके एक कार्यक्रम लिखते हैं। इस समय, राज्य ( लगभग। अनुवादक: चर, सरणियाँ, आदि ) बदल जाते हैं। उदाहरण के लिए, चर A को मान 5 संग्रहीत करें, बाद में आप इस चर के मान को बदलते हैं। आप चर का उपयोग करते हैं ताकि उनके मूल्य बदल जाएं।

एक कार्यात्मक प्रतिमान में, आप कंप्यूटर को यह नहीं बताते हैं कि क्या करना है, बल्कि कार्यों की प्रकृति को स्वयं निर्दिष्ट करें। एक संख्या का सबसे बड़ा सामान्य भाजक क्या है, 1 से n तक की गणनाओं का परिणाम, आदि।

इसलिए, चर नहीं बदलते हैं। एक बार एक चर शुरू कर दिए जाने के बाद, इसका मूल्य हमेशा के लिए सहेजा जाता है (ध्यान दें कि शुद्ध कार्यात्मक भाषाओं में इन्हें चर भी नहीं कहा जाता है)। इसलिए, कार्यात्मक प्रतिमान में, कार्यों का कोई दुष्प्रभाव नहीं होता है । एक पक्ष प्रभाव को उस क्षण के रूप में परिभाषित किया जा सकता है जिसके दौरान एक फ़ंक्शन अपनी सीमाओं से परे कुछ बदलता है। एक उदाहरण देखें:

a = 3 def some_func(): global a a = 5 some_func() print(a)

इस कोड के निष्पादन का परिणाम है 5. कार्यात्मक प्रोग्रामिंग में, चर बदलना मना है, और अपनी सीमाओं से परे किसी चीज़ के कार्यों को बदलना भी। सभी फ़ंक्शन कुछ गणना करने / प्रक्रिया करने और परिणाम वापस करने के लिए कर सकते हैं।

अब, आप सोच रहे होंगे: “कोई चर, कोई दुष्प्रभाव नहीं? क्यों अच्छा है? वाकई अच्छा सवाल है।

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

आमतौर पर, कार्यात्मक प्रोग्रामिंग में, लूप का उपयोग नहीं किया जाता है। पुनरावृत्ति का उपयोग किया जाता है। पुनरावृत्ति एक गणितीय अवधारणा है, वास्तव में, इसका अर्थ है "अपने आप को कुछ खिलाना।" एक पुनरावर्ती कार्य में, फ़ंक्शन स्वयं को एक उप-फ़ंक्शन की भूमिका कहता है। यहाँ पायथन में एक पुनरावर्ती कार्य का एक उदाहरण दिया गया है:

 def factorial_recursive(n): # Base case: 1! = 1 #   if n == 1: return 1 # Recursive case: n! = n * (n-1)! #    else: return n * factorial_recursive(n-1)

कुछ प्रोग्रामिंग लैंग्वेज आलसी हैं । इसका मतलब है कि वे अंतिम क्षण में सब कुछ गणना कर रहे हैं। मान लीजिए कि यदि कोड को 2 + 2 निष्पादित करना चाहिए, तो कार्यात्मक कार्यक्रम परिणाम की गणना केवल तभी करेगा जब परिणाम की आवश्यकता होगी। हम थोड़ी देर बाद अजगर के आलस्य के बारे में जानेंगे।

नक्शा

मानचित्र को समझने के लिए, आपको पहले चलने योग्य कंटेनरों से निपटना होगा। यह एक ऐसा कंटेनर है जिस पर आप "जा सकते हैं।" ये अक्सर सूची या सरणियाँ हैं, लेकिन पायथन में ऐसे कई कंटेनर हैं। तुम भी जादू के तरीकों को शुरू करके अपने खुद के कंटेनर बना सकते हैं। एपीआई की तरह ये तरीके, वस्तुओं को अधिक पायथोनिक बनने में मदद करते हैं। ऑब्जेक्ट को चलने योग्य बनाने के लिए 2 ऐसे तरीके हैं:

 class Counter: def __init__(self, low, high): # set class attributes inside the magic method __init__ # for "inistalise" #      self.current = low self.high = high def __iter__(self): # first magic method to make this object iterable #    return self def __next__(self): # second magic method #    if self.current > self.high: raise StopIteration else: self.current += 1 return self.current - 1

पहली जादू पद्धति "___iter__" या डंडर (अंडरस्कोर द्वारा दोहरा रेखांकित) है इटर एक पुनरावृत्त वस्तु देता है, यह अक्सर लूप की शुरुआत में उपयोग किया जाता है। Dunder अगला (__next__) अगली वस्तु देता है।

इसे जांचें:

 for c in Counter(3, 8): print(c)

निष्पादन परिणाम:

पायथन में, एक पुनरावृत्ति एक वस्तु है जिसमें केवल __iter__ विधि है। इसका मतलब है कि आप ऑब्जेक्ट (कंटेनर) की कोशिकाओं के स्थान तक पहुंच सकते हैं, लेकिन आप उनके माध्यम से "चलना" नहीं कर सकते। कुछ वस्तुओं में केवल अद्भुत __next__ विधि होती है, जादू __iter__ विधि के बिना, उदाहरण के लिए, सेट (उस पर बाद में अधिक)। इस लेख में, हम पुनरावृत्त वस्तुओं से संबंधित हर चीज को कवर करेंगे।

अब हम जानते हैं कि एक चलने योग्य वस्तु क्या है, चलो मानचित्र फ़ंक्शन पर लौटते हैं। यह फ़ंक्शन हमें पुनरावृत्त कंटेनर में प्रत्येक तत्व के लिए कुछ अन्य फ़ंक्शन की कार्रवाई को लागू करने की अनुमति देता है। हम सूची में प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करना चाहते हैं, यह लगभग सभी चलने योग्य कंटेनरों के लिए संभव है। नक्शा, दो तर्क लेता है: लागू होने वाला फ़ंक्शन, और कंटेनर (सूची, आदि)।

 map(function, iterable)

मान लें कि हमारे पास निम्नलिखित तत्वों के साथ एक सूची है:

[1, 2, 3, 4, 5]

और हम प्रत्येक तत्व को वर्गाकार करना चाहते हैं, इसे इस तरह किया जा सकता है:

 x = [1, 2, 3, 4, 5] def square(num): return num*num print(list(map(square, x)))

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

अचानक से किसी आलसी की गैर-आलसी परिभाषा से हटना थोड़ा अजीब है। यदि आप एक कार्यशील की तुलना में कार्यात्मक तरीके से अधिक सोचते हैं तो आपको इसकी आदत हो जाएगी।

लेखन कार्य, उदाहरण के लिए, "वर्ग (संख्या)" सामान्य है, लेकिन पूरी तरह से सही नहीं है। क्या हमें मानचित्र में इसका उपयोग करने के लिए पूरे फ़ंक्शन को घोषित करने की आवश्यकता है? यह (अनाम) लंबो कार्यों को शुरू करके सरल बनाया जा सकता है।

लम्बोदर भाव

एक पंक्ति में लैम्ब्डा अभिव्यक्तियाँ कार्य हैं, उदाहरण के लिए, यहाँ एक लैम्ब्डा अभिव्यक्ति है जो परिणामी संख्या को बढ़ाती है:

 square = lambda x: x * x

और, इसे चलाएं:

>>> square(3)
9

मैं आपको सुन सकता हूं। "ब्रैंडन, तर्क कहाँ हैं?" यह सब क्या है? यह एक फंक्शन की तरह नहीं है। ”

हां, यह भ्रामक हो सकता है, लेकिन इसे समझाया जा सकता है। इस पंक्ति में, हम चर "वर्ग" के लिए कुछ निर्दिष्ट करते हैं। यह हिस्सा:

 lambda x: x * x

पायथन को बताता है कि हम लैम्बडा फ़ंक्शन का उपयोग कर रहे हैं, और इनपुट का नाम x है। बृहदान्त्र के बाद सब कुछ इनपुट के लिए क्या होगा, और हम स्वचालित रूप से बाद में परिणाम प्राप्त करेंगे।

हमारे कार्यक्रम ने एक-पंक्ति का रूप ले लिया, आपको यह करने की आवश्यकता है:

 x = [1, 2, 3, 4, 5] print(list(map(lambda num: num * num, x)))

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

कम करें

कम करना एक ऐसा कार्य है जो एक पुनरावृत्त कंटेनर को एक चीज में बदल देता है। यही है, गणना की जाती है जो सूची को एक ही संख्या में बदल देती है। यह इस तरह दिखता है:

 reduce(function, list)

हम फ़ंक्शन तर्क के रूप में लैम्ब्डा कार्यों का उपयोग कर सकते हैं (और अक्सर)।

यदि हम सूची में सभी संख्याओं को गुणा करना चाहते हैं, तो इसे इस तरह किया जा सकता है:

 product = 1 x = [1, 2, 3, 4] for num in x: product = product * num

और कम करने के साथ यह इस तरह दिखाई देगा:

 from functools import reduce product = reduce((lambda x, y: x * y),[1, 2, 3, 4])

परिणाम समान होगा, लेकिन कोड कम है और इसे अधिक सटीक रूप से उपयोग करने के लिए कार्यात्मक प्रोग्रामिंग के ज्ञान के साथ।

फ़िल्टर

फ़िल्टर फ़ंक्शन एक पुनरावृत्त कंटेनर लेता है और इसे दिए गए नियम (एक फ़ंक्शन) के अनुसार फ़िल्टर करता है।

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

वाक्य रचना:

 filter(function, list)

आइए फ़िल्टर का उपयोग किए बिना एक उदाहरण देखें:

 x = range(-5, 5) new_list = [] for num in x: if num < 0: new_list.append(num)

फिल्टर के साथ:

 x = range(-5, 5) all_less_than_zero = list(filter(lambda num: num < 0, x))

उच्च आदेश कार्य

उच्च-क्रम के कार्य तर्कों के रूप में कार्य ले सकते हैं और उन्हें वापस कर सकते हैं। एक सरल उदाहरण इस तरह दिखेगा:

 def summation(nums): return sum(nums) def action(func, numbers): return func(numbers) print(action(summation, [1, 2, 3])) # Output is 6 #  6

या एक उदाहरण और भी सरल है:

 def rtnBrandon(): return "brandon" def rtnJohn(): return "john" def rtnPerson(): age = int(input("What's your age?")) if age == 21: return rtnBrandon() else: return rtnJohn()

पहले याद रखें कि मैंने कहा कि वास्तविक कार्यात्मक प्रोग्रामिंग चर का उपयोग नहीं करती है। उच्च-क्रम के कार्य इसे संभव बनाते हैं। यदि आप कार्यों की लंबी "सुरंग" के माध्यम से जानकारी पारित कर रहे हैं तो आपको चर को बचाने की आवश्यकता नहीं है।

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

एक कर्तव्य चक्र बनाता है
एक डेटा संरचना में एक चर या आइटम को सौंपा
फ़ंक्शन तर्क के रूप में पारित किया गया
फ़ंक्शन निष्पादन के परिणामस्वरूप लौटा

तो पायथन में सभी कार्य प्रथम श्रेणी की वस्तुएं हैं, और इन्हें उच्च क्रम के कार्यों के रूप में उपयोग किया जा सकता है।

आंशिक आवेदन

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

 def power(base, exponent): return base ** exponent

अब हमें स्क्वेरिंग के लिए एक अलग फ़ंक्शन बनाने और पावर फ़ंक्शन का उपयोग करके गणना करने की आवश्यकता है:

 def square(base): return power(base, 2)

यह काम करता है, लेकिन क्या होगा अगर हम एक संख्या को घन करना चाहते हैं? या 4 वीं डिग्री में? क्या आपको ऐसे कार्यों को हमेशा के लिए लिखना चाहिए? बेशक आप कर सकते हैं। लेकिन प्रोग्रामर आलसी हैं। यदि आप एक ही बात को कई बार दोहराते हैं, तो संभवत: इसे तेजी से करने और दोहराव को रोकने का एक तरीका है। आंशिक आवेदन का उपयोग यहां किया जा सकता है। आइए आंशिक एप्लिकेशन का उपयोग करके पावर फ़ंक्शन का एक उदाहरण देखें:

 from functools import partial square = partial(power, exponent=2) print(square(2)) # output is 4 #  4

क्या यह अच्छा नहीं है? हम एक फ़ंक्शन को कॉल कर सकते हैं, जिसमें 2 तर्कों की आवश्यकता है, केवल 1 का उपयोग करके, और यह निर्दिष्ट करना कि दूसरा अपने आप क्या होगा।

आप एक शक्ति फ़ंक्शन का अनुकरण करने के लिए एक लूप का उपयोग कर सकते हैं जो 1000 वीं शक्ति तक क्यूब्स के साथ काम करेगा।

 from functools import partial powers = [] for x in range(2, 1001): powers.append(partial(power, exponent = x)) print(powers[0](3)) # output is 9 #  9

कार्यात्मक प्रोग्रामिंग पाइथोनिक कैनन से मेल नहीं खाती है

आपने देखा होगा कि कार्यात्मक प्रोग्रामिंग में बहुत सी चीजें जो हम करना चाहते हैं, वे सूचियों में घूमती हैं। कम फ़ंक्शन और आंशिक अनुप्रयोग के अलावा, उन सभी फ़ंक्शंस को, जिन्हें आपने सूची बनाई थी। गुइदो (पायथन के निर्माता) पायथन `में कार्यात्मक चीजों को पसंद नहीं करते हैं, क्योंकि पायथन के पास सूची बनाने का अपना तरीका है।

यदि आप कंसोल में "इसे आयात करें" लिखते हैं, तो आपको मिलेगा:

>>> import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one — and preferably only one — obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let's do more of those!

यह पायथन ज़ेन है। यह एक कविता है जिसका अर्थ यह है कि इसका अर्थ एक अजगर है। वह हिस्सा जो हमें रुचता है:

एक होना चाहिए - और अधिमानतः केवल एक - स्पष्ट तरीका यह करने के लिए।

केवल एक ही होना चाहिए - और अधिमानतः केवल एक ही - कुछ करने का स्पष्ट तरीका।

पायथन में, मानचित्र और फ़िल्टर सूची अमूर्त ( लिंक ) के समान कर सकते हैं। यह पायथन-ज़ेन के नियमों में से एक का उल्लंघन करता है, इसलिए कार्यात्मक प्रोग्रामिंग का यह हिस्सा "पायथोनिक" नहीं है।

अगली चीजों के बारे में बात करने के लिए भेड़ का बच्चा कार्य कर रहे हैं। पायथन में, एक लैम्ब्डा फ़ंक्शन एक सामान्य कार्य है। और वास्तव में यह वाक्यात्मक चीनी है। ये दोनों भाग समान कार्य करते हैं:

 foo = lambda a: 2 def foo(a): return 2

एक मानक फ़ंक्शन अभी भी लैम्बडा फ़ंक्शन के समान हो सकता है, लेकिन इसके विपरीत नहीं। एक लैम्ब्डा फ़ंक्शन एक नियमित रूप से समान नहीं हो सकता है।

यह इस बारे में एक छोटी टिप्पणी थी कि कार्यात्मक प्रोग्रामिंग पाइथोनिक विचारधारा के लायक क्यों नहीं है। पहले, मैंने सूचियों के अमूर्त होने का उल्लेख किया ( सूची समावेशन भी ), अब इसके बारे में बात करते हैं।

अमूर्त सूची

मैंने पहले ही कहा है कि मानचित्र और फ़िल्टर का उपयोग करके जो कुछ भी किया जा सकता है, वह सूची अमूर्तता का उपयोग करके किया जा सकता है। इस भाग में हम इस पर चर्चा करेंगे।

सूची अमूर्तता पायथन में सूची बनाने का एक तरीका है। वाक्य रचना:

 [function for item in iterable]

आइए सूची में प्रत्येक आइटम को उदाहरण के लिए देखें:

 print([x * x for x in [1, 2, 3, 4]])

ठीक है, हम देख सकते हैं कि फ़ंक्शन को सूची के प्रत्येक तत्व पर कैसे लागू किया जाए। हम फ़िल्टर के आसपास कैसे प्राप्त करते हैं? इस कोड पर एक नज़र डालें:

 x = range(-5, 5) all_less_than_zero = list(filter(lambda num: num < 0, x)) print(all_less_than_zero)

अब सूची अमूर्त का उपयोग करें:

 x = range(-5, 5) all_less_than_zero = [num for num in x if num < 0]

सूची अमूर्तता इस तरह की सशर्त अभिव्यक्तियों का समर्थन करती है। अब आपको कुछ पाने के लिए एक लाख कार्यों का उपयोग करने की आवश्यकता नहीं है। वास्तव में, यदि आप एक सूची के साथ कुछ करने की कोशिश कर रहे हैं, तो संभावना है कि यह सूची के अमूर्तता के साथ क्लीनर और आसान है।

क्या होगा अगर हम सूची के प्रत्येक तत्व को शून्य से नीचे करना चाहते हैं। लैम्ब्डा फ़ंक्शन, मैप और फ़िल्टर के साथ, यह इस तरह दिखेगा:

 x = range(-5, 5) all_less_than_zero = list(map(lambda num: num * num, list(filter(lambda num: num < 0, x))))

यह प्रविष्टि तर्कसंगत नहीं है और बहुत सरल नहीं है। सूची अमूर्तता का उपयोग करना, यह इस तरह दिखेगा:

 x = range(-5, 5) all_less_than_zero = [num * num for num in x if num < 0]

सूचियों के लिए सूची अमूर्त केवल अच्छा, विचित्र रूप से पर्याप्त है। प्रत्येक चलने योग्य कंटेनर के लिए मानचित्र और फ़िल्टर काम करते हैं, तो क्या गलत है? .. हाँ, आप प्रत्येक चलने योग्य कंटेनर के लिए अमूर्त का उपयोग कर सकते हैं जो आपको मिलते हैं।

अन्य सार

आप प्रत्येक चलने योग्य कंटेनर के लिए अमूर्त आवेदन कर सकते हैं।

प्रत्येक चलने योग्य कंटेनर को अमूर्त का उपयोग करके बनाया जा सकता है। संस्करण 2.7 से शुरू होकर, आप एक शब्दकोश (हैश टेबल) भी बना सकते हैं।

यदि कुछ चलने योग्य कंटेनर है, तो कुछ उत्पन्न किया जा सकता है। चलो सेट का उपयोग करके अंतिम उदाहरण देखें। यदि आप नहीं जानते कि सेट क्या है, तो मेरे द्वारा लिखा गया यह लेख भी देखें। संक्षेप में:

सेट तत्वों का एक कंटेनर है, इसमें मौजूद तत्वों को दोहराया नहीं जाता है
आदेश महत्वपूर्ण नहीं है

 # taken from page 87, chapter 3 of Fluent Python by Luciano Ramalho #    Fluent Python, . 87, . 3 >>> from unicodedata import name >>> {chr(i) for i in range(32, 256) if 'SIGN' in name(chr(i), '')} {'×', '¥', '°', '£', '', '#', '¬', '%', 'µ', '>', '¤', '±', '¶', '§', '<', '=', '', '$', '÷', '¢', '+'}

जैसा कि आपने देखा होगा, शब्दकोश की तरह सेट, घुंघराले ब्रेसिज़ का उपयोग करता है। पायथन वास्तव में स्मार्ट है। वह अनुमान लगाएगा कि क्या आप एक शब्दकोश अमूर्त का उपयोग कर रहे हैं या एक set`a अमूर्त का उपयोग कर रहे हैं, इस आधार पर कि आप शब्दकोश के लिए अतिरिक्त पैरामीटर निर्दिष्ट करते हैं या नहीं। यदि आप अमूर्तता के बारे में अधिक जानना चाहते हैं, तो इसे पढ़ें। अगर अमूर्त और पीढ़ी के बारे में, तो यह एक ।

परिणाम

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

लेखक पृष्ठ ।

10 मिनट में पायथन में कार्यात्मक प्रोग्रामिंग सीखें