Python Functions: फ़ंक्शन्स को कैसे कॉल और लिखें

डिफ़ॉल्ट आर्ग्युमेंट्स

डिफ़ॉल्ट आर्ग्युमेंट्स वे होते हैं जो फ़ंक्शन कॉल के दौरान कोई वैल्यू पास न होने पर एक डिफ़ॉल्ट वैल्यू ले लेते हैं। आप यह डिफ़ॉल्ट वैल्यू असाइनमेंट ऑपरेटर = के साथ दे सकते हैं, जैसे निम्न उदाहरण में:

# Define `plus()` function
def plus(a,b = 2):
  return a + b
  
# Call `plus()` with only `a` parameter
plus(a=1)

# Call `plus()` with `a` and `b` parameters
plus(a=1, b=3)

आवश्यक आर्ग्युमेंट्स

नाम से ही स्पष्ट है, UDF के आवश्यक आर्ग्युमेंट्स वे होते हैं जिन्हें होना ही चाहिए। इन आर्ग्युमेंट्स को फ़ंक्शन कॉल के समय पास करना पड़ता है और ठीक उसी क्रम में, जैसे इस उदाहरण में:

# Define `plus()` with required arguments
def plus(a,b):
  return a + b

फ़ंक्शन को बिना एरर के कॉल करने के लिए आपको a और b पैरामीटर्स से मैप होने वाले आर्ग्युमेंट्स चाहिए। अगर आप a और b को अदल-बदल दें, तो परिणाम अलग नहीं होगा, लेकिन यह तब बदल सकता है जब आप plus() को निम्न रूप में बदल दें:

# Define `plus()` with required arguments
def plus(a,b):
  return a/b

कीवर्ड आर्ग्युमेंट्स

यदि आप यह सुनिश्चित करना चाहते हैं कि आप सभी पैरामीटर्स को सही क्रम में कॉल कर रहे हैं, तो आप अपने फ़ंक्शन कॉल में कीवर्ड आर्ग्युमेंट्स का उपयोग कर सकते हैं। आप इन्हें उनके पैरामीटर नाम से आर्ग्युमेंट्स की पहचान करने के लिए उपयोग करते हैं। इसे थोड़ा और स्पष्ट करने के लिए ऊपर वाले उदाहरण को लें:

# Define `plus()` function
def plus(a,b):
  return a + b
  
# Call `plus()` function with parameters 
plus(2,3)

# Call `plus()` function with keyword arguments
plus(a=1, b=2)

ध्यान दें कि कीवर्ड आर्ग्युमेंट्स का उपयोग करके, आप पैरामीटर्स के क्रम को बदल भी सकते हैं और फिर भी फ़ंक्शन चलाने पर वही परिणाम पाएँगे:

# Define `plus()` function
def plus(a,b):
  return a + b
  
# Call `plus()` function with keyword arguments
plus(b=2, a=1)

वैरिएबल संख्या के आर्ग्युमेंट्स

ऐसे मामलों में जहाँ आपको यह नहीं पता कि आप फ़ंक्शन को कितने आर्ग्युमेंट्स पास करना चाहते हैं, आप *args के साथ निम्न सिंटैक्स का उपयोग कर सकते हैं:

# Define `plus()` function to accept a variable number of arguments
def plus(*args):
  return sum(args)

# Calculate the sum
plus(1,4,5)

एस्टेरिस्क (*) उस वैरिएबल नाम के पहले लगाया जाता है जो सभी nonkeyword वैरिएबल आर्ग्युमेंट्स के मानों को रखता है। ध्यान दें कि आप *varint, *var_int_args या कोई और नाम भी plus() फ़ंक्शन को पास कर सकते थे।

टिप: *args को किसी दूसरे नाम से बदलकर देखें जिसमें एस्टेरिस्क शामिल हो। आप देखेंगे कि ऊपर का कोड वैसे ही काम करता रहेगा!

