पाइथन में फंक्शंस (Functions in Python)

इस अध्याय में, हम पाइथन में फंक्शंस (Functions) के उपयोग को समझेंगे। फंक्शंस प्रोग्रामिंग का एक महत्वपूर्ण हिस्सा हैं जो कोड को अधिक संगठित, पुन: उपयोगी और पठनीय बनाते हैं। फंक्शंस का उपयोग करके, आप कोड के टुकड़ों को परिभाषित कर सकते हैं और उन्हें कई बार कॉल कर सकते हैं, जिससे आपके प्रोग्राम में कोड की पुनरावृत्ति (redundancy) कम होती है। इस अध्याय में, हम फंक्शन की परिभाषा, फंक्शंस को कॉल करने, फंक्शन पैरामीटर्स और आर्गुमेंट्स, रिटर्न स्टेटमेंट, फंक्शन डॉक्स्ट्रिंग्स, स्कोप, नेस्टेड फंक्शंस, लैम्ब्डा फंक्शंस, रिक्रूज़न, और बिल्ट-इन फंक्शंस के बारे में विस्तार से जानेंगे। इसके अलावा, हम मॉड्यूल्स और पैकेजेस के साथ फंक्शंस के उपयोग और कुछ उपयोगी टिप्स पर भी चर्चा करेंगे।

फंक्शन क्या है? (What is a Function?)

फंक्शन (Function) प्रोग्रामिंग में एक संगठित, पुन: उपयोगी कोड का ब्लॉक होता है, जो किसी विशेष कार्य (task) को पूरा करने के लिए डिज़ाइन किया गया होता है। फंक्शन का उपयोग कोड को विभाजित करने और प्रोग्राम को अधिक मॉड्यूलर और पठनीय बनाने के लिए किया जाता है। फंक्शंस की सहायता से, आप जटिल कार्यों को छोटे, प्रबंधनीय हिस्सों में विभाजित कर सकते हैं, जिन्हें बार-बार उपयोग किया जा सकता है।

फंक्शन के मुख्य घटक (Main Components of a Function)

1. फंक्शन का नाम (Function Name): फंक्शन का नाम उस कार्य को संदर्भित करता है जिसे फंक्शन निष्पादित करेगा। फंक्शन नाम का उपयोग फंक्शन को कॉल करने के लिए किया जाता है।
2. पैरामीटर्स (Parameters): पैरामीटर्स वह जानकारी हैं जो फंक्शन को इनपुट के रूप में दी जाती है। ये फंक्शन के लिए वैकल्पिक हैं।
3. फंक्शन बॉडी (Function Body): फंक्शन बॉडी में वे सभी कोड स्टेटमेंट्स होते हैं जो फंक्शन का कार्य पूरा करते हैं। यह इंडेंटेड ब्लॉक में लिखा जाता है।
4. रिटर्न स्टेटमेंट (Return Statement): रिटर्न स्टेटमेंट वह मान लौटाता है जिसे फंक्शन कॉल के बाद प्राप्त किया जाता है। यह भी वैकल्पिक है।

फंक्शन का महत्व (Importance of Functions)

1. कोड का पुन: उपयोग (Code Reusability): एक बार फंक्शन को परिभाषित करने के बाद, आप इसे कई बार कॉल कर सकते हैं, जिससे कोड का पुन: उपयोग होता है और कोड की पुनरावृत्ति (redundancy) कम होती है।
2. मॉड्यूलरिटी (Modularity): फंक्शंस प्रोग्राम को छोटे, प्रबंधनीय हिस्सों में विभाजित करते हैं, जिससे प्रोग्राम को समझना और बनाए रखना आसान हो जाता है।
3. कोड का संगठन (Code Organization): फंक्शंस का उपयोग कोड को संगठित रखने के लिए किया जाता है। यह प्रोग्राम को अधिक स्पष्ट और व्यवस्थित बनाता है।
4. डिबगिंग और परीक्षण (Debugging and Testing): फंक्शंस का उपयोग करके, आप कोड के छोटे हिस्सों का परीक्षण और डिबग कर सकते हैं, जिससे त्रुटियों को ढूंढना और ठीक करना आसान हो जाता है।

