Python Academy · Pelajaran

Anotasi Jenis Asas

Anotasi pemboleh ubah, parameter fungsi dan jenis pulangan.

Pelajaran 1 daripada 413 langkah

Anotasi Jenis Asas ialah pelajaran Python Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Python Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Python Academy merangkumi sejumlah 4 pelajaran.

Apakah Anotasi Jenis

Anotasi jenis ialah petunjuk yang mengisytiharkan jenis dijangka bagi pemboleh ubah, parameter dan nilai pulangan. Anotasi ini tidak dikuatkuasakan pada masa jalan — anotasi ini dibaca oleh pemeriksa jenis seperti mypy.

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

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

Anotasi Pemboleh Ubah

Anotasikan pemboleh ubah pada tahap modul, tahap kelas atau tahap setempat dengan titik bertindih diikuti jenisnya.

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 tandatangan fungsi. Gunakan -> type untuk menganotasi jenis pulangan.

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

Jenis Koleksi Terbina Dalam (Python 3.9+)

Mulai Python 3.9+, gunakan jenis terbina dalam huruf kecil secara langsung sebagai generik: list[int], dict[str, int], 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] bermaksud nilai boleh jadi X atau None. X | Y bermaksud 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]:

Jenis Union

int | str (Python 3.10+) atau Union[int, str] menganotasikan nilai yang mungkin merupakan salah satu daripada beberapa jenis.

from typing import Union

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

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

Alias Jenis

Tugaskan ungkapan jenis kepada nama untuk mencipta alias yang boleh digunakan semula, sekali gus meningkatkan kebolehbacaan.

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 menganotasi fungsi yang dihantar 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 jenis elemennya, bukan tupel, dan **kwargs dengan jenis 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 import ini di bahagian atas fail untuk mendayakan penilaian anotasi yang ditangguhkan, sekali gus membenarkan rujukan ke hadapan tanpa tanda petikan.

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

Pengawal TYPE_CHECKING

Importkan jenis hanya semasa pemeriksaan jenis, bukan pada masa jalan, untuk mengelakkan import kitaran atau import 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

Semakan Pantas

Apakah sintaks anotasi yang menandakan fungsi tidak memulangkan apa-apa?

Jawab dalam pelajaran interaktif

Rumusan

Anotasikan pemboleh ubah dengan name: Type, parameter dengan param: Type dan nilai pulangan dengan -> Type. Gunakan list[T], dict[K,V] (Python 3.9+), X | None (3.10+) dan from __future__ import annotations untuk rujukan ke hadapan.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 76
Pelajaran: 320

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Anotasi Jenis Asas” percuma?

Ya — teks penuh “Anotasi Jenis Asas” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Python Academy, tingkat taraf kepada CoddyKit PRO. Kursus Python Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Anotasi Jenis Asas”?

Anotasi pemboleh ubah, parameter fungsi dan jenis pulangan. Anda berlatih Python Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Python Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Python Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Anotasi Jenis Asas” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Python Academy ini?

Ya. Setiap pelajaran Python Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Python Academy