Python Academy · Pelajaran

TypeVar, Class Generik, dan Protocol

Definisikan tipe generik yang dapat digunakan kembali dan subtyping struktural dengan Protocol.

TypeVar, Class Generik, dan Protocol adalah pelajaran Python Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Python Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Python Academy mencakup 4 pelajaran total.

Apa Itu TypeVar

TypeVar mendeklarasikan variabel tipe—sebuah pengganti yang dapat berupa tipe apa pun dan dapat dibatasi jika diperlukan. TypeVar digunakan dalam fungsi dan kelas generik.

from typing import TypeVar

T = TypeVar("T")

def identity(value: T) -> T:
    return value

print(identity(42))      # int
print(identity("hello")) # str

Fungsi Generik

Fungsi yang menggunakan TypeVar pada tipe parameter dan nilai kembalian memungkinkan mypy menyimpulkan tipe kembalian dari tipe argumen.

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T:
    return items[0]

x: int = first([1, 2, 3])     # mypy knows x is int
s: str = first(["a","b","c"]) # mypy knows s is str

TypeVar Terbatas

Berikan batasan tipe kepada TypeVar untuk membatasi tipe yang dapat diterima.

from typing import TypeVar

Numeric = TypeVar("Numeric", int, float)

def double(n: Numeric) -> Numeric:
    return n * 2

print(double(5))    # 10
print(double(2.5))  # 5.0
# double("x")  # mypy error

Kelas Generik

Turunkan kelas dari Generic[T] untuk membuat kelas yang diparameterkan oleh variabel tipe.

from typing import Generic, TypeVar

T = TypeVar("T")

class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

stack: Stack[int] = Stack()
stack.push(1)
print(stack.pop())   # 1

Beberapa TypeVar

Gunakan beberapa TypeVar untuk memparameterkan kelas atau fungsi dengan dua tipe yang saling independen.

from typing import Generic, TypeVar

K = TypeVar("K")
V = TypeVar("V")

class Pair(Generic[K, V]):
    def __init__(self, key: K, value: V) -> None:
        self.key = key
        self.value = value

p: Pair[str, int] = Pair("age", 30)
print(p.key, p.value)   # age 30

Protocol — Subtipe Struktural

Protocol mendefinisikan antarmuka berdasarkan metode dan atribut yang harus dimiliki sebuah kelas, tanpa mengharuskan pewarisan secara eksplisit ("pengetikan bebek, diperiksa tipenya").

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

def render(obj: Drawable) -> None:
    obj.draw()

class Circle:
    def draw(self) -> None:
        print("Drawing circle")

render(Circle())   # works — Circle satisfies Drawable

Protocol dengan runtime_checkable

Tambahkan @runtime_checkable ke Protocol untuk mengaktifkan pemeriksaan isinstance() saat runtime.

from typing import Protocol, runtime_checkable

@runtime_checkable
class Closeable(Protocol):
    def close(self) -> None: ...

class File:
    def close(self) -> None: print("closed")

print(isinstance(File(), Closeable))   # True

Protocol vs ABC

ABC mengharuskan pewarisan secara eksplisit (class Dog(Animal)). Protocol bekerja berdasarkan pencocokan struktural—jika sebuah kelas memiliki metode yang tepat, kelas tersebut memenuhi protocol terlepas dari pewarisannya.

from typing import Protocol
from abc import ABC, abstractmethod

# ABC: nominal typing
class Printable(ABC):
    @abstractmethod
    def display(self) -> None: ...

# Protocol: structural typing
class Displayable(Protocol):
    def display(self) -> None: ...

TypeVar dengan bound

TypeVar("T", bound=BaseClass) membatasi T agar berupa BaseClass atau salah satu subkelasnya.

from typing import TypeVar

class Animal:
    def speak(self) -> str: return "..."

A = TypeVar("A", bound=Animal)

def make_speak(animal: A) -> str:
    return animal.speak()

Alias Generik — Python 3.12

Python 3.12 memperkenalkan pernyataan type untuk alias tipe yang lebih rapi dan sintaks class Foo[T] untuk generik tanpa mengimpor TypeVar.

# Python 3.12+
type Vector = list[float]
type Matrix = list[Vector]

class Stack[T]:
    def __init__(self) -> None: self._items: list[T] = []
    def push(self, item: T) -> None: self._items.append(item)
    def pop(self) -> T: return self._items.pop()

Tipe Self

Self (dari typing dalam versi 3.11+) menganotasikan metode yang mengembalikan kelas saat ini, sehingga berguna dalam antarmuka berantai dan subkelas.

from typing import Self

class Builder:
    def __init__(self) -> None:
        self.parts: list[str] = []

    def add(self, part: str) -> Self:
        self.parts.append(part)
        return self

b = Builder().add("a").add("b")
print(b.parts)   # ["a", "b"]

Pemeriksaan Singkat

Apa perbedaan utama antara Protocol dan ABC dalam pengetikan Python?

Ringkasan

TypeVar membuat pengganti tipe untuk fungsi dan kelas generik. Generic[T] memparameterkan kelas. Protocol memungkinkan subtipe struktural tanpa pewarisan. Gunakan bound= atau batasan tipe pada TypeVar untuk membatasi tipe yang dapat diterima.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “TypeVar, Class Generik, dan Protocol” gratis?

Ya — teks lengkap “TypeVar, Class Generik, dan Protocol” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Python Academy, upgrade ke CoddyKit PRO. Kursus Python Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “TypeVar, Class Generik, dan Protocol”?

Definisikan tipe generik yang dapat digunakan kembali dan subtyping struktural dengan Protocol. Kamu berlatih Python Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Python Academy?

Tidak diperlukan pengalaman sebelumnya. Python Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “TypeVar, Class Generik, dan Protocol” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Python Academy ini?

Ya. Setiap pelajaran Python Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Anotasi Tipe Dasar
Tipe Kompleks: List, Dict, Optional, Union
TypeVar, Class Generik, dan Protocol
Menjalankan mypy dan Memperbaiki Error Tipe

← Kembali ke Python Academy