Kaip veikia tipo žymos ir kokios jų naudos?

Question

IT Interview Practice · Accepted Answer

**Tipo žymos** (PEP 484+) leidžia anotsuoti tikėtinus kintamųjų, funkcijų parametrų ir grąžinamų reikšmių tipus. Jos yra **neprivaliomos** ir **neprivalomi vykdymo metu** — Python jas ignoros vykdydamas — tačiau jos suteikia galimybę statinei analizei, geresniam įrankių palaikymui ir aiškesniam kodui.

## Pagrindinė sintaksė

```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` anotsuoja parametrus/kintamuosius ir `-> type` grąžinamą reikšmę. Jos dokumentuoja ketinimą ir yra tikrinamos įrankių, tačiau Python **neprivalomas** jų vykdymo metu (neteisingą tipą perduodant nesudarys klaidą automatiškai).

## Dažnos tipo skonstrukcijos

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

## Statinis tipo tikrinimas aptinka klaidas prieš vykdymą

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

Tipo tikrintuvas tokis kaip **mypy** arba **pyright** analizuoja žymas ir praneša apie tipo klaidas *prieš* vykdant kodą — aptinkant visa klasę klaidų (neteisingų argumento tipų, None netinkamo panaudojimo) anksti, kaip tai darytų kompiliatorius.

## Naudos

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

## Jos yra neprivaliomos ir laipsniškas

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

## Sistemų darbai juos naudoja vykdymo metu

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

Kai kurios bibliotekos (Pydantic, FastAPI) skaito tipo žymas norėdamos patikrinti duomenis ir generuoti dokumentaciją — dėl to jos tampa funkcionaliai reikšmingos vykdymo metu.

## Kodėl tai svarbu

Tipo žymos Python'ui atneša daug statinio tipizavimo naudos neprarasdamos jos dinaminės lankstumo: jos aptinka su tipais susijusias klaidas anksti (per mypy/pyright), dramatiškai gerina IDE įrankius ir refaktoravimą, tarnauja kaip gyvoji dokumentacija ir suteikia galias šiuolaikiniams sistemams (FastAPI, Pydantic), kurie jas naudoja duomenų validacijai ir automatiškai generuotai dokumentacijai.

Nors neprivaliomos ir neprivaliomos Python'o paties vykdymo metu, jos tapo standartu profesiniu ir didelio masto Python'o kodo bazėse, nes daro kodą patikimesnį, lengviau prižiūrimą ir savidokumentavusį — vis dažniau tikėtasi praktiką, ypač kai projektai auga.

Pagrindinė sintaksė

Dažnos tipo skonstrukcijos

Statinis tipo tikrinimas aptinka klaidas prieš vykdymą

Naudos

Jos yra neprivaliomos ir laipsniškas

Sistemų darbai juos naudoja vykdymo metu

Kodėl tai svarbu

Susiję klausimai