Seneste Python-funktioner

Denne artikel forklarer de nyeste funktioner i Python.

Vi forklarer trin for trin de bemærkelsesværdige funktioner i Python 3.12 til 3.13 generationerne ud fra et praktisk perspektiv på 'umiddelbart anvendelige' muligheder.

YouTube Video

Seneste Python-funktioner

I de senere år har Python udviklet sig med fokus ikke kun på 'let at skrive', men også på 'robusthed, hastighed og læsbarhed'. Nedenfor introducerer vi de bemærkelsesværdige funktioner fra Python 3.12 til 3.13 generationerne.

Dramatiske forbedringer i fejlmeddelelser (Python 3.12)

I Python 3.12 vises fejl nu på en mere konkret og visuel måde. Du kan med det samme identificere, hvor fejlene opstår, og markant reducere fejlretningstiden.

1def calc_total(price, tax):
2    return price + price * tax
3
4result = calc_total(100, )

• Manglende argumenter vises med den relevante linje og placering, så du ikke bliver forvirret, når du skal finde årsagen.

Praktisk brug af 'match'-sætningen (Strukturel mønstermatching)

'match'-sætningen gør det muligt at beskrive komplekse betingelsesgrene og genkende datastrukturer deklarativt. Håndtering af ordbøger og indlejrede strukturer bliver især mere læsbar.

1user = {"status": "active", "name": "Alice"}
2
3match user:
4    case {"status": "active", "name": name}:
5        print(f"Welcome back, {name}!")
6    case {"status": "inactive"}:
7        print("Please activate your account.")
8    case _:
9        print("Unknown user status.")

• Fordi du kan udføre betingede grene og dataudtræk samtidigt, bliver indlejrede if-sætninger unødvendige.

Intuitiv mønstermatching til håndtering af indlejrede data

'match'-sætningen er også effektiv til strukturerede data såsom JSON eller API-svar.

1data = {"user": {"name": "Bob", "age": 25}}
2
3match data:
4    case {"user": {"name": name, "age": age}}:
5        print(f"{name} is {age} years old.")

• Du kan sikkert udtrække kun de nødvendige elementer, hvilket reducerer behovet for defensiv kode.

