ફંક્શન પરિમાણો અને ડિફોલ્ટ આર્ગ્યુમેન્ટ્સ કેવી રીતે કાર્ય કરે છે?

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 ડિઝાઇન કરવામાં આધાર આપે છે.