ਟਾਈਪ ਹਿੰਟਸ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਫਾਇਦੇ ਕੀ ਹਨ?

Question

Accepted Answer

**Type hints** (PEP 484+) ਤੁਹਾਨੂੰ ਵੇਰੀਏਬਲਜ਼, ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰਜ਼, ਅਤੇ ਰਿਟਰਨ ਵੈਲੀਜ਼ ਦੀ ਸੰਭਾਵੀ ਕਿਸਮ ਨੂੰ ਐਨੋਟੇਟ ਕਰਨ ਦਿੰਦੇ ਹਨ। ਇਹ **ਚੋਣਿਕ** ਹਨ ਅਤੇ **ਰਨਟਾਈਮ 'ਤੇ ਲਾਗੂ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ** — Python ਚਲਦੇ ਸਮੇਂ ਉਨ੍ਹਾਂ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰਦਾ ਹੈ — ਪਰ ਇਹ static ਵਿਸ਼ਲੇਸ਼ਣ, ਬਿਹਤਰ ਟੂਲਿੰਗ, ਅਤੇ ਵਧੇਰੇ ਸਪਸ਼ਟ ਕੋਡ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਨ।

## ਬੁਨਿਆਦੀ ਸਿੰਟੈਕਸ

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

## Static type ਚੈਕਿੰਗ ਰਨਟਾਈਮ ਤੋਂ ਪਹਿਲਾਂ ਬੱਗਸ ਫੜਦੀ ਹੈ

```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 ਸੁਝਾਵਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ ਅਤੇ type ਤਰੁੱਟੀਆਂ ਦੀ ਖ਼ਬਰ ਦਿੰਦਾ ਹੈ *ਕੋਡ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ* — ਬਗਸ ਦੀ ਪੂਰੀ ਸ਼੍ਰੇਣੀ (ਗਲਤ ਆਰਗੁਮੈਂਟ ਕਿਸਮਾਂ, 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 ਵਿੱਚ static typing ਦੇ ਬਹੁਤ ਸਾਰੇ ਫਾਇਦੇ ਲਿਆਉਂਦੇ ਹਨ ਇਸਦੀ dynamic ਸੁਤੰਤਰਤਾ ਨੂੰ ਕੁਰਬਾਨ ਕੀਤੇ ਬਗੈਰ: ਇਹ type ਨਾਲ ਸੰਬੰਧਤ ਬੱਗਸ ਨੂੰ ਜਲਦੀ ਫੜਦੇ ਹਨ (mypy/pyright ਦੁਆਰਾ), IDE ਟੂਲਿੰਗ ਅਤੇ refactoring ਨੂੰ ਬਹੁਤ ਬਿਹਤਰ ਬਣਾਉਂਦੇ ਹਨ, ਜੀਵੰਤ ਦਸਤਾਵੇਜ਼ੀਕਰਣ ਵਜੋਂ ਕੰਮ ਕਰਦੇ ਹਨ, ਅਤੇ ਆਧੁਨਿਕ ਫ੍ਰੇਮਵਰਕਸ (FastAPI, Pydantic) ਨੂੰ ਸ਼ਕਤੀ ਦਿੰਦੇ ਹਨ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ validation ਅਤੇ auto-generated docs ਲਈ ਵਰਤਦੇ ਹਨ।

ਹਾਲਾਂਕਿ ਚੋਣਿਕ ਅਤੇ Python ਆਪਣੇ ਆਪ ਦੁਆਰਾ ਰਨਟਾਈਮ 'ਤੇ ਲਾਗੂ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ, ਪੇਸ਼ੇਵਰ ਅਤੇ ਵੱਡੇ ਪੈਮਾਨੇ ਦੇ Python codebases ਵਿੱਚ ਇਹ ਮਾਨਕ ਬਣ ਗਏ ਹਨ ਕਿਉਂਕਿ ਇਹ ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਭਰੋਸੇਮੰਦ, ਬਰਕਰਾਰ ਰੱਖਣ ਯੋਗ, ਅਤੇ ਸਵੈ-ਦਸਤਾਵੇਜ਼ ਬਣਾਉਂਦੇ ਹਨ — ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਜਿਵੇਂ ਪ੍ਰੋਜੈਕਟਸ ਵੱਡੇ ਹੋ ਜਾਂਦੇ ਹਨ, ਇੱਕ ਉਮੀਦ ਕੀਤੀ ਵਿਵਹਾਰ।