फ़ंक्शन पैरामीटर और डिफ़ॉल्ट आर्गुमेंट कैसे काम करते हैं?

Question

Accepted Answer

Python फ़ंक्शन **पोजीशनल** और **कीवर्ड** आर्गुमेंट, साथ ही **डिफ़ॉल्ट वैल्यूज** को सपोर्ट करते हैं। यह समझना कि वे कैसे संयुक्त होते हैं — और एक प्रसिद्ध डिफ़ॉल्ट-आर्गुमेंट समस्या — आवश्यक है।

## पोजीशनल, कीवर्ड, और डिफ़ॉल्ट आर्गुमेंट

```python
def greet(name, greeting="Hello", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

greet("Ann")                          # positional → "Hello, Ann!"
greet("Ann", "Hi")                    # "Hi, Ann!"
greet("Ann", punctuation=".")          # keyword arg → "Hello, Ann."
greet(name="Ann", greeting="Hey")      # all by keyword
```

डिफ़ॉल्ट वाले पैरामीटर वैकल्पिक हैं; आप आर्गुमेंट को पोजीशन द्वारा या नाम द्वारा पास कर सकते हैं (कीवर्ड आर्गुमेंट पठनीयता में सुधार करते हैं और आपको पहले के वैकल्पिक पैरामीटर को छोड़ने देते हैं)।

## प्रसिद्ध समस्या: बदलने योग्य डिफ़ॉल्ट आर्गुमेंट

```python
# ❌ DANGER — the default list is created ONCE and SHARED across all calls
def add_item(item, items=[]):
    items.append(item)
    return items

add_item("a")   # ["a"]
add_item("b")   # ["a", "b"]  ← surprise! the SAME list persisted
```

डिफ़ॉल्ट वैल्यूज **एक बार** मूल्यांकन की जाती हैं जब फ़ंक्शन परिभाषित होता है, प्रत्येक कॉल पर नहीं। एक बदलने योग्य डिफ़ॉल्ट (सूची/डिक्ट) इसलिए कॉल के बीच साझा किया जाता है — एक क्लासिक बग। समाधान:

```python
# ✅ use None as the default and create a fresh object inside
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items
```

## कीवर्ड-केवल और पोजीशनल-केवल पैरामीटर

```python
def f(a, b, *, key):       # `*` → `key` MUST be passed by keyword
    ...
f(1, 2, key=3)             # ✅   f(1, 2, 3) ❌

def g(a, b, /, c):         # `/` → a, b MUST be positional
    ...
```

`*` और `/` मार्कर आपको यह लागू करने देते हैं कि आर्गुमेंट कैसे पास किए जाते हैं — स्पष्ट, स्थिर APIs के लिए उपयोगी।

## यह महत्वपूर्ण क्यों है

Python फ़ंक्शन को सही तरीके से लिखने और कॉल करने के लिए पैरामीटर हैंडलिंग को समझना मौलिक है।

डिफ़ॉल्ट फ़ंक्शन को लचकदार बनाते हैं, और कीवर्ड आर्गुमेंट कॉल को स्व-दस्तावेज़ बनाते हैं।

मुख्य रूप से, **बदलने योग्य-डिफ़ॉल्ट-आर्गुमेंट जाल** Python की सबसे सामान्य और भ्रामक बग में से एक है — जानना कि डिफ़ॉल्ट एक बार मूल्यांकन किए जाते हैं (इसलिए बदलने योग्य डिफ़ॉल्ट कॉल के बीच बने रहते हैं) और `None`-सेंटिनल फिक्स सूक्ष्म त्रुटियों की एक पूरी कक्षा को रोकता है।

यह ज्ञान स्वच्छ, अनुमानित फ़ंक्शन APIs डिज़ाइन करने का आधार है।