Forbedret f-string-debugudskrift (=` notation / Python 3.8 og senere, forbedret brugervenlighed)

Med f-strenge kan du nu tilføje = for at vise både selve udtrykket og resultatet af evalueringen på samme tid. Denne funktion er specialiseret til debugging og er særdeles nyttig, når du hurtigt vil tjekke indholdet af en variabel.

1x = 10
2y = 20
3print(f"{x=}, {y=}, {x+y=}")

• Da variabelnavne og værdier vises sammen, bliver midlertidig debugging med print()-udtryk lettere at læse.
• Du kan skrive logudskrifter og verificeringskode mere præcist og mere udtryksfuldt.

Forenklede typehint og 'type'-alias (Python 3.12: Ny alias-syntaks)

I Python 3.12 blev der indført en dedikeret syntaks til definition af typealias— type-sætningen. Dette gør, at typehint ikke kun fungerer som supplerende information, men også som et sprog-element til tydeligt at udtrykke designintention.

1type UserId = int
2type UserName = str
3
4def greet(user_id: UserId, name: UserName) -> str:
5    return f"Hello, {name} (id={user_id})"

• Ved at give betydning til UserId eller UserName kan forskelle i roller tydeliggøres, selvom begge bruger samme int eller str type.
• Typedefinitioner bliver mere præcise, hvilket mindsker udgiften ved forståelse under code review og vedligeholdelse.
• Tidligere blev typealias som UserId = int oprettet ved tildeling, men med type-sætningen bliver det eksplicit, at 'dette er en typedefinition'. Dette er især effektivt for forbedring af designlæsbarhed i mellemstore og større kodebaser.

Naturlige typeannotationer med indbyggede typer (Forenklede generics fra Python 3.9+)

Siden Python 3.9 kan du bruge indbyggede typer som list eller dict direkte som generics.

Dette gør det muligt at skrive intuitive og læsbare typehint uden at importere typer fra typing-modulet.

1def sum_numbers(numbers: list[int]) -> int:
2    return sum(numbers)
3
4print(sum_numbers([1, 2, 3, 4]))

• Typehint fungerer ikke som 'begrænsninger', men som 'dokumentation, der forklarer behandlingsindholdet'.

Sikker metodekædning med Self type (Python 3.11 og senere)

Siden Python 3.11 kan du angive Self som returtype for metoder, der returnerer klassen selv.

Dette giver dig mulighed for sikkert at skrive metodekædningskode uden at miste typeinformation.

 1from typing import Self
 2
 3class Counter:
 4    def __init__(self, value: int = 0) -> None:
 5        self.value = value
 6
 7    def increment(self) -> Self:
 8        self.value += 1
 9        return self
10
11counter = Counter()
12counter.increment().increment()
13print(counter.value)

• Selv for metoder, der returnerer self, bevares den korrekte returtype.
• IDE'er og typecheckere kan præcist forstå metodekædning.

Klarere strengmanipulation (removeprefix / removesuffix | Python 3.9 og senere)

Fra Python 3.9 er der tilføjet specialiserede metoder str.removeprefix() og str.removesuffix() til sikkert at fjerne præfikser og suffikser fra strenge. Med disse kan du præcist udtrykke hensigten om 'kun at fjerne begyndelsen eller slutningen' i din kode.

1filename = "report_2026.txt"
2
3clean_name = filename.removeprefix("report_")
4name_without_ext = clean_name.removesuffix(".txt")
5
6print(name_without_ext)

• Den angivne streng fjernes kun hvis den findes i begyndelsen eller slutningen, hvilket forhindrer utilsigtede udskiftninger.
• Denne tilgang giver bedre læsbarhed og sikkerhed end brug af replace() eller udskæring.
• Især til håndtering af 'strenge med et defineret format', såsom filnavne eller URL-forbehandling, kan brugen af disse metoder minimere risikoen for fejl betydeligt.

Robust strengsammenligning til internationalisering (str.casefold() | Unicode-understøttelse)

str.casefold() i Python er en metode til case-insensitive sammenligninger, der tager hensyn til Unicode. I modsætning til simpel lower() eller upper() normaliserer den strenge, inklusiv sprogspecifikke tegnomdannelser.

1text1 = "Stra\u00dfe"
2text2 = "strasse"
3
4print(text1)
5print(text2)
6
7print(f"Comparison Result: {text1.casefold() == text2.casefold()}")

• Den kan korrekt håndtere sprogaafhængige forskelle som tysk ß og ss.
• Dette er en essentiel teknik til applikationer med flersproglig understøttelse eller internationalisering.

Standard TOML-understøttelse (tomllib | Python 3.11 og senere)

Fra Python 3.11 er tomllib-modulet til læsning af TOML-konfigurationsfiler blevet tilføjet til standardbiblioteket. Konfigurationsstyring kan nu udføres udelukkende i Python uden afhængighed af eksterne biblioteker.

 1import tomllib
 2
 3with open("config.toml", "rb") as f:
 4    config = tomllib.load(f)
 5
 6print(config["database"]["host"])
 7
 8# config.toml
 9# title = "TOML Example"
10# [database]
11# host = "192.168.1.1"
12# ports = [ 8001, 8001, 8002 ]

• Eksterne pakker som toml er ikke længere nødvendige, hvilket forenkler dine afhængigheder.
• Indlæsning af konfigurationsfiler er standardiseret, hvilket gør distribution, drift og CI-miljøer lettere at håndtere.

Undtagelseshåndtering i parallelle processers tidsalder (ExceptionGroup / except* | Python 3.11 og senere)

Python 3.11 introducerede ExceptionGroup for at håndtere flere undtagelser samlet samt except* syntaksen for at håndtere dem sikkert i grene. Dette er en ny funktion til at håndtere 'samtidige fejl', der opstår ved asynkron eller parallel behandling.

 1def process(values):
 2    errors = []
 3    for v in values:
 4        if v < 0:
 5            errors.append(ValueError(f"Negative value: {v}"))
 6    if errors:
 7        raise ExceptionGroup("Invalid values", errors)
 8
 9try:
10    process([1, -2, -3])
11except* ValueError as e:
12    print("Handled:", e)

• Flere undtagelser kan nu rejses og klassificeres i én operation.
• Den løser problemet i asynkron behandling, hvor kun den første fejl kunne ses.
• Ved operationer som asyncio.gather() eller parallel batchbehandling kan flere fejlfaktorer forekomme samtidigt. Anvendelse af ExceptionGroup gør det lettere at organisere fejlindsamling, logning og retry-strategier.

Ydelse forbedres blot ved at opdatere til den nyeste version

Fra Python 3.11 og frem er mange processer blevet hurtigere gennem interne optimeringer.

1def count_up(n):
2    total = 0
3    for i in range(n):
4        total += i
5    return total
6
7print(count_up(1_000_000))

• En stor fordel er, at hastighedsforbedringer kan opnås uden at omskrive din kode.

Styring af garbage collection (eksplicit styring via gc-modulet)

I Python giver brugen af det standard gc-modul dig mulighed for midlertidigt at deaktivere eller manuelt udføre garbage collection. Dette er en effektiv optimeringsteknik i scenarier som batchbehandling af store datasæt eller ydelseskritiske operationer.

1import gc
2
3gc.disable()
4# heavy batch processing
5gc.enable()
6gc.collect()

• Undertrykkelse af unødvendige garbage collection-udløsere kan reducere udsving i behandlingstiden.
• Du kan eksplicit samle op ved procesintervaller, hvilket gør det lettere at holde styr på hukommelsesforbruget.
• Dog bør denne teknik ikke bruges som standardoptimering, men kun overvejes, hvis profiling viser, at GC er en flaskehals. For de fleste applikationer er det sikrest at stole på Pythons automatiske garbage collection.

Sammendrag

Med forbedringer i fejlmeddelelser og udvikling af typehint i Python 3.12 til 3.13 generationerne er det blevet nemmere end nogensinde før at forstå og vedligeholde kode. Desuden bidrager forbedringer som bedre debugoplevelser og ydelsesforbedringer gennem intern optimering direkte til øget produktivitet i praksis. Du behøver ikke tage alle disse nye funktioner i brug på én gang; det er praktisk at starte med den seneste Python-version og gradvist inkorporere funktioner efter behov. Denne gradvise implementering fører til mere læsbar og robust Python-kode.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video