Python Academy · leksjon

Grunnleggende typeannotasjoner

Annoter variabler, funksjonsparametere og returtyper.

Leksjon 1 av 413 trinn

Grunnleggende typeannotasjoner er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Python Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hva er typeannotasjoner

Typeannotasjoner er hint som angir forventet type for variabler, parametere og returverdier. De håndheves ikke ved kjøring – de leses av typesjekkere som mypy.

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

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

Variabelannotasjoner

Angi type for variabler på modulnivå, klassenivå eller lokalt med et kolon etterfulgt av typen.

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

# Annotation without assignment (declaration only)
future_value: int

Annotasjoner for funksjonsparametere

Annoter hver parameter i funksjonssignaturen. Bruk -> type for å angi returtypen.

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

Innebygde samlingstyper (Python 3.9+)

Fra og med Python 3.9 kan innebygde typer med små bokstaver brukes direkte som generiske typer: list[int], dict[str, int] og 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 og Union

X | None (Python 3.10+) eller Optional[X] betyr at en verdi kan være X eller None. X | Y betyr X eller 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-typer

int | str (Python 3.10+) eller Union[int, str] annoterer en verdi som kan være én av flere typer.

from typing import Union

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

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

Typealiaser

Tilordne et typeuttrykk til et navn for å opprette et gjenbrukbart alias og gjøre koden mer lesbar.

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

Bruk Callable[[arg_types], return_type] for å annotere funksjoner som sendes inn som argumenter.

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

Annotere *args og **kwargs

Annoter *args med elementtypen, ikke en tuple, og **kwargs med verditypen.

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

Legg denne importen øverst i filen for å aktivere utsatt evaluering av annotasjoner, slik at fremoverreferanser kan brukes uten anførselstegn.

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

Importer typer bare under typesjekking, ikke ved kjøring, for å unngå sirkulære importer eller tunge importer.

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

Kort kontroll

Hvilken annotasjonssyntaks angir at en funksjon ikke returnerer noe?

Besvar den i den interaktive leksjonen

Oppsummering

Annoter variabler med name: Type, parametere med param: Type og returverdier med -> Type. Bruk list[T], dict[K,V] (Python 3.9+), X | None (3.10+) og from __future__ import annotations for fremoverreferanser.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 76
Leksjoner: 320

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Grunnleggende typeannotasjoner» gratis?

Ja – hele teksten i «Grunnleggende typeannotasjoner» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Python Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Grunnleggende typeannotasjoner»?

Annoter variabler, funksjonsparametere og returtyper. Du øver på Python Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Python Academy?

Ingen tidligere erfaring er nødvendig. Python Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Grunnleggende typeannotasjoner»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Python Academy-leksjonen?

Ja. Alle Python Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Grunnleggende typeannotasjoner
Komplekse typer: List, Dict, Optional, Union
TypeVar, generiske klasser og Protocol
Kjøre mypy og rette typefeil

← Tilbake til Python Academy