आप देखते हैं कि ऊपर दिया गया फ़ंक्शन बिल्ट-इन Python sum() फ़ंक्शन का उपयोग करके उन सभी आर्ग्युमेंट्स का योग निकालता है जो plus() को पास किए जाते हैं। 

ग्लोबल बनाम लोकल वेरिएबल्स

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

आप देखेंगे कि जब आप फ़ंक्शन बॉडी के अंदर परिभाषित लोकल वेरिएबल total को प्रिंट करने की कोशिश करते हैं, तो आपको NameError मिलेगा, जो कहेगा कि name 'total' is not defined। दूसरी ओर, init वेरिएबल बिना किसी समस्या के प्रिंट किया जा सकता है।

Positional-only और keyword-only पैरामीटर्स

Python 3.8 से, आप अपनी फ़ंक्शन सिग्नेचर में दो विशेष मार्कर्स: / और * का उपयोग करके यह नियंत्रित कर सकते हैं कि आर्ग्युमेंट्स कैसे पास किए जाएँ। / से पहले की हर चीज़ केवल पॉज़िशनली पास की जा सकती है; * के बाद की हर चीज़ केवल कीवर्ड के जरिए पास की जा सकती है।

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")संचालित द्वारा

 कॉल साइट पर यह इस तरह दिखता है:

greet("Alice")                          # works
greet("Alice", greeting="Hi")           # works
greet("Alice", "Hi", punctuation="?")   # works

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-onlyसंचालित द्वारा

आप ऐसा क्यों चाहेंगे? दो मुख्य कारण।

पहला, positional-only पैरामीटर्स आपको बाद में उनके नाम बदलने की आज़ादी देते हैं बिना किसी के कोड को तोड़े — क्योंकि कोई भी पैरामीटर नाम को कीवर्ड के रूप में इस्तेमाल नहीं कर सकता, आप इसे बदलने के लिए स्वतंत्र हैं।

दूसरा, keyword-only पैरामीटर्स कॉलर्स को यह स्पष्ट करने के लिए बाध्य करते हैं कि वे क्या पास कर रहे हैं, जो तब कॉल्स को अधिक पठनीय बनाता है जब आपके पास कई वैकल्पिक फ़्लैग्स या सेटिंग्स हों।

संक्षेप में, ये आशय (intent) को साफ़-साफ़ लागू करने का एक सुथरा तरीका हैं।

Python में गुमनाम (Anonymous) फ़ंक्शन्स

गुमनाम फ़ंक्शन्स को Python में lambda फ़ंक्शन्स भी कहा जाता है क्योंकि इन्हें मानक def कीवर्ड के बजाय lambda कीवर्ड से घोषित किया जाता है।

double = lambda x: x*2

double(5)

ऊपर दिए गए DataCamp Light चंक में, lambda x: x*2 गुमनाम या lambda फ़ंक्शन है। x आर्ग्युमेंट है, और x*2 वह एक्सप्रेशन या निर्देश है जिसका मूल्यांकन कर रिटर्न किया जाता है। इस फ़ंक्शन की ख़ास बात यह है कि इसका कोई नाम नहीं है, जैसे कि आपने इस ट्यूटोरियल के पहले भाग में देखे उदाहरणों में था। यदि आपको ऊपर वाले फ़ंक्शन को UDF में लिखना हो, तो परिणाम निम्न होगा:

def double(x):
  return x*2संचालित द्वारा

आइए दो आर्ग्युमेंट्स वाले एक और lambda फ़ंक्शन का उदाहरण देखें:

# `sum()` lambda function
sum = lambda x, y: x + y;

# Call the `sum()` anonymous function
sum(4,5)

# "Translate" to a UDF
def sum(x, y):
  return x+y

