ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ ਅਤੇ ਡਿਫਾਲਟ ਆਰਗੂਮੈਂਟ ਕਿਵੇਂ ਕਾਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

Python ਫੰਕਸ਼ਨ **positional** ਅਤੇ **keyword** ਆਰਗੂਮੈਂਟ ਸਮਰਥਨ ਕਰਦੇ ਹਨ, ਨਾਲ ਹੀ **default values** ਵੀ। ਇਹ ਸਮਝਣਾ ਕਿ ਉਹ ਕਿਵੇਂ ਇਕੱਠੇ ਕਾਮ ਕਰਦੇ ਹਨ — ਅਤੇ ਇੱਕ ਮਸ਼ਹੂਰ default-argument ਸਮੱਸਿਆ — ਜ਼ਰੂਰੀ ਹੈ।

## Positional, keyword, ਅਤੇ default arguments

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

Default ਮੁੱਲ ਵਾਲੇ Parameters ਵਿਕਲਪਿਕ ਹੁੰਦੇ ਹਨ؛ ਤੁਸੀਂ arguments ਨੂੰ position ਦੁਆਰਾ ਜਾਂ name ਦੁਆਰਾ (keyword args) ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ। Keyword args readability ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦੇ ਹਨ ਅਤੇ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਦੇ optional params ਨੂੰ ਛੱਡ ਦਿਵਾਉਂਦੇ ਹਨ।

## ਮਸ਼ਹੂਰ ਸਮੱਸਿਆ: mutable default arguments

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

Default ਮੁੱਲ **ਇੱਕ ਵਾਰ** evaluate ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਫੰਕਸ਼ਨ define ਹੁੰਦਾ ਹੈ, ਹਰੇਕ call ਤੇ ਨਹੀਂ। ਇੱਕ mutable default (list/dict) ਇਸ ਲਈ calls ਦੇ ਵਿਚਕਾਰ ਸਾਝਾ ਹੁੰਦਾ ਹੈ — ਇੱਕ ਕਲਾਸਿਕ bug। Fix:

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

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

`*` ਅਤੇ `/` markers ਤੁਹਾਨੂੰ enforce ਕਰਨ ਦਿੰਦੇ ਹਨ ਕਿ arguments ਕਿਵੇਂ pass ਹੁੰਦੇ ਹਨ — ਸਪੱਸ਼ਟ, ਸਥਿਰ APIs ਲਈ ਲਾਭਦਾਇਕ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰਖਦਾ ਹੈ

Parameter handling ਨੂੰ ਸਮਝਣਾ Python functions ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ likhne ਅਤੇ call ਕਰਨ ਲਈ ਮੌਲਿਕ ਹੈ।

Defaults functions ਨੂੰ likhne ਲਈ flexible ਬਣਾਉਂਦੇ ਹਨ, ਅਤੇ keyword arguments calls ਨੂੰ self-documenting ਬਣਾਉਂਦੇ ਹਨ।

ਮਹੱਤਵਪੂਰਨ ਤਰੀਕੇ ਨਾਲ, **mutable-default-argument trap** Python ਦੀਆਂ ਸਭ ਤੋਂ ਆਮ ਅਤੇ ਉਲਝੀਆਂ bugs ਵਿੱਚੋਂ ਇੱਕ ਹੈ — ਇਹ ਜਾਣਨਾ ਕਿ defaults ਇੱਕ ਵਾਰ evaluate ਹੁੰਦੇ ਹਨ (ਇਸ ਲਈ mutable defaults calls ਦੇ ਵਿਚਕਾਰ persist ਕਰਦੇ ਹਨ) ਅਤੇ `None`-sentinel fix subtle errors ਦੀ ਪੂਰੀ ਸ਼੍ਰੇਣੀ ਨੂੰ روکتا ہے।

ਇਹ ਗਿਆਨ ਸਾਫ਼, ਅਨੁਮਾਨਯੋਗ function APIs ਨੂੰ ਡਿਜਾਈਨ ਕਰਨ ਨੂੰ ਅਧਾਰ ਦਿੰਦਾ ਹੈ।