Python Academy · Lektion

Grundläggande typannoteringar

Annotera variabler, funktionsparametrar och returtyper.

Lektion 1 av 413 steg

Grundläggande typannoteringar är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad är typannoteringar?

Typannoteringar är ledtrådar som anger den förväntade typen för variabler, parametrar och returvärden. De tillämpas inte vid körning – de läses av typkontrollerare som mypy.

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

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

Variabelannoteringar

Annotera variabler på modulnivå, klassnivå eller lokal nivå med ett kolon följt av typen.

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

# Annotation without assignment (declaration only)
future_value: int

Annoteringar av funktionsparametrar

Annotera varje parameter i funktionssignaturen. Använd -> type för att annotera 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")

Inbyggda samlingstyper (Python 3.9+)

Från och med Python 3.9 kan ni använda inbyggda typer med gemener direkt som generiska typer: list[int], dict[str, int] och 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 och Union

X | None (Python 3.10+) eller Optional[X] betyder att ett värde kan vara X eller None. X | Y betyder 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] annoterar ett värde som kan vara en av flera typer.

from typing import Union

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

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

Typalias

Tilldela ett typuttryck till ett namn för att skapa ett återanvändbart alias och förbättra läsbarheten.

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

Använd Callable[[arg_types], return_type] för att annotera funktioner som skickas som argument.

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

Annotera *args och **kwargs

Annotera *args med elementtypen, inte en tupel, och **kwargs med värdetypen.

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

Lägg till denna import högst upp i filen för att aktivera uppskjuten utvärdering av annoteringar, vilket gör framåtreferenser möjliga utan citattecken.

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

Importera typer endast vid typkontroll, inte vid körning, för att undvika cirkulära importer eller tunga 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

Snabbkontroll

Vilken annoteringssyntax anger att en funktion inte returnerar något?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Annotera variabler med name: Type, parametrar med param: Type och returvärden med -> Type. Använd list[T], dict[K,V] (Python 3.9+), X | None (3.10+) och from __future__ import annotations för framåtreferenser.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Grundläggande typannoteringar” gratis?

Ja – hela texten till ”Grundläggande typannoteringar” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grundläggande typannoteringar”?

Annotera variabler, funktionsparametrar och returtyper. Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Grundläggande typannoteringar”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Grundläggande typannoteringar
Komplexa typer: List, Dict, Optional, Union
TypeVar, generiska klasser och Protocol
Köra mypy och åtgärda typfel

← Tillbaka till Python Academy