Python Academy · Oppitunti

Tyyppimerkintöjen perusteet

Merkitkää muuttujat, funktioiden parametrit ja palautustyypit.

Oppitunti 1/413 vaihetta

Tyyppimerkintöjen perusteet on ilmainen Python Academy-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Python Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Python Academy-kurssilla on yhteensä 4 oppituntia.

Mitä tyyppimerkinnät ovat

Tyyppimerkinnät ovat vihjeitä, jotka ilmoittavat muuttujien, parametrien ja paluuarvojen odotetun tyypin. Niitä ei valvota ajonaikaisesti, vaan niitä lukevat esimerkiksi mypyn kaltaiset tyyppitarkistimet.

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

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

Muuttujien tyyppimerkinnät

Merkitkää moduuli-, luokka- tai paikalliset muuttujat kaksoispisteellä, jota seuraa tyyppi.

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

# Annotation without assignment (declaration only)
future_value: int

Funktioparametrien tyyppimerkinnät

Merkitkää jokainen parametri funktion allekirjoituksessa. Käyttäkää muotoa -> type paluutyypin merkitsemiseen.

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

Sisäänrakennetut kokoelmatyypit (Python 3.9+)

Käyttäkää Python 3.9:stä alkaen pieniä kirjaimia käyttäviä sisäänrakennettuja tyyppejä suoraan geneerisinä tyyppeinä: 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 ja Union

X | None (Python 3.10+) tai Optional[X] tarkoittaa, että arvo voi olla X tai None. X | Y tarkoittaa, että arvo voi olla X tai 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]:

Union-tyypit

int | str (Python 3.10+) tai Union[int, str] merkitsee arvon, joka voi olla jotakin useista tyypeistä.

from typing import Union

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

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

Tyyppialiakset

Määrittäkää tyyppilauseke nimelle luodaksenne uudelleenkäytettävän aliaksen, joka parantaa luettavuutta.

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

Callable-tyyppimerkinnät

Käyttäkää muotoa Callable[[arg_types], return_type] argumentteina välitettävien funktioiden merkitsemiseen.

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

*args- ja **kwargs-tyyppimerkinnät

Merkitkää *args alkioiden tyypillä, ei tuplena, ja **kwargs arvojen tyypillä.

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

Lisätkää tämä tuonti tiedoston alkuun, jotta annotaatioiden laskentaa voidaan siirtää myöhemmäksi ja eteenpäin viittaavia tyyppejä voidaan käyttää ilman lainausmerkkejä.

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

TYPE_CHECKING-suojaus

Tuokaa tyypit vain tyyppitarkistuksen aikana, ei ajon aikana, jotta vältätte kehäriippuvuudet tai raskaiden moduulien tuonnin.

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

Pikatarkistus

Mikä annotaatiosyntaksi merkitsee, että funktio ei palauta mitään?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Merkitkää muuttujat muodossa name: Type, parametrit muodossa param: Type ja paluuarvot muodossa -> Type. Käyttäkää kokoelmille muotoja list[T] ja dict[K,V] (Python 3.9+), muotoa X | None (3.10+) sekä from __future__ import annotations eteenpäin viittaaville tyypeille.

Aloita maksutta

Opi Python tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 76
Oppitunnit: 320

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Tyyppimerkintöjen perusteet” ilmainen?

Kyllä – oppitunnin ”Tyyppimerkintöjen perusteet” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Python Academy-kurssin, päivitä CoddyKit PROhon. Python Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Tyyppimerkintöjen perusteet”?

Merkitkää muuttujat, funktioiden parametrit ja palautustyypit. Harjoittelet Python Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Python Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Python Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.

Kuinka kauan ”Tyyppimerkintöjen perusteet”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Python Academy-oppitunnilla?

Kyllä. Jokainen Python Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Tyyppimerkintöjen perusteet
Monimutkaiset tyypit: List, Dict, Optional, Union
TypeVar, geneeriset luokat ja Protocol
mypyn suorittaminen ja tyyppivirheiden korjaaminen

← Takaisin: Python Academy