ఫంక్షన్ పారామితులు మరియు డిఫాల్ట్ ఆర్గ్యుమెంట్‌లు ఎలా పనిచేస్తాయి?

Question

Accepted Answer

Python ఫంక్షన్‌లు **positional** మరియు **keyword** ఆర్గ్యుమెంట్‌లు, మరియు **default values** ను సపోర్ట్ చేస్తాయి. అవి ఎలా కలిసి పనిచేస్తాయనేది అర్థం చేసుకోవడం — మరియు ఒక ప్రసిద్ధ default-argument బేసికరణ — ఆవశ్యకమైనది.

## Positional, keyword, మరియు default ఆర్గ్యుమెంట్‌లు

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

డిఫాల్ట్ కలిగిన పారామితులు ఐచ్ఛికమైనవి; మీరు ఆర్గ్యుమెంట్‌లను స్థానం ద్వారా లేదా పేరు ద్వారా పంపవచ్చు (keyword ఆర్గ్యుమెంట్‌లు పठనీయతను మెరుగుపరుస్తాయి మరియు మీకు ముందుగా ఐచ్ఛిక పారామితులను దాటవేయడానికి అనుమతిస్తాయి).

## ప్రసిద్ధ సమస్య: మార్పులేని default ఆర్గ్యుమెంట్‌లు

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

డిఫాల్ట్ విలువలు ఫంక్షన్ నిర్వచించినప్పుడు **ఒక్కసారి** మూల్యాంకనం చేయబడతాయి, ప్రతి కాల్‌కు కాదు. ఒక మార్పులేని డిఫాల్ట్ (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
    ...
```

chip `*` మరియు `/` మీకు ఆర్గ్యుమెంట్‌లు ఎలా పంపబడతాయో కట్టుబడుటకు అనుమతిస్తాయి — స్పష్టమైన, నిలకడైన API ల కోసం ఉపయోగకరమైనది.

## ఇది ఎందుకు ముఖ్యమైనది

పారామితి నిర్వహణ అర్థం చేసుకోవడం Python ఫంక్షన్‌లను సరిగా రాయడానికి మరియు పిలవడానికి ప్రాథమికమైనది.

డిఫాల్ట్‌లు ఫంక్షన్‌లను సరళంగా చేస్తాయి, మరియు keyword ఆర్గ్యుమెంట్‌లు కాల్‌లను స్వయం-డాక్యుమెంటింగ్ చేస్తాయి.

క్రూషియల్‌గా, **mutable-default-argument విషం** Python యొక్క అత్యంత సాధారణ మరియు గందరగోళమైన బగ్‌లలో ఒకటి — డిఫాల్ట్‌లు ఒక్కసారి మూల్యాంకనం చేయబడతాయని తెలుసుకోవడం (కాబట్టి మార్పులేని డిఫాల్ట్‌లు కాల్‌ల మధ్య కొనసాగుతాయి) మరియు `None`-sentinel తీర్పు సూక్ష్మ లోపాల యొక్క సંపూర్ణ తరగతిని నిరోధిస్తుంది.

ఈ జ్ఞానం స్చ్ఛ, ఊహించదగిన ఫంక్షన్ API ల రూపకల్పన చేయడానికి సహాయపడుతుంది.