टाइप हिन्टस कसरी काम गर्छन् र तिनका लाभहरू के हुन्?

Question

Accepted Answer

**Type hints** (PEP 484+) ले तपाइंलाई चर, फङ्क्शन प्यारामिटर र रिटर्न मानहरूको अपेक्षित प्रकारहरू एनोटेट गर्न दिन्छ। तिनीहरू **वैकल्पिक** र **रनटाइममा लागू गरिएका छैनन्** — Python तिनलाई चलाउँदा बेवास्ता गर्छ — तर तिनीहरू स्थिर विश्लेषण, उत्तम उपकरण र स्पष्टतर कोड सक्षम गर्छन्।

## आधारभूत सिन्ट्याक्स

```python
def greet(name: str, times: int = 1) -> str:
    return name * times

age: int = 30
names: list[str] = ["Ann", "Bob"]
scores: dict[str, int] = {"math": 90}
```

`: type` ले प्यारामिटर/चरहरू एनोटेट गर्छ र `-> type` ले रिटर्न गर्छ। यिनीहरूले अभिप्राय दस्तावेज गर्छन् र उपकरणहरूद्वारा जाँच गरिन्छन्, तर Python ले तिनलाई रनटाइममा **लागू गर्दैन** (गलत प्रकार पास गर्नले आफैं बढाउने छैन)।

## सामान्य typing संरचनाहरू

```python
from typing import Optional, Union, Callable, Any

def find(id: int) -> Optional[str]:    # str OR None (= str | None in 3.10+)
    ...

x: int | str                           # Union (3.10+ syntax)
handler: Callable[[int], bool]         # a function taking int, returning bool
items: list[dict[str, int]]            # nested generics
```

## स्थिर प्रकार जाँच रनटाइमभन्दा पहिले त्रुटिहरू समात्छ

```python
def add(a: int, b: int) -> int:
    return a + b

add("hello", 3)   # ✅ Python runs it (and crashes); ❌ mypy/pyright flags it BEFORE running
```

**mypy** वा **pyright** जस्तो type checker ले संकेतहरू विश्लेषण गर्छ र तपाइंले कोड चलाउनु अघि टाइप त्रुटिहरू रिपोर्ट गर्छ — गलत आर्गुमेन्ट प्रकार, None दुरुपयोग जस्तो त्रुटिहरूको पूरो वर्ग समात्छ, कम्पाइलर जस्तै।

## लाभहरू

```text
✓ Catch type bugs early via static checkers (mypy, pyright) — before runtime
✓ IDE support — better autocomplete, refactoring, inline error detection
✓ Self-documenting code — signatures show exactly what's expected/returned
✓ Powers frameworks — FastAPI/Pydantic USE hints for validation & docs
✓ Easier maintenance of large codebases (catch breaking changes)
```

## तिनीहरू वैकल्पिक र क्रमिक हुन्

```text
You can add hints incrementally — a few functions, or strictly everywhere.
Unannotated code still works. "Gradual typing" suits adopting them over time.
```

## ढाँचाहरूले तिनलाई रनटाइममा लाभ उठाउँछन्

```python
from pydantic import BaseModel
class User(BaseModel):
    name: str
    age: int            # Pydantic USES the hint to VALIDATE data at runtime
User(name="Ann", age="x")   # raises a validation error
```

केही लाइब्रेरीहरू (Pydantic, FastAPI) type संकेतहरू पढ्छन् डेटा प्रमाणित गर्न र दस्तावेज उत्पन्न गर्न — तिनलाई रनटाइममा कार्यात्मक रूपमा अर्थपूर्ण बनाइन्छ।

## यो किन महत्वपूर्ण छ

Type hints ले Python मा स्थिर टाइपिङको धेरै लाभ आनन्छ यसको गतिशील लचकता बिना: तिनीहरू प्रकार-सम्बन्धी त्रुटिहरू प्रारम्भिकमा समात्छन् (mypy/pyright को माध्यमबाट), IDE उपकरण र रिफ्याक्टरिङ नाटकीय रूपमा सुधार गर्छन्, जीवन्त दस्तावेज हिसाबमा काम गर्छन्, र आधुनिक ढाँचाहरू (FastAPI, Pydantic) शक्तिशाली बनाउँछन् जो प्रमाणीकरण र अटो-उत्पन्न दस्तावेजको लागि तिनलाई प्रयोग गर्छन्।

भने वैकल्पिक र Python आफैले रनटाइम-लागू गरिएका छैनन्, तिनीहरू पेशेदार र बृहत् पैमाणमा Python codebases मा मानक बन्न गएका छन् किनभने तिनीहरू कोडलाई अधिक विश्वस्त, रखरखाव योग्य र आत्म-दस्तावेज बनाउँछन् — बढ्दो एक अपेक्षित अभ्यास, विशेष गरी परियोजनाहरू वृद्धि हुँदा।