फंक्शन पॅरामीटर आणि डिफॉल्ट आर्गुमेंट कसे काम करतात?

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

डिफॉल्ट्स असलेले पॅरामीटर पर्यायी आहेत; तुम्ही आर्गुमेंट position द्वारे किंवा नाव द्वारे पास करू शकता (keyword args वाचनीयता सुधारतात आणि तुम्हाला आधीचे पर्यायी पॅरामीटर स्किप करू देतात).

## प्रसिद्ध गोतिबिडा: 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 डिफॉल्ट (list/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
    ...
```

`*` आणि `/` मार्कर तुम्हाला आर्गुमेंट कसे पास केले जातात हे लागू करू देतात — स्पष्ट, स्थिर API साठी उपयोगी.

## हे का महत्वाचे आहे

Python फंक्शन्स बरोबर लिहिणे आणि कॉल करण्याचे मूलभूत आवश्यक आहे.

डिफॉल्ट्स फंक्शन्स लवचिक बनवतात, आणि keyword आर्गुमेंट कॉल्स self-documenting बनवतात.

महत्वाचे म्हणजे, **mutable-default-argument trap** Python चा सर्वात सामान्य आणि गोंधळात टाकणारा बग आहे — हे जाणून घेऊन की डिफॉल्ट्स एक वेळ मूल्यांकित केले जातात (त्यामुळे mutable डिफॉल्ट्स कॉल्स भोवती राहतात) आणि `None`-sentinel फिक्स सूक्ष्म त्रुटींचा संपूर्ण वर्ग रोखते.

ही ज्ञान स्वच्छ, अचूक फंक्शन API डिजाइन करण्यासाठी आधार आहे.