पाइथन फंक्शन (Python Functions) — Study Notes

1. परिचय

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

2. फंक्शन की आवश्यकता (Need of Functions)

• कोड पुनः उपयोग (Code Reusability): एक बार लिखे फंक्शन को कई बार कॉल किया जा सकता है।
• कोड दोहराव में कमी: एक ही कोड को बार-बार लिखने की आवश्यकता नहीं।
• पठनीयता (Readability): प्रोग्राम सुव्यवस्थित और समझने योग्य बनता है।
• मॉड्यूलरिटी (Modularity): बड़े प्रोग्राम को छोटे-छोटे फंक्शन में बाँटा जा सकता है।
• डिबगिंग में आसानी: त्रुटि वाले फंक्शन को अलग से ठीक किया जा सकता है।
• टीम कार्य में सहयोग: कई डेवलपर अलग-अलग फंक्शन पर काम कर सकते हैं।

3. फंक्शन की घोषणा और आह्वान (Defining and Calling a Function)

3.1 फंक्शन की घोषणा

पाइथन में फंक्शन def कीवर्ड से घोषित किया जाता है:

def नमस्कार():
    print("नमस्कार दोस्तों!")

• def फंक्शन घोषित करने का कीवर्ड है।
• फंक्शन का नाम (यहाँ नमस्कार) पहचानकर्ता है।
• कोष्ठक () के अंदर पैरामीटर आते हैं (यहाँ कोई नहीं)।
• कोलन : के बाद फंक्शन का बॉडी आता है, जिसमें इंडेंटेशन होता है।

3.2 फंक्शन का आह्वान (Calling)

फंक्शन के नाम के साथ कोष्ठक लगाकर उसे कॉल किया जाता है:

नमस्कार()

फंक्शन को बार-बार कॉल किया जा सकता है, और प्रत्येक कॉल पर उसका कोड निष्पादित होता है। केवल घोषणा से कोड नहीं चलता; कॉल करना आवश्यक है।

4. पैरामीटर और आर्ग्युमेंट (Parameters and Arguments)

• पैरामीटर (Parameter): फंक्शन घोषणा के कोष्ठक में लिखे गए चर।
• आर्ग्युमेंट (Argument): फंक्शन को कॉल करते समय दिए गए वास्तविक मान।

उदाहरण:

def योग(a, b):        # a, b पैरामीटर हैं
    print(a + b)

योग(5, 7)             # 5, 7 आर्ग्युमेंट हैं

यहाँ फंक्शन दो पैरामीटर लेता है और उनका योग प्रदर्शित करता है। पैरामीटर की संख्या और आर्ग्युमेंट की संख्या मेल खानी चाहिए, अन्यथा त्रुटि आएगी।

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

फंक्शन return स्टेटमेंट द्वारा परिणाम लौटा सकता है:

def वर्ग(x):
    return x * x

परिणाम = वर्ग(5)    # परिणाम = 25

• return फंक्शन से मान लौटाता है और फंक्शन समाप्त हो जाता है।
• return के बाद लिखा कोड निष्पादित नहीं होता।
• यदि फंक्शन में return नहीं है, तो वह None लौटाता है।
• return के माध्यम से लौटाया गया मान किसी चर में संग्रहीत किया जा सकता है।

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

पैरामीटर को डिफ़ॉल्ट मान देकर वैकल्पिक बनाया जा सकता है:

def परिचय(नाम, कक्षा="10वीं"):
    print(नाम, कक्षा)

परिचय("राहुल")             # राहुल 10वीं
परिचय("सीमा", "9वीं")       # सीमा 9वीं

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

7. आर्ग्युमेंट के प्रकार (Types of Arguments)

7.1 पोज़िशनल आर्ग्युमेंट (Positional Arguments)

आर्ग्युमेंट उसी क्रम में पैरामीटर को मिलते हैं जिस क्रम में दिए गए हों।

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

आर्ग्युमेंट को पैरामीटर के नाम के साथ दिया जाता है:

योग(b=7, a=5)   # क्रम की चिंता नहीं

7.3 डिफ़ॉल्ट आर्ग्युमेंट (Default Arguments)

जब पैरामीटर का डिफ़ॉल्ट मान हो, तो आर्ग्युमेंट वैकल्पिक हो जाता है।

8. स्थानीय और वैश्विक चर (Local and Global Variables)

8.1 स्थानीय चर (Local Variables)

फंक्शन के अंदर घोषित चर स्थानीय चर कहलाते हैं। इनका उपयोग केवल उसी फंक्शन के अंदर होता है और फंक्शन के समाप्त होने पर ये नष्ट हो जाते हैं।

8.2 वैश्विक चर (Global Variables)

फंक्शन के बाहर घोषित चर वैश्विक चर कहलाते हैं। इनका उपयोग प्रोग्राम के किसी भी भाग में किया जा सकता है।

8.3 global कीवर्ड

यदि किसी फंक्शन के अंदर वैश्विक चर के मान को बदलना हो, तो global कीवर्ड का उपयोग होता है:

मान = 10

def बदलो():
    global मान
    मान = 20

स्कोप का नियम