फंक्शन का सिंटैक्स (Syntax of a Function)

पाइथन में एक फंक्शन को परिभाषित करने के लिए def कीवर्ड का उपयोग किया जाता है। फंक्शन का नाम और पैरामीटर्स ब्रैकेट्स में दिए जाते हैं। फंक्शन बॉडी इंडेंटेड ब्लॉक में लिखी जाती है।

def function_name(parameters):
    # फंक्शन बॉडी
    # कोड स्टेटमेंट्स
    return value  # वैकल्पिक

उदाहरण (Example)

def greet(name):
    """यह फंक्शन दिए गए नाम के साथ एक अभिवादन संदेश प्रिंट करता है।"""
    print(f"नमस्ते, {name}!")

greet("राम")

फंक्शन पैरामीटर्स और आर्गुमेंट्स (Function Parameters and Arguments)

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

डिफ़ॉल्ट पैरामीटर्स (Default Parameters)

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

def greet(name, message="नमस्ते"):
    print(f"{message}, {name}!")

greet("राम")  # आउटपुट: नमस्ते, राम!
greet("सीता", "सुप्रभात")  # आउटपुट: सुप्रभात, सीता!

कीवर्ड आर्गुमेंट्स (Keyword Arguments)

कीवर्ड आर्गुमेंट्स का उपयोग करके, आप फंक्शन कॉल में पैरामीटर्स को उनके नाम से निर्दिष्ट कर सकते हैं। इससे फंक्शन कॉल अधिक स्पष्ट और पठनीय बनती है।

def greet(name, message):
    print(f"{message}, {name}!")

greet(name="राम", message="नमस्ते")  # आउटपुट: नमस्ते, राम!
greet(message="सुप्रभात", name="सीता")  # आउटपुट: सुप्रभात, सीता!

वेरिएबल-लेंथ आर्गुमेंट्स (Variable-Length Arguments)

वेरिएबल-लेंथ आर्गुमेंट्स का उपयोग तब किया जाता है जब आप नहीं जानते कि कितने आर्गुमेंट्स फंक्शन को पास किए जाएंगे। पाइथन में दो प्रकार के वेरिएबल-लेंथ आर्गुमेंट्स होते हैं:

1. अवैधृत आर्गुमेंट्स (Arbitrary Arguments) *args का उपयोग करके, आप फंक्शन में एक ट्यूपल के रूप में अवैधृत आर्गुमेंट्स पास कर सकते हैं।

   def greet(*names):
       for name in names:
           print(f"नमस्ते, {name}!")
   
   greet("राम", "सीता", "लक्ष्मण")  # आउटपुट: नमस्ते, राम! नमस्ते, सीता! नमस्ते, लक्ष्मण!
   

    

2. अवैधृत कीवर्ड आर्गुमेंट्स (Arbitrary Keyword Arguments) **kwargs का उपयोग करके, आप फंक्शन में एक डिक्शनरी के रूप में अवैधृत कीवर्ड आर्गुमेंट्स पास कर सकते हैं।

   def greet(**kwargs):
       for key, value in kwargs.items():
           print(f"{key} का अभिवादन: {value}")
   
   greet(राम="नमस्ते", सीता="सुप्रभात")  # आउटपुट: राम का अभिवादन: नमस्ते, सीता का अभिवादन: सुप्रभात
   

    

उदाहरण (Example)

def describe_person(name, age, city="अज्ञात", *hobbies, **attributes):
    print(f"नाम: {name}")
    print(f"उम्र: {age}")
    print(f"शहर: {city}")
    print("शौक:", ", ".join(hobbies))
    for key, value in attributes.items():
        print(f"{key}: {value}")

