Nieuwste Python-functies

Dit artikel legt de nieuwste functies van Python uit.

We leggen de opvallende functies van de Python 3.12 tot 3.13 generaties stap voor stap uit vanuit een praktisch perspectief van direct bruikbare toepassingen.

YouTube Video

Nieuwste Python-functies

De afgelopen jaren is Python geëvolueerd met nadruk niet alleen op 'gemak van schrijven', maar ook op 'robustheid, snelheid en leesbaarheid'. Hieronder introduceren we de opvallende functies van Python 3.12 tot 3.13 generaties.

Dramatische verbeteringen in foutmeldingen (Python 3.12)

In Python 3.12 worden fouten nu op een concretere en visuele manier weergegeven. Je kunt direct zien waar fouten zijn gemaakt en de tijd voor foutopsporing aanzienlijk verkorten.

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

• Ontbrekende argumenten worden getoond met de betreffende regel en locatie, zodat je niet in de war raakt bij het achterhalen van de oorzaak.

Praktisch gebruik van de 'match'-instructie (structurele patroonherkenning)

Met de 'match'-instructie kun je complexe conditionele vertakkingen en onderscheid in datastructuren declaratief beschrijven. Het omgaan met woordenboeken (dictionaries) en geneste structuren wordt vooral veel leesbaarder.

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

• Omdat je voorwaardelijke vertakkingen en gegevensuittrekking tegelijk kunt uitvoeren, worden geneste if-instructies overbodig.

Intuïtieve patroonherkenning voor het werken met geneste gegevens

De 'match'-instructie is ook effectief voor gestructureerde gegevens zoals JSON of API-responses.

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

• Je kunt alleen de benodigde elementen veilig extraheren, waardoor de behoefte aan defensieve code afneemt.

