पायथन में फंक्शन

यह लेख पायथन में फंक्शन को समझाता है।

YouTube Video

पायथन में फंक्शन

पायथन में फंक्शन कोड के पुन: उपयोग योग्य ब्लॉक्स को परिभाषित करने की एक महत्वपूर्ण विशेषता है, जो आपको आवश्यकतानुसार उन्हें कॉल करके अपने प्रोग्राम को व्यवस्थित और सरल बनाने की अनुमति देता है। फंक्शन्स का उपयोग कोड की पठनीयता में सुधार कर सकता है और DRY सिद्धांत (Don't Repeat Yourself) का पालन कर सकता है, जिससे एक ही कोड को बार-बार लिखने से बचा जा सके।

फंक्शन्स को परिभाषित करना

फंक्शन्स को def कीवर्ड का उपयोग करके परिभाषित किया जाता है। मूल सिंटैक्स इस प्रकार है:।

1def function_name(arg1, arg2, ..., argN):
2    """docstring (A brief description of the function)"""
3    processing
4    return return_value

उदाहरण के लिए, यदि आप दो संख्याओं को जोड़ने वाला एक फ़ंक्शन परिभाषित करना चाहते हैं, तो आप इसे इस प्रकार लिखेंगे:।

1def add(x, y):
2    """A function that adds two numbers and returns the result"""
3    return x + y

फ़ंक्शन को कॉल करना

एक परिभाषित फ़ंक्शन को कॉल और उपयोग इस प्रकार किया जा सकता है:।

1result = add(3, 4)
2print(result)  # Output: 7

फ़ंक्शन के घटक

1. फ़ंक्शन का नाम: फ़ंक्शन का नाम, जिसका उपयोग इसे कॉल करने के लिए किया जाता है।

2. आर्ग्युमेंट्स (पैरामीटर्स): वे वेरिएबल नाम जो कॉल के दौरान पास किए गए डेटा को प्राप्त करते हैं। आप शून्य या अधिक आर्ग्युमेंट्स को परिभाषित कर सकते हैं।

3. डॉक्यूमेंटेशन स्ट्रिंग (डॉकस्ट्रिंग): एक स्ट्रिंग जिसका उपयोग किसी फ़ंक्शन के उद्देश्य और उपयोग को वर्णित करने के लिए किया जाता है। वैकल्पिक।

4. फ़ंक्शन बॉडी: यह एक इनडेंटेड ब्लॉक है जहां फ़ंक्शन द्वारा निष्पादित किए जाने वाले निर्देश लिखे जाते हैं।

5. रिटर्न वैल्यू: वह मान जो return स्टेटमेंट का उपयोग करके कॉलर को वापस किया जाता है। यदि return को छोड़ा जाता है, तो डिफ़ॉल्ट रूप से None लौटाया जाता है।

आर्ग्युमेंट्स के प्रकार

पायथन में, विभिन्न प्रकार के आर्ग्युमेंट्स होते हैं।

1. पोजिशनल आर्ग्युमेंट्स: फंक्शन को आर्ग्युमेंट्स पास करने का मानक तरीका।
2. डिफ़ॉल्ट आर्ग्युमेंट्स: आर्ग्युमेंट्स जिनके डिफ़ॉल्ट मान होते हैं और जिन्हें कॉल के दौरान छोड़ा जा सकता है।

1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"

3. चर-लंबाई वाले तर्क: *args का उपयोग करके कई स्थानिक तर्कों को एक ट्यूपल के रूप में प्राप्त करना, और **kwargs का उपयोग करके उन्हें एक शब्दकोश के रूप में प्राप्त करना।

1def func(*args, **kwargs):
2    print("args:", args)
3    print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}

सही ढंग से फ़ंक्शंस का उपयोग करके, आप अधिक प्रभावी और कुशल तरीके से Python प्रोग्राम लिख सकते हैं।

Python में लैम्ब्डा फ़ंक्शंस

Python में, lambda फ़ंक्शंस का उपयोग गुमनाम और संक्षिप्त फ़ंक्शंस को परिभाषित करने के लिए किया जाता है। सामान्य def कीवर्ड के साथ परिभाषित फ़ंक्शंस के विपरीत, lambda आपको छोटे, एक-पंक्ति वाले फ़ंक्शंस बनाने की अनुमति देता है। यहाँ, हम Python में lambda फ़ंक्शंस को विस्तार से समझाएंगे।

lambda फ़ंक्शंस की मूल बातें

lambda फ़ंक्शंस, जिन्हें गुमनाम फ़ंक्शंस भी कहा जाता है, का उपयोग अस्थायी फ़ंक्शंस को परिभाषित करने के लिए किया जाता है जिनका कोई नाम नहीं होता। मूल सिंटैक्स इस प्रकार है:।