describe_person("राम", 25, "अयोध्या", "पढ़ना", "लेखन", पेशा="राजकुमार", भाषा="संस्कृत")

आउटपुट:

नाम: राम
उम्र: 25
शहर: अयोध्या
शौक: पढ़ना, लेखन
पेशा: राजकुमार
भाषा: संस्कृत

रिटर्न स्टेटमेंट (Return Statement)

रिटर्न स्टेटमेंट (Return Statement) पाइथन में फंक्शन के निष्पादन को समाप्त करने और फंक्शन से एक मान लौटाने के लिए उपयोग किया जाता है। return कीवर्ड का उपयोग करके, आप फंक्शन से एक या एक से अधिक मान लौट सकते हैं। रिटर्न स्टेटमेंट फंक्शन को और अधिक लचीला और शक्तिशाली बनाता है, जिससे फंक्शन के परिणामों का उपयोग प्रोग्राम के अन्य हिस्सों में किया जा सकता है।

सिंटैक्स (Syntax)

def function_name(parameters):
    # फंक्शन बॉडी
    return value

उदाहरण (Examples)

1. सरल रिटर्न स्टेटमेंट (Simple Return Statement)

   def add(a, b):
       return a + b
   
   result = add(5, 3)
   print(result)
   

   आउटपुट:

   8
   

    

2. कई मान लौटाना (Returning Multiple Values)

   def get_person_info():
       name = "राम"
       age = 25
       city = "अयोध्या"
       return name, age, city
   
   name, age, city = get_person_info()
   print(f"नाम: {name}, उम्र: {age}, शहर: {city}")
   

   आउटपुट:

   नाम: राम, उम्र: 25, शहर: अयोध्या
   

    

3. कंडीशनल रिटर्न स्टेटमेंट (Conditional Return Statement)

   def check_even_odd(number):
       if number % 2 == 0:
           return "सम संख्या"
       else:
           return "विषम संख्या"
   
   result = check_even_odd(10)
   print(result)
   

   आउटपुट:

   सम संख्या
   

    

रिटर्न स्टेटमेंट का महत्व (Importance of Return Statement)

1. मानों को वापस करना (Returning Values): रिटर्न स्टेटमेंट का उपयोग फंक्शन से मानों को वापस करने के लिए किया जाता है, जिससे इन मानों का उपयोग प्रोग्राम के अन्य हिस्सों में किया जा सकता है।
2. फंक्शन निष्पादन को समाप्त करना (Ending Function Execution): जब रिटर्न स्टेटमेंट निष्पादित होता है, तो फंक्शन का निष्पादन तुरंत समाप्त हो जाता है और कंट्रोल फंक्शन कॉल करने वाले कोड पर वापस आ जाता है।
3. कंडीशनल रिटर्न (Conditional Return): आप कंडीशनल स्टेटमेंट्स का उपयोग करके विभिन्न स्थितियों के आधार पर विभिन्न मान लौटाने के लिए रिटर्न स्टेटमेंट का उपयोग कर सकते हैं।

डिफ़ॉल्ट रिटर्न मान (Default Return Value)

यदि फंक्शन में रिटर्न स्टेटमेंट नहीं है, तो फंक्शन डिफ़ॉल्ट रूप से None लौटाता है।

उदाहरण (Example):

def greet(name):
    print(f"नमस्ते, {name}!")

result = greet("राम")
print(result)

आउटपुट:

नमस्ते, राम!
None

रिटर्न स्टेटमेंट के साथ लूप्स (Return Statement with Loops)

आप लूप्स के अंदर भी रिटर्न स्टेटमेंट का उपयोग कर सकते हैं। जब रिटर्न स्टेटमेंट लूप के अंदर निष्पादित होता है, तो फंक्शन का निष्पादन तुरंत समाप्त हो जाता है।

उदाहरण (Example):

def find_first_even(numbers):
    for num in numbers:
        if num % 2 == 0:
            return num
    return None