आप गुमनाम फ़ंक्शन्स का उपयोग तब करते हैं जब आपको थोड़े समय के लिए बिना नाम का फ़ंक्शन चाहिए, और जिसे रनटाइम पर बनाया जाता है। ऐसे विशिष्ट संदर्भ जहाँ यह प्रासंगिक होता है, वे हैं जब आप filter(), map() और reduce() के साथ काम कर रहे हों:

from functools import reduce

my_list = [1,2,3,4,5,6,7,8,9,10]

# Use lambda function with `filter()`
filtered_list = list(filter(lambda x: (x*2 > 10), my_list))

# Use lambda function with `map()`
mapped_list = list(map(lambda x: x*2, my_list))

# Use lambda function with `reduce()`
reduced_list = reduce(lambda x, y: x+y, my_list)

print(filtered_list)
print(mapped_list)
print(reduced_list)

filter() फ़ंक्शन, जैसा कि नाम से स्पष्ट है, मूल इनपुट सूची my_list को किसी मानदंड >10 के आधार पर फ़िल्टर करता है। दूसरी ओर, map() के साथ, आप सूची my_list के सभी आइटम्स पर कोई फ़ंक्शन लागू करते हैं। इस मामले में, आप सभी तत्वों को 2 से गुणा करते हैं।

ध्यान दें कि reduce() फ़ंक्शन functools लाइब्रेरी का हिस्सा है। आप इस फ़ंक्शन का उपयोग my_list की आइटम्स पर बाएँ से दाएँ क्रम में क्रमिक रूप से करते हैं और अनुक्रम को एक एकल मान में घटाते हैं, जो इस मामले में 55 है।

Python में main() को फ़ंक्शन की तरह उपयोग करना

यदि आपको Java जैसी अन्य प्रोग्रामिंग भाषाओं का अनुभव है, तो आप जानते होंगे कि फ़ंक्शन्स को निष्पादित करने के लिए main फ़ंक्शन आवश्यक होता है। जैसा कि आपने ऊपर दिए उदाहरणों में देखा, Python के लिए यह ज़रूरी नहीं है। फिर भी, अपने Python प्रोग्राम में main() फ़ंक्शन शामिल करना आपके कोड को तार्किक रूप से व्यवस्थित करने में सहायक हो सकता है — सबसे महत्वपूर्ण घटक इसी main() फ़ंक्शन के भीतर समाहित होते हैं।

आप आसानी से एक main() फ़ंक्शन परिभाषित कर सकते हैं और इसे वैसा ही कॉल कर सकते हैं जैसा आपने ऊपर अन्य सभी फ़ंक्शन्स के साथ किया है:

# Define `main()` function
def main():
  hello()
  print("This is a main function")

main()

हालाँकि, अभी की स्थिति में, जब आप इसे किसी मॉड्यूल के रूप में इम्पोर्ट करेंगे, तो आपके main() फ़ंक्शन का कोड कॉल हो जाएगा। यह सुनिश्चित करने के लिए कि ऐसा न हो, आप __name__ == '__main__' होने पर ही main() फ़ंक्शन को कॉल करते हैं।

इसका मतलब है कि ऊपर दिए गए कोड चंक का कोड इस प्रकार बन जाता है:

# Define `main()` function
def main():
  hello()
  print("This is a main function")
  
# Execute `main()` function 
if __name__ == '__main__':
    main()

नोट कि __main__ फ़ंक्शन के अलावा, आपके पास एक __init__ फ़ंक्शन भी होता है जो किसी क्लास या ऑब्जेक्ट के इंस्टेंस को इनिशियलाइज़ करता है। सरल शब्दों में, यह कंस्ट्रक्टर या इनिशियलाइज़र की तरह काम करता है और जब आप किसी क्लास का नया इंस्टेंस बनाते हैं तो अपने-आप कॉल होता है। इस फ़ंक्शन के साथ, नया बना ऑब्जेक्ट पैरामीटर self को असाइन होता है, जिसे आपने इस ट्यूटोरियल में पहले देखा था। निम्न उदाहरण देखें:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())संचालित द्वारा