Verbeterde f-string debug-uitvoer (=`-notatie / Python 3.8 en later, verbeterde bruikbaarheid)

Met f-strings kun je nu = toevoegen om zowel de uitdrukking zelf als het evaluatieresultaat tegelijk te tonen. Deze functie is speciaal bedoeld voor debugging en is zeer nuttig als je snel de inhoud van een variabele wilt controleren.

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

• Omdat variabelenamen en waarden samen worden weergegeven, wordt tijdelijke debugging met print()-uitvoer eenvoudiger te lezen.
• Je kunt loguitvoer en verificatiecode beknopter en expressiever schrijven.

Vereenvoudigde typehints en 'type'-alias (Python 3.12: nieuwe typealias-syntaxis)

In Python 3.12 is een toegewijde syntaxis geïntroduceerd voor het definiëren van type-aliasen: de type-instructie. Hierdoor kunnen typehints niet alleen als aanvullende informatie fungeren, maar ook als een taalelement om ontwerpintentie duidelijk te maken.

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

• Door betekenis te geven aan UserId of UserName, kunnen verschillen in rol worden verduidelijkt, zelfs als beide dezelfde int of str gebruiken.
• Typedefinities worden beknopter, wat het begrijpingsproces tijdens code-review en onderhoud vereenvoudigt.
• Voorheen werden typealiasen zoals UserId = int toegewezen via toewijzing, maar met de type-instructie wordt expliciet gemaakt dat dit een typedefinitie betreft. Dit is vooral effectief om de ontwerp-leesbaarheid te verbeteren in middelgrote en grote codebases.

Natuurlijke typeannotaties met ingebouwde types (vereenvoudigde generics vanaf Python 3.9+)

Sinds Python 3.9 kun je ingebouwde types zoals list of dict direct als generics gebruiken.

Hierdoor kun je intuïtieve en leesbare typehints schrijven zonder types uit het typing-module te importeren.

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

• Typehints fungeren niet als 'beperkingen', maar als 'documentatie die de verwerking uitlegt'.

Veilige method-chaining met het Self-type (Python 3.11 en later)

Sinds Python 3.11 kun je Self specificeren als returntype voor methoden die de klasse zelf retourneren.

Je kunt zo veilig method-chaining-code schrijven zonder type-informatie te verliezen.

 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)

• Zelfs bij methoden die self retourneren, blijft het juiste returntype behouden.
• IDEs en typecheckers begrijpen method-chaining nu correct.

Duidelijkere tekenreeksmanipulatie (removeprefix / removesuffix | Python 3.9 en later)

Vanaf Python 3.9 zijn gespecialiseerde methoden str.removeprefix() en str.removesuffix() toegevoegd om voorvoegsels en achtervoegsels veilig uit tekenreeksen te verwijderen. Hiermee kun je in je code nauwkeurig aangeven dat je alleen het begin of het einde wilt verwijderen.

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

• De opgegeven tekenreeks wordt alleen verwijderd als deze zich aan het begin of eind bevindt, waardoor ongewenste vervangingen worden voorkomen.
• Deze aanpak biedt betere leesbaarheid en veiligheid dan het gebruik van replace() of slicing.
• Voor het werken met 'tekenreeksen met een gedefinieerde opmaak', zoals bestandsnamen of URL-preprocessing, kan het gebruik van deze methoden het risico op bugs aanzienlijk verkleinen.

Robuuste tekenreeksvergelijking voor internationalisatie (str.casefold() | Unicode-ondersteuning)

str.casefold() in Python is een methode voor hoofdletterongevoelige vergelijking die rekening houdt met Unicode. In tegenstelling tot eenvoudige lower() of upper() normaliseert deze methode tekenreeksen, inclusief taalspecifieke tekenconversies.

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

• Het kan taalafhankelijke verschillen correct verwerken, zoals Duits ß en ss.
• Dit is een essentiële techniek voor toepassingen met meertalige ondersteuning of internationalisatie.

Standaard TOML-ondersteuning (tomllib | Python 3.11 en later)

Vanaf Python 3.11 is het tomllib-module voor het lezen van TOML-configuratiebestanden toegevoegd aan de standaardbibliotheek. Configuratiebeheer kan nu volledig in Python worden uitgevoerd, zonder afhankelijk te zijn van externe bibliotheken.

 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 ]

• Externe pakketten zoals toml zijn niet meer nodig, waardoor je afhankelijkheden worden vereenvoudigd.
• Het laden van configuratiebestanden is gestandaardiseerd, waardoor distributie, werking en CI-omgevingen eenvoudiger te beheren zijn.

Foutafhandeling voor het tijdperk van parallelle verwerking (ExceptionGroup / except* | Python 3.11 en later)

Python 3.11 introduceerde ExceptionGroup om meerdere uitzonderingen tegelijk af te handelen en de except*-syntaxis om deze veilig gescheiden te verwerken. Dit is een nieuwe functie om 'gelijktijdige fouten' in asynchrone of parallelle verwerking af te handelen.

 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)

• Meerdere uitzonderingen kunnen nu in één keer worden opgegooid en geclassificeerd.
• Dit pakt het probleem aan dat bij asynchrone verwerking alleen de eerste fout zichtbaar was.
• Bij operaties zoals asyncio.gather() of parallelle batchverwerking kunnen meerdere foutfactoren tegelijk voorkomen. Met ExceptionGroup wordt het gemakkelijker om foutverzameling, logging en retry-strategieën te organiseren.

De prestaties verbeteren gewoon door te updaten naar de nieuwste versie

Vanaf Python 3.11 zijn veel processen sneller geworden dankzij interne optimalisaties.

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

• Een groot voordeel is dat prestatieverbeteringen mogelijk zijn zonder je code opnieuw te schrijven.

Beheer van garbage collection (expliciete controle via gc-module)

In Python kun je met de standaard gc-module tijdelijk garbage collection uitschakelen of handmatig uitvoeren. Dit is een effectieve optimalisatietechniek voor scenario's zoals batchverwerking van grote datasets of prestatiekritieke operaties.

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

• Onnodige garbage collection-triggers onderdrukken kan schommelingen in verwerkingstijden verminderen.
• Je kunt expliciet verzamelen op procesintervallen, waardoor geheugenbeheer beter te controleren is.
• Deze techniek moet echter niet standaard als optimalisatie worden toegepast, maar alleen als profiling aantoont dat GC een bottleneck vormt. Voor de meeste toepassingen is het het veiligst om te vertrouwen op Python's automatische garbage collection.

Samenvatting

Met de verbeteringen in foutmeldingen en de evolutie van typehints in de Python 3.12 tot 3.13 generatie is het begrijpen en onderhouden van code gemakkelijker dan ooit tevoren. Bovendien leveren verbeteringen zoals betere debugging-ervaringen en prestatieverbeteringen door interne optimalisatie geleidelijk directe bijdragen aan de productiviteit in de praktijk. Je hoeft niet al deze nieuwe functies tegelijk te gebruiken; het is praktisch om te beginnen met de nieuwste Python-versie en functies geleidelijk toe te voegen indien nodig. Deze geleidelijke adoptie leidt tot leesbaardere en robuustere Python-code.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video