Best practices in Python

Dit artikel legt best practices in Python uit.

We leggen de best practices van Python uit met echte codevoorbeelden, en introduceren manieren om leesbare en onderhoudbare code te schrijven.

YouTube Video

Best practices in Python

Maak leesbaarheid de hoogste prioriteit

Laten we eerst kijken naar 'leesbaarheid als hoogste prioriteit stellen.'.

Python is een taal die 'leesbaarheid' waardeert. Stel als eerste prioriteit om code te schrijven waarvan de bedoeling direct duidelijk is.

1# Bad example: unclear variable names
2a = 10
3b = 5
4c = a * b

In deze code geven de variabelen hun betekenis niet weer, waardoor het voor anderen later tijd kost om het te begrijpen.

1# Good example: descriptive variable names
2price = 10
3quantity = 5
4total_cost = price * quantity

Door variabelen specifieke namen te geven, fungeert je code zelf als documentatie.

Schrijf expliciete code

Laten we nu kijken naar 'expliciete code schrijven.'.

In Python wordt 'expliciete bedoeling' verkozen boven 'impliciet gedrag.'.

1# Bad example: implicit truthy check
2if data:
3    process(data)

In deze code is onduidelijk wat er van data verwacht wordt, wat aanleiding kan geven tot bugs.

1# Good example: explicit condition
2if len(data) > 0:
3    process(data)

Door voorwaarden expliciet te maken, komt de bedoeling van de code overeen met de specificatie.

Houd functies klein en gericht op één enkele verantwoordelijkheid

Laten we nu kijken naar 'functies klein houden en focussen op één verantwoordelijkheid.'.

Wanneer één functie te veel doet, worden testen en onderhoud lastig.

1# Bad example: doing too many things
2def handle_user(user):
3    save_to_database(user)
4    send_email(user)
5    write_log(user)

In deze code raken processen sterk met elkaar verweven, waardoor hergebruik en aanpassing moeilijk worden.

1# Good example: single responsibility
2def save_user(user):
3    save_to_database(user)
4
5def notify_user(user):
6    send_email(user)
7
8def log_user(user):
9    write_log(user)

Door functies op te splitsen worden hun rollen duidelijk en wordt testen eenvoudiger.

Gebruik actief type hints

Laten we nu kijken naar 'actief gebruik maken van type hints.'.

Type hints dienen als documentatie en zijn een krachtig hulpmiddel om bugs te voorkomen.

1# Bad example: Without type hints
2def add(a, b):
3    return a + b

In deze code zijn de types van argumenten en returnwaarden onduidelijk, waardoor verkeerd gebruik waarschijnlijk is.

1# Good example: With type hints
2def add(a: int, b: int) -> int:
3    return a + b

Met type hints verbeteren IDE-aanvulling, statische analyse en leesbaarheid aanzienlijk.

Geef expliciet aan of een functie None kan retourneren

Laten we nu kijken naar 'expliciet aangeven dat een functie None kan retourneren.'.

Functies die mogelijk None retourneren, worden vaak over het hoofd gezien door gebruikers.

1# Bad example: Ambiguous return value
2def find_user(user_id):
3    if user_id == 1:
4        return {"id": 1, "name": "Alice"}
5    return None

In deze code is het onduidelijk of er een waarde geretourneerd wordt.

1# Good example: explicit return type
2from typing import Optional, Dict, Any
3
4def find_user(user_id: int) -> Optional[Dict[str, Any]]:
5    if user_id == 1:
6        return {"id": 1, "name": "Alice"}
7    return None

Door Optional te gebruiken kun je aangeven dat het mogelijk is dat er None geretourneerd wordt.

Vang uitzonderingen niet te ruim op

Laten we nu kijken naar 'exceptions niet te ruim opvangen.'.

Exception handling zou in principe alleen moeten opvangen wat noodzakelijk is.

1# Bad example: catching all exceptions
2try:
3    result = int(value)
4except Exception:
5    result = 0

Deze code kan bugs verbergen die eigenlijk opgemerkt hadden moeten worden.

1# Good example: catch specific exception
2try:
3    result = int(value)
4except ValueError:
5    result = 0

Door uitzonderingen te beperken, mis je geen onverwachte problemen.

Hanteer resources veilig met het with statement

Laten we nu kijken naar 'resources veilig hanteren met het with statement.'.

Resources zoals bestanden en locks moeten altijd betrouwbaar worden vrijgegeven.

1# Bad example: manual close
2file = open("data.txt")
3content = file.read()
4file.close()

In deze code kan het gebeuren dat close() niet wordt aangeroepen als er een uitzondering optreedt.

1# Good example: using context manager
2with open("data.txt") as file:
3    content = file.read()

Door een with statement te gebruiken wordt altijd netjes opgeruimd, zelfs bij een uitzondering.

Gebruik list comprehensions op de juiste manier

Laten we nu kijken naar 'list comprehensions op de juiste manier gebruiken.'.

Eenvoudige transformaties kunnen beknopt worden geschreven met list comprehensions.

1# Bad example: Verbose loop
2squares = []
3for i in range(10):
4    squares.append(i * i)

In deze code is het kernproces lastig te zien.

1# Good example: Clear list comprehension
2squares = [i * i for i in range(10)]

Door list comprehensions correct te gebruiken, verbetert de leesbaarheid van de code.

Vermijd magic numbers

Laten we nu kijken naar 'het vermijden van magic numbers.'.

Nummers en strings direct schrijven maakt hun betekenis onduidelijk.

1# Bad example: magic number
2if status == 404:
3    handle_not_found()

In deze code wordt ervan uitgegaan dat je weet wat 404 betekent.

1# Good example: named constant
2NOT_FOUND = 404
3
4if status == NOT_FOUND:
5    handle_not_found()

Door namen te geven maak je intenties duidelijk.

Schrijf code die onderhoudbaar is, niet alleen code die 'werkt'

Tot slot, laten we kijken naar 'code schrijven die onderhoudbaar is, niet alleen code die werkt.'.

Het belangrijkste is of je toekomstige zelf of anderen het kunnen lezen.

1# Bad example: Hard to maintain
2def f(x):
3    return x * 1.08 + 100

In deze code is de specificatie niet af te leiden uit de code.

1# Good example: Easy to maintain
2TAX_RATE = 1.08
3BASE_FEE = 100
4
5def calculate_total(price: float) -> float:
6    return price * TAX_RATE + BASE_FEE

Door betekenis in namen te leggen, wordt de code zelf de specificatie.

Samenvatting

Best practices in Python komen neer op code schrijven die makkelijk te begrijpen is, niet per se slimme code. Door kleine gewoontes op te bouwen schrijf je code met minder bugs die lang bruikbaar blijft.

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

YouTube Video