Bagaimana petunjuk tipe bekerja dan apa manfaatnya?

Question

Accepted Answer

**Type hints** (PEP 484+) memungkinkan Anda memberi anotasi tipe yang diharapkan dari variabel, parameter fungsi, dan nilai pengembalian. Mereka **opsional** dan **tidak diterapkan saat runtime** — Python mengabaikannya saat menjalankan — tetapi mereka memungkinkan analisis statis, perkakas yang lebih baik, dan kode yang lebih jelas.

## Sintaks dasar

```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` memberi anotasi parameter/variabel dan `-> type` mengembalikan. Ini mendokumentasikan niat dan diperiksa oleh alat, tetapi Python **tidak** menerapkannya saat runtime (melewatkan tipe yang salah tidak akan melempar kesalahan dengan sendirinya).

## Konstruksi pengetikan umum

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

## Pemeriksaan tipe statis menangkap bug sebelum runtime

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

Pemeriksa tipe seperti **mypy** atau **pyright** menganalisis petunjuk dan melaporkan kesalahan tipe *sebelum* Anda menjalankan kode — menangkap seluruh kelas bug (tipe argumen yang salah, penyalahgunaan None) sejak dini, seperti yang dilakukan compiler.

## Manfaatnya

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

## Mereka opsional dan bertahap

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

## Framework memanfaatkannya saat 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
```

Beberapa library (Pydantic, FastAPI) membaca petunjuk tipe untuk memvalidasi data dan menghasilkan dokumen — menjadikannya bermakna secara fungsional saat runtime.

## Mengapa ini penting

Petunjuk tipe membawa banyak manfaat pengetikan statis ke Python tanpa mengorbankan fleksibilitas dinamisnya: mereka menangkap bug yang berkaitan dengan tipe sejak dini (melalui mypy/pyright), secara dramatis meningkatkan perkakas IDE dan refactoring, berfungsi sebagai dokumentasi hidup, dan memberdayakan framework modern (FastAPI, Pydantic) yang menggunakannya untuk validasi dan dokumen yang dibuat secara otomatis. Meskipun opsional dan tidak diterapkan oleh Python sendiri saat runtime, mereka telah menjadi standar dalam codebase Python profesional dan skala besar karena membuat kode lebih andal, dapat dipelihara, dan mendokumentasikan diri sendiri — semakin menjadi praktik yang diharapkan, terutama saat proyek berkembang.