Python Academy · Pelajaran

Anotasi Tipe Dasar

Anotasikan variabel, parameter fungsi, dan tipe return.

Anotasi Tipe Dasar adalah pelajaran Python Academy gratis di CoddyKit. Ini adalah pelajaran 1 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 Anotasi Tipe

Anotasi tipe adalah petunjuk yang menyatakan tipe yang diharapkan untuk variabel, parameter, dan nilai kembalian. Anotasi ini tidak diberlakukan saat runtime—anotasi ini dibaca oleh pemeriksa tipe seperti mypy.

def greet(name: str) -> str:
    return f"Hello, {name}"

result: str = greet("Alice")
print(result)

Anotasi Variabel

Anotasikan variabel tingkat modul, tingkat kelas, atau lokal dengan titik dua yang diikuti tipe.

count: int = 0
pi: float = 3.14159
name: str = "Python"
flag: bool = True

# Annotation without assignment (declaration only)
future_value: int

Anotasi Parameter Fungsi

Anotasikan setiap parameter dalam tanda tangan fungsi. Gunakan -> type untuk menganotasikan tipe kembalian.

def add(a: int, b: int) -> int:
    return a + b

def repeat(text: str, times: int = 1) -> str:
    return text * times

def no_return() -> None:
    print("side effect only")

Tipe Koleksi Bawaan (Python 3.9+)

Mulai Python 3.9+, gunakan tipe bawaan dengan huruf kecil secara langsung sebagai generik: list[int], dict[str, int], dan tuple[int, ...].

def total(numbers: list[int]) -> int:
    return sum(numbers)

def config() -> dict[str, str]:
    return {"host": "localhost", "port": "8080"}

def coords() -> tuple[float, float]:
    return (1.0, 2.0)

Optional dan Union

X | None (Python 3.10+) atau Optional[X] berarti suatu nilai dapat berupa X atau None. X | Y berarti X atau Y.

from typing import Optional

def find(items: list[int], target: int) -> int | None:
    return next((x for x in items if x == target), None)

# Older style:
# def find(...) -> Optional[int]:

Tipe Union

int | str (Python 3.10+) atau Union[int, str] menganotasikan nilai yang mungkin berupa salah satu dari beberapa tipe.

from typing import Union

def process(value: int | str) -> str:
    return str(value)

# Older style:
# def process(value: Union[int, str]) -> str:

Alias Tipe

Tetapkan ekspresi tipe ke sebuah nama untuk membuat alias yang dapat digunakan kembali dan meningkatkan keterbacaan.

from typing import TypeAlias

Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[Vector]

def dot(a: Vector, b: Vector) -> float:
    return sum(x * y for x, y in zip(a, b))

Anotasi Callable

Gunakan Callable[[arg_types], return_type] untuk menganotasikan fungsi yang diteruskan sebagai argumen.

from typing import Callable

def apply(func: Callable[[int, int], int], x: int, y: int) -> int:
    return func(x, y)

result = apply(lambda a, b: a + b, 3, 4)
print(result)  # 7

Menganotasikan *args dan **kwargs

Anotasikan *args dengan tipe elemennya, bukan tuple, dan anotasikan **kwargs dengan tipe nilainya.

def log(*messages: str, level: str = "INFO") -> None:
    for msg in messages:
        print(f"[{level}] {msg}")

def configure(**options: int) -> None:
    for key, val in options.items():
        print(f"{key}: {val}")

from future import annotations

Tambahkan impor ini di bagian atas berkas untuk mengaktifkan evaluasi anotasi yang ditunda, sehingga referensi ke deklarasi berikutnya dapat digunakan tanpa tanda kutip.

from __future__ import annotations

class Node:
    def __init__(self, value: int, next: Node | None = None):
        self.value = value
        self.next = next   # forward ref to Node works here

Penjagaan TYPE_CHECKING

Impor tipe hanya saat pemeriksaan tipe, bukan saat runtime, untuk menghindari impor melingkar atau impor yang berat.

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from mymodule import HeavyClass

def process(obj: HeavyClass) -> None:
    ...   # HeavyClass not imported at runtime

Pemeriksaan Singkat

Sintaks anotasi apa yang menandai bahwa sebuah fungsi tidak mengembalikan apa pun?

Ringkasan

Anotasikan variabel dengan name: Type, parameter dengan param: Type, dan nilai kembalian dengan -> Type. Gunakan list[T], dict[K,V] (Python 3.9+), X | None (3.10+), dan from __future__ import annotations untuk referensi ke deklarasi berikutnya.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Anotasi Tipe Dasar” gratis?

Ya — teks lengkap “Anotasi Tipe Dasar” 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 “Anotasi Tipe Dasar”?

Anotasikan variabel, parameter fungsi, dan tipe return. 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 1 dari 4.

Berapa lama pelajaran “Anotasi Tipe Dasar” 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

← Kembali ke Python Academy