numbers = [1, 3, 5, 7, 8, 10]
result = find_first_even(numbers)
print(result)

आउटपुट:

8

फंक्शन डॉक्स्ट्रिंग्स (Function Docstrings)

फंक्शन डॉक्स्ट्रिंग्स (Function Docstrings) फंक्शन के उद्देश्य, पैरामीटर्स, और रिटर्न मान के बारे में जानकारी प्रदान करने के लिए उपयोग की जाती हैं। डॉक्स्ट्रिंग्स को ट्रिपल कोट्स (""") के भीतर लिखा जाता है और यह फंक्शन के पहले स्टेटमेंट के रूप में आता है। डॉक्स्ट्रिंग्स का उपयोग फंक्शन के दस्तावेज़ीकरण और कोड को अधिक पठनीय और समझने में आसान बनाने के लिए किया जाता है।

सिंटैक्स (Syntax)

def function_name(parameters):
    """
    यह एक डॉक्स्ट्रिंग है।
    
    पैरामीटर्स:
        parameters (type): विवरण
    
    रिटर्न:
        return_value (type): विवरण
    """
    # फंक्शन बॉडी
    return value

उदाहरण (Examples)

1. सरल डॉक्स्ट्रिंग (Simple Docstring)

   def greet(name):
       """
       दिए गए नाम के साथ अभिवादन प्रिंट करता है।
       
       पैरामीटर्स:
           name (str): व्यक्ति का नाम
       
       रिटर्न:
           None
       """
       print(f"नमस्ते, {name}!")
   
   greet("राम")
   

   आउटपुट:

   नमस्ते, राम!
   

    

2. विस्तृत डॉक्स्ट्रिंग (Detailed Docstring)

   def add(a, b):
       """
       दो संख्याओं का योग करता है।
       
       पैरामीटर्स:
           a (int, float): पहली संख्या
           b (int, float): दूसरी संख्या
       
       रिटर्न:
           int, float: दोनों संख्याओं का योग
       """
       return a + b
   
   result = add(5, 3)
   print(result)
   

   आउटपुट:

   8
   

    

डॉक्स्ट्रिंग्स का महत्व (Importance of Docstrings)

1. कोड की पठनीयता (Readability): डॉक्स्ट्रिंग्स कोड को अधिक पठनीय बनाती हैं और फंक्शन के उपयोग के बारे में जानकारी प्रदान करती हैं।
2. दस्तावेज़ीकरण (Documentation): डॉक्स्ट्रिंग्स का उपयोग फंक्शन के उद्देश्य, इनपुट पैरामीटर्स, और रिटर्न मान को दस्तावेजित करने के लिए किया जाता है, जिससे कोड को समझना और बनाए रखना आसान हो जाता है।
3. हेल्प फंक्शन (Help Function): डॉक्स्ट्रिंग्स का उपयोग help() फंक्शन के साथ किया जा सकता है, जिससे फंक्शन के बारे में जानकारी प्राप्त की जा सकती है।उदाहरण (Example):

   def greet(name):
       """
       दिए गए नाम के साथ अभिवादन प्रिंट करता है।
       
       पैरामीटर्स:
           name (str): व्यक्ति का नाम
       
       रिटर्न:
           None
       """
       print(f"नमस्ते, {name}!")
   
   help(greet)
   

   आउटपुट:

   Help on function greet in module __main__:
   
   greet(name)
       दिए गए नाम के साथ अभिवादन प्रिंट करता है।
       
       पैरामीटर्स:
           name (str): व्यक्ति का नाम
       
       रिटर्न:
           None
   

    

स्टाइल गाइड्स के अनुसार डॉक्स्ट्रिंग्स लिखना (Writing Docstrings According to Style Guides)

डॉक्स्ट्रिंग्स लिखते समय, यह सुनिश्चित करना महत्वपूर्ण है कि वे स्पष्ट, संक्षिप्त और समझने में आसान हों। PEP 257 पाइथन डॉक्स्ट्रिंग्स के लिए स्टाइल गाइड है और इसमें डॉक्स्ट्रिंग्स लिखने के लिए सर्वोत्तम प्रथाओं का वर्णन किया गया है।

उदाहरण (Example):

def calculate_area(radius):
    """
    वृत का क्षेत्रफल गणना करता है।
    
    यह फंक्शन दिए गए त्रिज्या (radius) का उपयोग करके वृत का क्षेत्रफल (area) गणना करता है।
    
    पैरामीटर्स:
        radius (float): वृत की त्रिज्या
    
    रिटर्न:
        float: वृत का क्षेत्रफल
    """
    import math
    return math.pi * radius ** 2

help(calculate_area)

आउटपुट:

Help on function calculate_area in module __main__:

calculate_area(radius)
    वृत का क्षेत्रफल गणना करता है।
    
    यह फंक्शन दिए गए त्रिज्या (radius) का उपयोग करके वृत का क्षेत्रफल (area) गणना करता है।
    
    पैरामीटर्स:
        radius (float): वृत की त्रिज्या
    
    रिटर्न:
        float: वृत का क्षेत्रफल

फंक्शंस के साथ स्कोप (Scope with Functions)

स्कोप (Scope) एक प्रोग्राम के उस हिस्से को संदर्भित करता है जहां एक विशेष वेरिएबल को पहचाना और एक्सेस किया जा सकता है। पाइथन में, वेरिएबल्स का स्कोप मुख्यतः दो प्रकार का होता है: लोकल स्कोप (Local Scope) और ग्लोबल स्कोप (Global Scope)। स्कोप फंक्शंस के साथ काम करते समय महत्वपूर्ण होता है क्योंकि यह निर्धारित करता है कि वेरिएबल्स को कहां और कैसे एक्सेस किया जा सकता है।

लोकल स्कोप (Local Scope)

जब एक वेरिएबल फंक्शन के भीतर परिभाषित होता है, तो उसका स्कोप केवल उस फंक्शन तक सीमित होता है। इसे लोकल वेरिएबल (Local Variable) कहा जाता है। लोकल वेरिएबल्स फंक्शन के बाहर एक्सेस नहीं किए जा सकते हैं।

उदाहरण (Example):

def my_function():
    local_var = "मैं एक लोकल वेरिएबल हूँ"
    print(local_var)

my_function()
# print(local_var)  # यह त्रुटि उत्पन्न करेगा क्योंकि local_var लोकल स्कोप में है

आउटपुट:

मैं एक लोकल वेरिएबल हूँ

ग्लोबल स्कोप (Global Scope)

जब एक वेरिएबल फंक्शन के बाहर परिभाषित होता है, तो उसका स्कोप पूरे प्रोग्राम में होता है। इसे ग्लोबल वेरिएबल (Global Variable) कहा जाता है। ग्लोबल वेरिएबल्स को फंक्शंस के भीतर और बाहर दोनों जगह एक्सेस किया जा सकता है।

उदाहरण (Example):

global_var = "मैं एक ग्लोबल वेरिएबल हूँ"

def my_function():
    print(global_var)

my_function()
print(global_var)

आउटपुट:

मैं एक ग्लोबल वेरिएबल हूँ
मैं एक ग्लोबल वेरिएबल हूँ

ग्लोबल कीवर्ड (The global Keyword)

अगर आप फंक्शन के भीतर एक ग्लोबल वेरिएबल को संशोधित करना चाहते हैं, तो आपको global कीवर्ड का उपयोग करना होगा। यह बताता है कि वेरिएबल ग्लोबल स्कोप में है और इसे फंक्शन के भीतर संशोधित किया जा सकता है।

उदाहरण (Example):

global_var = "मूल मान"

def my_function():
    global global_var
    global_var = "संशोधित मान"
    print("फंक्शन के भीतर:", global_var)

my_function()
print("फंक्शन के बाहर:", global_var)

आउटपुट:

फंक्शन के भीतर: संशोधित मान
फंक्शन के बाहर: संशोधित मान

नेस्टेड फंक्शंस और एनक्लोजिंग स्कोप (Nested Functions and Enclosing Scope)
नेस्टेड फंक्शंस में, इनर फंक्शन आउटर फंक्शन के वेरिएबल्स को एक्सेस कर सकता है। इसे एनक्लोजिंग स्कोप (Enclosing Scope) कहा जाता है।

उदाहरण (Example):

def outer_function():
    enclosing_var = "मैं एनक्लोजिंग स्कोप में हूँ"

    def inner_function():
        print(enclosing_var)
    
    inner_function()

outer_function()

आउटपुट:

मैं एनक्लोजिंग स्कोप में हूँ

बिल्ट-इन स्कोप (Built-in Scope)

बिल्ट-इन स्कोप वह स्कोप है जिसमें पाइथन के सभी बिल्ट-इन फंक्शंस, एरर, और अन्य बिल्ट-इन ऑब्जेक्ट्स आते हैं। आप इन्हें सीधे उपयोग कर सकते हैं।

उदाहरण (Example):

print(len("पाइथन"))  # len() बिल्ट-इन फंक्शन है

आउटपुट:

6

स्कोप रेजोल्यूशन (Scope Resolution) – LEGB नियम

पाइथन में स्कोप रेजोल्यूशन LEGB (Local, Enclosing, Global, Built-in) नियम के अनुसार काम करता है:

1. Local: सबसे पहले लोकल स्कोप में खोजा जाता है।
2. Enclosing: फिर एनक्लोजिंग स्कोप में खोजा जाता है।
3. Global: उसके बाद ग्लोबल स्कोप में खोजा जाता है।
4. Built-in: अंत में बिल्ट-इन स्कोप में खोजा जाता है।

उदाहरण (Example):

global_var = "ग्लोबल स्कोप"

def outer_function():
    enclosing_var = "एनक्लोजिंग स्कोप"

    def inner_function():
        local_var = "लोकल स्कोप"
        print(local_var)
        print(enclosing_var)
        print(global_var)
    
    inner_function()

outer_function()

आउटपुट:

लोकल स्कोप
एनक्लोजिंग स्कोप
ग्लोबल स्कोप

नेस्टेड फंक्शंस (Nested Functions)

नेस्टेड फंक्शंस (Nested Functions) वे फंक्शंस होते हैं जो किसी अन्य फंक्शन के भीतर परिभाषित किए जाते हैं। नेस्टेड फंक्शंस का उपयोग अक्सर तब किया जाता है जब हमें फंक्शन के भीतर एक या अधिक कार्यों को संगठित और संक्षिप्त करना होता है। नेस्टेड फंक्शंस का उपयोग स्कोप और एन्कैप्सुलेशन को बेहतर बनाने के लिए भी किया जाता है।

सिंटैक्स (Syntax)

def outer_function():
    # आउटर फंक्शन का कोड

    def inner_function():
        # इनर फंक्शन का कोड

    # इनर फंक्शन को कॉल करें
    in

उदाहरण (Examples)

1. सरल नेस्टेड फंक्शन (Simple Nested Function)

   def greet(name):
       """आउटर फंक्शन जो एक इनर फंक्शन को परिभाषित करता है।"""
       
       def display_message():
           """इनर फंक्शन जो अभिवादन संदेश प्रिंट करता है।"""
           print(f"नमस्ते, {name}!")
       
       # इनर फंक्शन को कॉल करें
       display_message()
   
   greet("राम")
   

   आउटपुट:

   नमस्ते, राम!
   

    

2. नेस्टेड फंक्शंस के साथ एन्क्लोजिंग स्कोप (Nested Functions with Enclosing Scope)

   def outer_function():
       outer_var = "मैं आउटर फंक्शन का वेरिएबल हूँ"
       
       def inner_function():
           print(outer_var)
       
       inner_function()
   
   outer_function()
   

   आउटपुट:

   मैं आउटर फंक्शन का वेरिएबल हूँ
   

    

नेस्टेड फंक्शंस और क्लोज़र्स (Nested Functions and Closures)

जब एक नेस्टेड फंक्शन अपने आउटर फंक्शन के स्कोप में परिभाषित वेरिएबल्स को एक्सेस करता है, तो इसे क्लोज़र (Closure) कहा जाता है। क्लोज़र तब उपयोगी होते हैं जब आपको एक फंक्शन के भीतर की स्थिति (state) को बनाए रखना होता है।

उदाहरण (Example):

def outer_function(msg):
    """आउटर फंक्शन जो एक संदेश को अपने इनर फंक्शन के माध्यम से क्लोज़र के रूप में उपयोग करता है।"""
    
    def inner_function():
        print(msg)
    
    return inner_function

# आउटर फंक्शन को कॉल करें और उसका परिणाम एक वेरिएबल में स्टोर करें
closure_func = outer_function("नमस्ते, दुनिया!")

# क्लोज़र फंक्शन को कॉल करें
closure_func()

आउटपुट:

नमस्ते, दुनिया!

नेस्टेड फंक्शंस के साथ डेकोरेटर्स (Decorators with Nested Functions)

नेस्टेड फंक्शंस का उपयोग डेकोरेटर्स (Decorators) बनाने के लिए भी किया जा सकता है। डेकोरेटर्स फंक्शंस होते हैं जो अन्य फंक्शंस को संशोधित या विस्तारित करते हैं।

उदाहरण (Example):

def decorator_function(original_function):
    """डेकोरेटर फंक्शन जो एक फंक्शन को संशोधित करता है।"""
    
    def wrapper_function():
        print("Wrapper function executed before", original_function.__name__)
        return original_function()
    
    return wrapper_function

@decorator_function
def display():
    print("Display function executed.")

# डेकोरेटेड फंक्शन को कॉल करें
display()

आउटपुट:

Wrapper function executed before display
Display function executed.

नेस्टेड फंक्शंस के फायदे (Advantages of Nested Functions)

1. स्कोप का प्रबंधन (Scope Management): नेस्टेड फंक्शंस का उपयोग स्कोप को सीमित करने के लिए किया जाता है, जिससे वेरिएबल्स को अनावश्यक रूप से ग्लोबल स्कोप में प्रदूषित होने से रोका जा सकता है।
2. कोड का संगठन (Code Organization): नेस्टेड फंक्शंस का उपयोग करके, आप कोड को अधिक संगठित और संरचित बना सकते हैं, जिससे कोड की पठनीयता और समझ बढ़ती है।
3. एन्कैप्सुलेशन (Encapsulation): नेस्टेड फंक्शंस का उपयोग करके, आप कुछ कार्यों को एन्कैप्सुलेट कर सकते हैं, जिससे वे फंक्शन के बाहर से अप्राप्य होते हैं और केवल उसी फंक्शन के भीतर उपयोग किए जा सकते हैं।

उदाहरण: नेस्टेड फंक्शंस और क्लोज़र्स

उदाहरण (Example):

def make_multiplier_of(n):
    """यह फंक्शन एक नेस्टेड फंक्शन को परिभाषित करता है जो किसी संख्या को 'n' से गुणा करता है।"""
    
    def multiplier(x):
        return x * n
    
    return multiplier

# एक फंक्शन बनाएँ जो किसी संख्या को 3 से गुणा करता है
times3 = make_multiplier_of(3)

# एक फंक्शन बनाएँ जो किसी संख्या को 5 से गुणा करता है
times5 = make_multiplier_of(5)

print(times3(9))  # आउटपुट: 27
print(times5(9))  # आउटपुट: 45