1lambda arguments: expression

• arguments: फ़ंक्शन के तर्क निर्दिष्ट करें। कई तर्कों को कॉमा द्वारा अलग करके निर्दिष्ट किया जा सकता है।
• expression: यह एक एक्सप्रेशन है जिसे तर्कों के आधार पर मूल्यांकित किया जाता है। एक्सप्रेशन का परिणाम फ़ंक्शन का रिटर्न मान बनता है।

उदाहरण के लिए, निम्नलिखित कोड एक lambda फ़ंक्शन को परिभाषित करता है और निष्पादित करता है जो दो संख्याओं को जोड़ता है।

1add = lambda x, y: x + y
2print(add(5, 3))  # Output: 8

इस उदाहरण में, lambda x, y: x + y एक lambda फ़ंक्शन है जो दो तर्क लेता है, x और y, और उनका योग लौटाता है।

lambda फ़ंक्शंस के उपयोग के मामले

lambda फ़ंक्शंस उन स्थितियों के लिए उपयोगी होते हैं जहाँ आपको तुरंत एक सरल फ़ंक्शन परिभाषित करने की आवश्यकता होती है। वे विशेष रूप से निम्नलिखित मामलों में आम होते हैं:।

1. जब फ़ंक्शंस को तर्कों के रूप में पास किया जाता है

   • यह उच्च-क्रम के फ़ंक्शन (ऐसे फ़ंक्शन जो अन्य फ़ंक्शन को तर्क के रूप में लेते हैं) में उपयोगी होता है जब छोटे, अस्थायी फ़ंक्शन पास किए जाते हैं।

2. सूचियों को सॉर्ट करने के लिए कुंजियाँ निर्दिष्ट करने पर

   • वे sort() या sorted() जैसी फ़ंक्शंस में सॉर्टिंग मानदंड (कुंजियाँ) निर्दिष्ट करने के लिए सुविधाजनक होते हैं।

उच्च-स्तरीय फ़ंक्शंस में उदाहरण उपयोग

उच्च-स्तरीय फ़ंक्शंस के सामान्य उदाहरणों में map(), filter(), और reduce() शामिल हैं। ये फ़ंक्शंस अन्य फ़ंक्शंस को तर्कों के रूप में लेते हैं और उन्हें सूचियों जैसी अनुक्रमों पर लागू करते हैं।

1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared)  # Output: [1, 4, 9, 16, 25]

इस उदाहरण में, एक lambda फ़ंक्शन को map() फ़ंक्शन में पास किया गया है ताकि सूची में प्रत्येक संख्या का वर्ग किया जा सके।

सूचियों के सॉर्टिंग के उपयोग के उदाहरण

lambda फ़ंक्शन का उपयोग कभी-कभी एक सूची को सॉर्ट करते समय एक कस्टम कुंजी निर्दिष्ट करने के लिए किया जा सकता है। उदाहरण के लिए, नीचे दिया गया कोड दूसरे तत्व के आधार पर ट्यूपल की सूची को सॉर्ट करता है।

1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

इस उदाहरण में, ट्यूपल को उनके दूसरे तत्व (एक स्ट्रिंग) के आधार पर सॉर्ट करने के लिए lambda फ़ंक्शन का उपयोग किया गया है।

filter() और lambda

filter() फ़ंक्शन का उपयोग सूची (या अन्य इटरबल) में दिए गए शर्त के अनुसार तत्वों को फ़िल्टर करने के लिए किया जाता है।

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3print(even_numbers)  # Output: [2, 4, 6, 8]

इस उदाहरण में, एक सूची में मौजूद सम संख्याओं को फ़िल्टर करके एक नई सूची बनाई गई है।

lambda और reduce()

reduce() फ़ंक्शन का उपयोग एक सूची को एकल मान में बदलने के लिए किया जाता है। इसे आसानी से एक lambda फ़ंक्शन का उपयोग करके लागू किया जा सकता है।

1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product)  # Output: 120

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

जटिल lambda फ़ंक्शनों का उपयोग करने से बचें

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

उदाहरण के लिए, आपको नीचे दिए गए जैसे जटिल lambda फ़ंक्शनों का उपयोग करने से बचना चाहिए।

1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)

इस स्थिति में, जैसा कि नीचे दिखाया गया है, def के साथ परिभाषित फ़ंक्शन का उपयोग करना बेहतर है।

1def complex_func(x, y):
2    if x > y:
3        return x * 2 + y
4    else:
5        return x + y * 2

निष्कर्ष

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

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video