• फंक्शन के अंदर घोषित चर फंक्शन के बाहर उपलब्ध नहीं होता।
• फंक्शन के बाहर घोषित चर फंक्शन के अंदर पढ़ा जा सकता है।
• फंक्शन के अंदर वैश्विक चर के मान को बदलने के लिए global कीवर्ड आवश्यक है।

9. फंक्शन में डेटा प्रकार (Data Types in Functions)

फंक्शन विभिन्न प्रकार के डेटा (संख्या, स्ट्रिंग, सूची, शब्दकोश) को आर्ग्युमेंट के रूप में ले सकता है और लौटा सकता है। पाइथन डायनामिक टाइपिंग वाली भाषा है, इसलिए पैरामीटर का डेटा प्रकार घोषित करना आवश्यक नहीं है।

def औसत(सूची):
    return sum(सूची) / len(सूची)

यह फंक्शन एक सूची लेता है और उसकी औसत लौटाता है।

10. अंतर्निर्मित फंक्शन (Built-in Functions)

पाइथन में कई अंतर्निर्मित फंक्शन उपलब्ध हैं: - print(): आउटपुट दिखाना। - input(): इनपुट लेना। - len(): लंबाई ज्ञात करना। - type(): डेटा प्रकार जानना। - int(), float(), str(): प्रकार परिवर्तन। - sum(): योग। - min(), max(): न्यूनतम/अधिकतम। - abs(): निरपेक्ष मान। - range(): संख्या श्रेणी। - round(): गोल करना।

त्वरित पुनरावृत्ति तालिकाएँ

तालिका 1: फंक्शन की शब्दावली

शब्द	अर्थ
def	फंक्शन घोषणा का कीवर्ड
पैरामीटर	घोषणा में चर
आर्ग्युमेंट	कॉल के समय मान
return	परिणाम लौटाना
body	फंक्शन का कोड ब्लॉक
call	फंक्शन का आह्वान

तालिका 2: चर के प्रकार

चर	घोषणा स्थान	उपयोग क्षेत्र
स्थानीय	फंक्शन के अंदर	केवल उसी फंक्शन में
वैश्विक	फंक्शन के बाहर	पूरे प्रोग्राम में
global कीवर्ड	फंक्शन में	वैश्विक चर बदलना

तालिका 3: आर्ग्युमेंट के प्रकार

प्रकार	विवरण
पोज़िशनल	क्रम से मिलान
कीवर्ड	नाम से मिलान
डिफ़ॉल्ट	वैकल्पिक मान

माइंड मैप

graph TD
    A["पाइथन फंक्शन"] --> B["घोषणा"]
    B --> B1["def कीवर्ड"]
    B --> B2["फंक्शन नाम"]
    A --> C["पैरामीटर और आर्ग्युमेंट"]
    C --> C1["पोज़िशनल"]
    C --> C2["कीवर्ड"]
    C --> C3["डिफ़ॉल्ट"]
    A --> D["return"]
    D --> D1["मान लौटाना"]
    A --> E["चर का स्कोप"]
    E --> E1["स्थानीय"]
    E --> E2["वैश्विक"]
    A --> F["अंतर्निर्मित फंक्शन"]
    F --> F1["print, input, len"]

महत्वपूर्ण आरेख (SVG)

फंक्शन का कार्य प्रवाह

स्थानीय और वैश्विक चर

सामान्य गलतियाँ

1. फंक्शन को घोषित करना परंतु कॉल करना भूलना; केवल घोषणा से कोड नहीं चलता।
2. पैरामीटर की संख्या से कम या अधिक आर्ग्युमेंट देना, जिससे त्रुटि आती है।
3. return के बाद कोड लिखना; return के बाद का कोड कभी निष्पादित नहीं होता।
4. फंक्शन के अंदर स्थानीय चर को बाहर उपयोग करने का प्रयास, जो त्रुटि देता है।
5. फंक्शन नाम में स्थान या संख्या से आरंभ करना।
6. def के बाद कोलन (:) न लगाना या बॉडी में इंडेंटेशन न करना।
7. return और print में भ्रम; return मान लौटाता है जबकि print केवल प्रदर्शित करता है।
8. डिफ़ॉल्ट मान वाले पैरामीटर को गलत क्रम में (बिना डिफ़ॉल्ट वाले से पहले) लिखना।

परीक्षा युक्तियाँ

1. def फंक्शन का पूरा प्रोग्राम लिखने का अभ्यास करें (घोषणा से लेकर कॉल तक)।
2. पैरामीटर और आर्ग्युमेंट के बीच अंतर को स्पष्ट रूप से समझें।
3. return वाले फंक्शन के आउटपुट आधारित प्रश्नों का अभ्यास करें।
4. स्थानीय और वैश्विक चर के स्कोप के प्रश्न हल करें।
5. डिफ़ॉल्ट पैरामीटर के व्यवहार (बिना आर्ग्युमेंट वाले कॉल पर डिफ़ॉल्ट मान प्रयोग) जानें।
6. अंतर्निर्मित फंक्शन (len, sum, type, int) के उपयोग याद रखें।
7. आउटपुट प्रश्नों में कोड को मानसिक रूप से लाइन-दर-लाइन चलाएँ।

निष्कर्ष

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