फंक्शन प्यारामिटर र डिफल्ट आर्गुमेन्ट कसरी काम गर्छन्?

Question

Accepted Answer

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

## Positional, keyword, र डिफल्ट आर्गुमेन्ट

```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
```

डिफल्टहरू भएका प्यारामिटरहरू वैकल्पिक हुन्छन्; तपाईं आर्गुमेन्टहरू स्थिति अनुसार वा नाम अनुसार (नाम अनुसार आर्गुमेन्ट पठनीयता सुधार गर्छन् र तपाईंलाई पहिलेका वैकल्पिक प्यारामिटरहरू छोड्न दिन्छन्) पास गर्न सक्नुहुन्छ।

## प्रसिद्ध समस्या: mutable डिफल्ट आर्गुमेन्ट

```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
```

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

```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
```

## Keyword-only र positional-only प्यारामिटरहरू

```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 फंक्शनहरू सही तरीकाले लेख्न र कल गर्न आवश्यक छ।

डिफल्टहरूले फंक्शनहरूलाई लचकदार बनाउँछन्, र नाम अनुसार आर्गुमेन्टहरूले कलहरूलाई self-documenting बनाउँछन्।

मुख्य रूपमा, **mutable-डिफल्ट-आर्गुमेन्ट ट्र्याप** Python को सबैभन्दा सामान्य र भ्रमकारी बग हो — डिफल्टहरू एक पटक मूल्यांकन गरिन्छन् (त्यसैले mutable डिफल्टहरू कलहरूको बीचमा रहन्छन्) र `None`-sentinel फिक्स सूक्ष्म त्रुटिहरूको सम्पूर्ण वर्ग रोक्छ भन्ने कुरा थाह पाएर।

यो ज्ञान स्वच्छ, पूर्वानुमानयोग्य फंक्शन API डिजाइन गर्न आधारभूत छ।