செயல்பாட்டு அளவுருக்கள் மற்றும் இயல்புநிலை வாதங்கள் எவ்வாறு செயல்படுகின்றன?

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

Default மதிப்புக்கள் செயல்பாட்டை வரையறுக்கும் போது **ஒரு முறை** மதிப்பிடப்படுகின்றன, ஒவ்வொரு அழைப்பு சமயமும் அல்ல. ஒரு மாறக்கூடிய default (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
    ...
```

markers `*` மற்றும் `/` வாதங்கள் எவ்வாறு அனுப்பப்படுகின்றன என்பதை கட்டாயப்படுத்த அனுமதிக்கின்றன — தெளிவான, நிலையான API களுக்கு பயனுள்ளதாக இருக்கிறது.

## இது ஏன் முக்கியமானது

அளவுரு கையாளுதலைப் புரிந்துகொள்ளுதல் Python செயல்பாடுகளை சரிசெய்து அழைப்பது அடிப்படைக்குரியது.

Defaults செயல்பாடுகளை நমनीயமாக்குகிறது, மற்றும் keyword வாதங்கள் அழைப்புகளை சுய-ஆவணமாக்குகிறது।

কার్यकরী, **mutable-default-argument함정** Python இன் மிகவும் பொதுவான மற்றும் குழப்புவதாக இருக்கும் பிழைகளில் ஒன்றாகும் — default மதிப்புக்கள் ஒரு முறை மதிப்பிடப்படுகின்றன என்பதை அறிவுறுத்துதல் (ஆகவே மாறக்கூடிய defaults அழைப்புகளுக்கு இடையே நிலைத்திருக்கிறது) மற்றும் `None`-sentinel தீர்வு நுண்ணிய பிழைகளின் முழு வகுப்பையும் தடுக்கிறது।

இந்த அறிவு சுத்தமான, கணிக்கத்தக்க செயல்பாட்டு API களை வடிவமைப்பதை ஆதரிக்கிறது.