Podstawowe adnotacje typów
Proszę dodawać adnotacje do zmiennych, parametrów funkcji i typów zwracanych.
Podstawowe adnotacje typów to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 4 lekcji w sumie.
Czym są adnotacje typów
Adnotacje typów to wskazówki określające oczekiwany typ zmiennych, parametrów i wartości zwracanych. Nie są egzekwowane w czasie wykonywania — odczytują je narzędzia do sprawdzania typów, takie jak mypy.
def greet(name: str) -> str:
return f"Hello, {name}"
result: str = greet("Alice")
print(result)Adnotacje zmiennych
Zmienne na poziomie modułu, klasy lub lokalne należy opisywać, używając dwukropka, po którym następuje typ.
count: int = 0
pi: float = 3.14159
name: str = "Python"
flag: bool = True
# Annotation without assignment (declaration only)
future_value: intAdnotacje parametrów funkcji
Każdy parametr należy opisać w sygnaturze funkcji. Do opisania typu zwracanego należy użyć -> type.
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")Wbudowane typy kolekcji (Python 3.9+)
Od Python 3.9 można bezpośrednio używać małych liter w nazwach wbudowanych typów jako typów generycznych: 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 i Union
X | None (Python 3.10+) lub Optional[X] oznacza, że wartość może być typu X lub mieć wartość None. X | Y oznacza, że może być typu X lub 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]:Typy Union
int | str (Python 3.10+) lub Union[int, str] oznacza wartość, która może należeć do jednego z kilku typów.
from typing import Union
def process(value: int | str) -> str:
return str(value)
# Older style:
# def process(value: Union[int, str]) -> str:Aliasy typów
Należy przypisać wyrażenie typu do nazwy, aby utworzyć wielokrotnie używany alias i poprawić czytelność kodu.
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))Adnotacje Callable
Należy użyć Callable[[arg_types], return_type], aby opisać funkcje przekazywane jako argumenty.
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) # 7Adnotowanie *args i **kwargs
*args należy opisać typem elementów, a nie krotką, natomiast **kwargs — typem wartości.
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
Należy dodać ten import na początku pliku, aby włączyć odroczoną ewaluację adnotacji i umożliwić stosowanie odwołań do typów zdefiniowanych później bez cudzysłowów.
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 hereStrażnik TYPE_CHECKING
Typy należy importować tylko podczas sprawdzania typów, a nie w czasie wykonywania, aby uniknąć cyklicznych importów lub ciężkich importów.
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 runtimeSzybkie sprawdzenie
Jaka składnia adnotacji oznacza, że funkcja niczego nie zwraca?
Podsumowanie
Zmienne należy opisywać za pomocą name: Type, parametry za pomocą param: Type, a wartości zwracane za pomocą -> Type. Należy używać list[T], dict[K,V] (Python 3.9+), X | None (3.10+) oraz from __future__ import annotations w przypadku odwołań do typów zdefiniowanych później.
Często zadawane pytania
Czy lekcja „Podstawowe adnotacje typów” jest bezpłatna?
Tak — pełny tekst „Podstawowe adnotacje typów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Podstawowe adnotacje typów”?
Proszę dodawać adnotacje do zmiennych, parametrów funkcji i typów zwracanych. Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Python Academy?
Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Podstawowe adnotacje typów”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?
Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Podstawowe adnotacje typów
- Typy złożone: List, Dict, Optional, Union
- TypeVar, klasy generyczne i Protocol
- Uruchamianie mypy i naprawianie błędów typów