Jak fungují type hints a jaké jsou jejich přínosy?

Question

Accepted Answer

**Type hints** (PEP 484+) vám umožňují anotovat očekávané typy proměnných, parametrů funkcí a návratových hodnot. Jsou **volitelné** a **nejsou vynuceny za běhu** — Python je při spuštění ignoruje — ale umožňují static analysis, lepší nástroje a jasnější kód.

## Základní syntaxe

```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` anotuje parametry/proměnné a `-> type` návratovou hodnotu. Tyto dokumentují záměr a jsou kontrolovány nástroji, ale Python je **neupravuje za běhu** (předání nesprávného typu sám nevyvolá chybu).

## Běžné typing konstrukty

```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 zachytí chyby před spuštěním

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

Type checker jako **mypy** nebo **pyright** analyzuje hints a hlásí type errors *před* spuštěním kódu — zachytáním celé třídy chyb (špatné typy argumentů, zneužití None) brzy, jak by to dělal compiler.

## Přínosy

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

## Jsou volitelné a postupné

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

## Frameworks je využívají za běhu

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

Některé knihovny (Pydantic, FastAPI) čtou type hints k validaci dat a generování dokumentace — což je činí funkčně smysluplné za běhu.

## Proč na tom záleží

Type hints přinášejí mnoho výhod statického psaní do Pythonu bez oběti jeho dynamické flexibility: zachytávají chyby související s typy brzy (přes mypy/pyright), dramaticky zlepšují tooling IDE a refactoring, slouží jako živá dokumentace a pohánějí moderní frameworks (FastAPI, Pydantic), které je používají pro validaci a automaticky generovanou dokumentaci.

Přestože jsou volitelné a nejsou vynuceny samotným Pythonem za běhu, staly se standardem v profesionálních a rozsáhlých Python codebasech, protože činí kód spolehlivějším, lépe udržovatelným a samo-dokumentujícím se — stále více očekávaná praxe, zejména jak projekty rostou.