Belajar Python - Type Checking & Contracting

#Pendahuluan

Python adalah bahasa bertipe dinamis, tapi itu bukan alasan untuk tidak memakai tipe. Episode 17 mengajarkan static typing modern dengan modul typing dan type checker seperti mypy dan pyright.

Typing bukan sekadar dekorasi — ia kontrak yang bisa diperiksa mesin, mendeteksi bug sebelum runtime, dan mendokumentasikan kode secara otomatis. Kita akan membedah Annotated, TypedDict, Protocol, dan ParamSpec, lalu melihat manfaatnya di codebase besar.

#Dasar Type Checking

#Menginstall dan Menjalankan mypy

mypy adalah type checker paling populer:

pip install mypy

Kode beranotasi untuk diperiksa

def tambah(a: int, b: int) -> int:
    return a + b
 
hasil = tambah(1, 2)
print(hasil)

def tambah(a: int, b: int) -> int: mendeklarasikan parameter dan return type. Simpan sebagai typed.py, lalu periksa:

mypy typed.py

mypy typed.py memeriksa anotasi dan menemukan pelanggaran tipe. Jika ada kode yang memanggil tambah("a", 1), mypy akan melaporkannya tanpa menjalankan program. Type checker menangkap bug di waktu pengembangan, bukan saat runtime.

#Annotated dan TypedDict

#Annotated untuk Metadata Tambahan

Annotated menambahkan metadata di samping tipe:

Menggunakan Annotated

from typing import Annotated
from pydantic import Field
 
usia = Annotated[int, Field(ge=0, le=150)]
 
def cek_usia(nilai: usia) -> str:
    if nilai < 18:
        return "remaja"
    return "dewasa"
 
print(cek_usia(20))

Annotated[int, Field(ge=0, le=150)] menggabungkan tipe int dengan metadata validasi. FastAPI dan pydantic membaca metadata ini untuk validasi dan dokumentasi otomatis. Annotated membuat tipe membawa lebih banyak informasi.

#TypedDict untuk Dict Terstruktur

TypedDict memberi tipe pada dict dengan kunci tetap:

Menggunakan TypedDict

from typing import TypedDict
 
class Pengguna(TypedDict):
    nama: str
    usia: int
    aktif: bool
 
def tampilkan(data: Pengguna) -> str:
    return f"{data['nama']} berusia {data['usia']}"
 
print(tampilkan({"nama": "Arman", "usia": 30, "aktif": True}))

class Pengguna(TypedDict): mendefinisikan skema dict dengan tipe per kunci. mypy memeriksa bahwa setiap kunci ada dan bertipe benar. TypedDict memberi keamanan tipe pada data JSON-like tanpa mengubahnya menjadi kelas.

#Protocol dan Structural Typing

#Memahami Protocol

Protocol memungkinkan structural typing — objek diterima berdasarkan bentuknya, bukan warisannya:

Menggunakan Protocol

from typing import Protocol
 
class BisaTerbang(Protocol):
    def terbang(self) -> str: ...
 
class Burung:
    def terbang(self) -> str:
        return "Burung terbang"
 
class Pesawat:
    def terbang(self) -> str:
        return "Pesawat terbang"
 
def terangkan(objek: BisaTerbang) -> str:
    return objek.terbang()
 
print(terangkan(Burung()))
print(terangkan(Pesawat()))

class BisaTerbang(Protocol): mendefinisikan kontrak berupa method terbang. Baik Burung maupun Pesawat memenuhi kontrak meski tidak saling mewarisi. Protocol memberi fleksibilitas duck typing dengan pemeriksaan tipe statis.

#ParamSpec dan Callable

#Meneruskan Fungsi dengan Tipe

ParamSpec menangkap parameter sebuah fungsi agar bisa diteruskan:

Menggunakan ParamSpec

from typing import Callable, ParamSpec, TypeVar
 
P = ParamSpec("P")
T = TypeVar("T")
 
def ulangi_dua_kali(fungsi: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
    hasil_pertama = fungsi(*args, **kwargs)
    return fungsi(*args, **kwargs)
 
print(ulangi_dua_kali(lambda x: x + 1, 5))

ParamSpec("P") menangkap parameter fungsi yang diteruskan. Callable[P, T] menyatakan fungsi yang dipanggil, dan P.args serta P.kwargs meneruskannya. mypy memeriksa bahwa pemanggilan ulang memiliki tipe yang konsisten — penting untuk decorator dan wrapper.

#mypy dan pyright dalam Praktik

#pyright: Alternatif dari Microsoft

pyright adalah type checker cepat yang diintegrasikan di editor:

npm install -g pyright

pyright typed.py

pyright typed.py memeriksa tipe dengan cepat. Berbeda dengan mypy yang dijalankan sebagai CLI, pyright menjadi mesin di balik ekstensi Python VS Code — memberi pemeriksaan tipe real-time saat mengetik. Keduanya bisa dipakai bersama; banyak tim memakai mypy di CI dan pyright di editor.

#Manfaat untuk Codebase Besar

#Dokumentasi dan Maintenance

Typing mendokumentasikan kode secara otomatis:

• Signature fungsi menjadi kontrak yang jelas.
• IDE menampilkan tipe saat hover.
• Developer baru memahami struktur lebih cepat.
• Bug tipe terdeteksi di CI, bukan di production.

Untuk tim besar, typed codebase lebih mudah dimaintenance karena kontrak antar modul dieksplisitkan. Investasi menulis anotasi terbayar berkali lipat dalam jangka panjang.

#Penutup

Inti yang harus dibawa pulang:

• mypy dan pyright memeriksa tipe tanpa menjalankan program.
• Annotated menambahkan metadata di samping tipe dasar.
• TypedDict memberi tipe pada dict dengan kunci tetap.
• Protocol memungkinkan structural typing berbasis bentuk objek.
• ParamSpec dan Callable menjaga tipe fungsi yang diteruskan.
• Typing membuat refactoring aman dan maintenance lebih mudah.

Di episode 18 selanjutnya kita akan membahas testing at scale — unit testing dengan pytest, test fixtures, parametrization, mocking, dan property-based testing dengan hypothesis, plus strategi integration dan end-to-end tests. Kode kalian akan terbukti benar dengan pengujian otomatis!