0Pricing
Python Academy · Lekcja

Typy złożone: List, Dict, Optional, Union

Proszę prawidłowo używać generyków modułu typing oraz Optional i Union.

Typy złożone: List, Dict, Optional, Union to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 2 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.

Przegląd modułu typing

Przed Pythonem 3.9 typy generyczne, takie jak List, Dict i Tuple, pochodziły z modułu typing. Od wersji 3.9 można bezpośrednio używać wbudowanych typów.

from typing import List, Dict, Tuple, Optional, Union

# Python 3.9+: use list[int], dict[str,int] directly
# Python 3.8-: use typing.List[int], typing.Dict[str,int]

List i Sequence

Należy używać list[T] w przypadku sekwencji modyfikowalnych oraz Sequence[T], gdy akceptowana ma być dowolna uporządkowana sekwencja (lista, krotka lub napis).

from typing import Sequence

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

def first(items: Sequence[str]) -> str:
    return items[0]   # works with list, tuple, str

Dict i Mapping

Należy używać dict[K,V] w przypadku modyfikowalnych słowników oraz Mapping[K,V] w przypadku obiektów tylko do odczytu przypominających słowniki.

from typing import Mapping

def lookup(data: Mapping[str, int], key: str) -> int | None:
    return data.get(key)

result = lookup({"a": 1, "b": 2}, "a")
print(result)   # 1

Adnotacje krotek

Stała długość: tuple[int, str, float]. Zmienna długość: tuple[int, ...].

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

def first_n(n: int) -> tuple[int, ...]:
    return tuple(range(n))

# Named tuple with types:
from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

Optional[T]

Optional[T] to skrócony zapis T | None. Jest to właściwy wybór, gdy parametr może nie zostać podany.

from typing import Optional

def find_user(user_id: int) -> Optional[dict[str, str]]:
    db: dict[int, dict[str, str]] = {
        1: {"name": "Alice"}
    }
    return db.get(user_id)

Typy Union

Union[X, Y] lub X | Y (3.10+) służy do opisywania wartości, które mogą należeć do jednego z kilku typów.

from typing import Union

def stringify(value: Union[int, float, str]) -> str:
    return str(value)

# Python 3.10+:
def stringify2(value: int | float | str) -> str:
    return str(value)

Typy Literal

Literal["a","b","c"] ogranicza wartość do określonego zbioru literałów.

from typing import Literal

Mode = Literal["read", "write", "append"]

def open_file(path: str, mode: Mode) -> None:
    with open(path, mode):
        pass

open_file("data.txt", "read")    # ok
# open_file("data.txt", "exec")  # mypy error

TypedDict

TypedDict służy do opisywania struktur słowników, w których każdy klucz jest powiązany z określonym typem.

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int
    email: str | None

def greet(user: User) -> str:
    return f"Hello, {user['name']}"

alice: User = {"name": "Alice", "age": 30, "email": None}

Set i FrozenSet

Zbiory należy opisywać za pomocą set[T], a zbiory niemodyfikowalne za pomocą frozenset[T].

def unique(items: list[int]) -> set[int]:
    return set(items)

def allowed_methods() -> frozenset[str]:
    return frozenset({"GET", "POST", "DELETE"})

Iterable i Iterator

Należy używać Iterable[T] dla każdego obiektu, po którym można iterować, oraz Iterator[T] dla obiektów zawierających __next__.

from typing import Iterable, Iterator

def evens(numbers: Iterable[int]) -> Iterator[int]:
    return (n for n in numbers if n % 2 == 0)

for n in evens([1, 2, 3, 4, 5]):
    print(n)   # 2 4

Any i NoReturn

Any wyłącza sprawdzanie typów dla danej wartości. NoReturn oznacza funkcje, które nigdy nie zwracają wartości, ponieważ zawsze zgłaszają wyjątek lub wykonują nieskończoną pętlę.

from typing import Any, NoReturn

def accept_all(x: Any) -> None:
    print(x)

def crash(msg: str) -> NoReturn:
    raise RuntimeError(msg)   # never returns normally

Szybkie sprawdzenie

Co oznacza Optional[str]?

Podsumowanie

W przypadku kolekcji należy używać list[T], dict[K,V] i tuple[T,...]. Optional[T] = T | None. Union[X,Y] lub X|Y służy do oznaczania wielu typów. Literal służy do oznaczania konkretnych wartości, TypedDict — typowanych struktur słowników, a Any — do wyłączenia sprawdzania typów.

Często zadawane pytania

Czy lekcja „Typy złożone: List, Dict, Optional, Union” jest bezpłatna?

Tak — pełny tekst „Typy złożone: List, Dict, Optional, Union” 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 „Typy złożone: List, Dict, Optional, Union”?

Proszę prawidłowo używać generyków modułu typing oraz Optional i Union. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Typy złożone: List, Dict, Optional, Union”?

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

  1. Podstawowe adnotacje typów
  2. Typy złożone: List, Dict, Optional, Union
  3. TypeVar, klasy generyczne i Protocol
  4. Uruchamianie mypy i naprawianie błędów typów
← Powrót do Python Academy