type hints எவ்வாறு செயல்படுகின்றன மற்றும் அவற்றின் நன்மைகள் என்ன?

Question

Accepted Answer

**Type hints** (PEP 484+) variables, function parameters, மற்றும் return values-இன் எதிர்பார்க்கப்படும் types-ஐ annotate செய்ய அனுமதிக்கின்றன. அவை **விருப்பத்தேர்வு** மற்றும் **runtime-இல் கட்டாயப்படுத்தப்படுவதில்லை** — இயங்கும்போது Python அவற்றைப் புறக்கணிக்கிறது — ஆனால் அவை static analysis, சிறந்த tooling, மற்றும் தெளிவான code-ஐ செயல்படுத்துகின்றன.

## அடிப்படை syntax

```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` parameters/variables-ஐ annotate செய்கிறது மற்றும் `-> type` return-ஐ. இவை நோக்கத்தை documentation செய்கின்றன மற்றும் tools-ஆல் சரிபார்க்கப்படுகின்றன, ஆனால் Python அவற்றை runtime-இல் கட்டாயப்படுத்த **இல்லை** (தவறான type-ஐ அனுப்புவது தானாக raise செய்யாது).

## பொதுவான typing constructs

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

## Static type checking runtime-க்கு முன் bugs-ஐ பிடிக்கிறது

```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 hints-ஐ analyze செய்து code-ஐ இயக்குவதற்கு *முன்* type errors-ஐ அறிக்கை செய்கிறது — ஒரு compiler போல, முழு bugs வகுப்பையும் (தவறான argument types, 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.
```

## Frameworks அவற்றை runtime-இல் பயன்படுத்துகின்றன

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

சில libraries (Pydantic, FastAPI) data-ஐ validate செய்யவும் docs உருவாக்கவும் type hints-ஐ படிக்கின்றன — அவற்றை runtime-இல் செயல்பாட்டு ரீதியாக அர்த்தமுள்ளதாக ஆக்குகின்றன.

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

Type hints Python-இன் dynamic நெகிழ்வுத்தன்மையை தியாகம் செய்யாமல் static typing-இன் பல நன்மைகளை கொண்டுவருகின்றன: அவை type-தொடர்பான bugs-ஐ ஆரம்பத்தில் பிடிக்கின்றன (mypy/pyright வழியாக), IDE tooling மற்றும் refactoring-ஐ வியத்தகு வகையில் மேம்படுத்துகின்றன, உயிருள்ள documentation-ஆக செயல்படுகின்றன, மற்றும் அவற்றை validation மற்றும் auto-generated docs-க்கு பயன்படுத்தும் நவீன frameworks-ஐ (FastAPI, Pydantic) இயக்குகின்றன.

விருப்பத்தேர்வு மற்றும் Python-ஆல் runtime-கட்டாயப்படுத்தப்படாதவை என்றாலும், அவை code-ஐ மிகவும் நம்பகமான, பராமரிக்கக்கூடிய, மற்றும் self-documenting ஆக்குவதால் தொழில்முறை மற்றும் பெரிய-அளவிலான Python codebases-இல் நிலையானதாகிவிட்டன — projects வளரும்போது குறிப்பாக, பெருகிய முறையில் எதிர்பார்க்கப்படும் ஒரு நடைமுறை.