Jouw start met Python.
Van je eerste script tot slimme automatisering. Begin met de eerste bouwstenen.
De eerste bouwstenen
26 praktische stappen · 114 min
Laat je code spreken
Twee regels tekst uitvoeren
Geef je waarden een naam
Een berekening met variabelen maken
Maak tekst persoonlijk
Een waarde in tekst invoegen
Reken met volgorde en resten
De volgorde van een berekening met haakjes veranderen
Maak van tekst een getal
Het type van een waarde bekijken
Stel vragen aan je waarden
Een vergelijking als True of False afdrukken
Ruim tekst stap voor stap op
Spaties aan de randen van tekst verwijderen
Combineer je kennis in een tijdplanner
Tekstinvoer omzetten en in een bericht gebruiken
Kiezen en herhalen
32 praktische stappen · 163 min
Kies een route met if en else
Een voorwaarde in een if-blok gebruiken
Verdeel gevallen met elif
Drie elkaar uitsluitende routes maken
Maak een toegangsregel leesbaar
Een samengestelde regel in tussenstappen opdelen
Loop door getallen met range
Een for-lus met een exclusieve bovengrens schrijven
Laat een while-lus stoppen
Een lusvoorwaarde en voortgang samen ontwerpen
Stop of sla een ronde over
Een volledige lus met break verlaten
Bouw een overzicht met accumulators
Meerdere samenvattingen in één lus bijhouden
Vind iets, of bewijs dat het ontbreekt
Stoppen bij de eerste gevonden deler
Denken in functies
32 praktische stappen · 192 min
Laat een functie iets teruggeven
Een functie definiëren en aanroepen
Geef invoer mee met parameters
Parameters met argumenten vullen
Maak afspraken over argumenten
Defaultwaarden bewust gebruiken
Houd lokale namen lokaal
Lokale en buitenste namen onderscheiden
Geef samenhangende waarden samen terug
Een tuple als retourwaarde maken
Weiger ongeldige argumenten duidelijk
Een functiecontract met grenzen formuleren
Geef een functie aan een functie
Een functie zonder haakjes doorgeven
Bouw een berekening uit kleine functies
Een grotere berekening in functies opdelen
Verzamelen en veranderen
32 praktische stappen · 208 min
Verander een lijst bewust
Een lijst op positie lezen
Kies tussen een alias en een kopie
Slices met grenzen en stappen gebruiken
Pak vaste en variabele reeksen uit
Een tuple met één waarde maken
Koppel sleutels aan waarden
Waarden met een sleutel opzoeken
Werk met unieke waarden
Duplicaten met een set verwijderen
Bouw collecties met comprehensions
Een transformatie als list comprehension schrijven
Werk veilig met geneste gegevens
Rijen en velden gericht uitlezen
Beheer taken met duidelijke mutatieregels
Een lijst met taakdictionaries bijhouden
Tekst begrijpen en verwerken
32 praktische stappen · 227 min
Pak precies het stukje tekst dat je nodig hebt
Tekstposities vanaf het begin en het einde lezen
Verdeel tekst en verbind de onderdelen
Witruimte en expliciete veldgrenzen onderscheiden
Zoek tekst en verwijder alleen het bedoelde begin
Aanwezigheid van een deeltekst van haar index onderscheiden
Kies de weergave van tekst en getallen
Veldbreedte en precisie in een f-string gebruiken
Vergelijk tekst in een gezamenlijke Unicode-vorm
Codepunten van zichtbare tekens onderscheiden
Codeer tekst en lees bytes strikt terug
Echte bytes van tekst onderscheiden
Herken de hele afgesproken tekstvorm
Tekenklassen en vaste aantallen begrijpen
Lees materiaalregels en behoud de afwijzingen
Splitsen, normaliseren en herkennen combineren
Foutafhandeling
32 praktische stappen · 210 min
Een traceback als routekaart lezen
Het fouttype en de laatste eigen bewerking in een traceback vinden.
Een verwachte fout gericht afhandelen
De uitvoering door try en except volgen.
De juiste fout op de juiste plek opvangen
Verwachte fouten afhandelen en andere fouten doorgeven.
Succes en afsluiting een eigen plaats geven
De else-route alleen na een normaal geëindigde poging uitvoeren.
Fouten werpen, doorgeven en vertalen
Een ongeldige waarde met een echte fout weigeren.
Een eigen foutcategorie voor aantallen
Een eenvoudig eigen fouttype van ValueError laten afstammen.
Fouten zichtbaar houden zonder gegevensverlies
Een gewone fout vastleggen en hetzelfde object doorgeven.
Een invoerpijplijn met verklaarde afwijzingen
Verantwoordelijkheden scheiden tussen lezen, parseren, verzamelen en afsluiten.
Eigen typen
32 praktische stappen · 218 min
Klassen en afzonderlijke instanties
Een klasse en haar afzonderlijke instanties onderscheiden.
Beginwaarden bij iedere nieuwe instantie
__init__ gebruiken om objectattributen meteen in te stellen.
Methoden gebruiken de toestand van hun instantie
Een methode met self op de juiste instantie laten werken.
Een property bewaakt de geldige toestand
Lezen en schrijven aan een property koppelen.
Dataclasses nemen gegevenswerk over
Een echte dataclass met benoemde velden gebruiken.
Gelijke waarden en hetzelfde object onderscheiden
Waardegelijkheid en identiteit uit elkaar houden.
Objecten samenstellen en bewust delen
Een relatie tussen echte objecten modelleren.
Een reservering bewaakt haar eigen toestand
Een samenhangend object met eigen begintoestand maken.
Interfaces en typing
32 praktische stappen · 238 min
Een object gebruiken om wat het kan
Met verschillende onafhankelijke objecten dezelfde methode gebruiken.
Typeannotaties beschrijven een contract
Parameters en retourwaarden met echte typen annoteren.
Ontbrekende waarden met None beschrijven
Een mogelijk ontbrekend resultaat met een union annoteren.
Typeverbanden met generieke functies beschrijven
Een echte typeparameter in een functiedefinitie gebruiken.
Een gedragscontract benoemen met Protocol
Een echt Protocol met een methodedeclaratie maken.
Een bron en haar iterator onderscheiden
De voortgang van een bestaande iterator gebruiken.
Waarden pas leveren wanneer ze nodig zijn
Een echte generator stapsgewijs waarden laten leveren.
Een blok met openen en opruimen verbinden
Enter- en exitgedrag met echte foutgegevens implementeren.
Modules en tooling
32 praktische stappen · 275 min
Code over echte modules verdelen
Een eigen Pythonbestand als module importeren.
Importeren scheiden van een programma starten
De bijzondere naam __main__ uitleggen.
Modules groeperen in een pakket
Bestanden en volledige modulenamen met elkaar verbinden.
Een project beschrijven met pyproject.toml
Projectidentiteit en Pythonvereisten vastleggen.
Een eigen Pythonomgeving gebruiken
Een virtuele omgeving met de bestaande Python maken.
Met uv vastleggen, installeren en uitvoeren
Projectafspraken en een gegenereerde lockfile onderscheiden.
Standaardgereedschap en een echte afhankelijkheid
JSON met de standaardbibliotheek verwerken.
Een eigen installeerbaar CLI-pakket
Herbruikbare regels en commandoregelinvoer scheiden.
Testen
32 praktische stappen · 255 min
Een test moet een fout kunnen vinden
Een concrete verwachting met assert controleren.
Meerdere controles met unittest organiseren
Testmethoden in een unittest.TestCase verzamelen.
Echte testfuncties met pytest uitvoeren
Losse testfuncties door pytest laten vinden.
Eén afspraak met meerdere gegevens testen
Met pytest.mark.parametrize aparte testgevallen maken.
Iedere test met verse gegevens laten beginnen
Een pytest-fixture via een functieparameter aanvragen.
De juiste fout verwachten en andere fouten laten opvallen
Met pytest.raises een afgesproken fout verwachten.
Testgegevens kiezen rond groepen en grenzen
Invoer verdelen in groepen met verschillend afgesproken gedrag.
Tijd en uitvoer voorspelbaar testen met afhankelijkheden
Een klok en schrijver als functieargument doorgeven.
Bestanden en I/O
32 praktische stappen · 240 min
Een pad benoemen en de tekst van een bestand lezen
Een Path gebruiken voor bestandsnaam en extensie.
Bestanden in de juiste modus openen en weer sluiten
Lezen, vervangen, toevoegen en exclusief aanmaken onderscheiden.
Regels lezen en op tijd sluiten
Regels zonder afsluitende newline en met overige witruimte verzamelen
CSV lezen en schrijven zonder velden te verliezen
CSV met komma’s en aanhalingstekens verwerken
JSON-documenten bewaren en gericht fouten afhandelen
Geneste JSON-gegevens lezen en schrijven
Mappen doorzoeken en resultaten voorspelbaar ordenen
Gesorteerde relatieve bestandslijststrings met / teruggeven
Binaire bestanden byte voor byte behouden
Binaire I/O onderscheiden van tekstdecodering
Een nieuwe bestandsversie voorbereiden en veilig publiceren
Voorbereiden en publiceren van één bestand scheiden
Concurrency
32 praktische stappen · 240 min
Een coroutine maken en echt uitvoeren
Het verschil tussen een coroutinefunctie, een coroutineobject en een resultaat uitleggen.
Onafhankelijk werk als taken starten
Een coroutine met create_task als Task laten plannen.
Meerdere resultaten verzamelen met gather
Resultaten van onafhankelijke coroutines in de invoervolgorde verzamelen.
Verwant werk samen beheren met TaskGroup
Taken binnen een async context een gezamenlijke levensduur geven.
Stoppen afwachten en eigen middelen opruimen
Annulering als verzoek onderscheiden van een direct gestopte taak.
Wachten begrenzen zonder fouten te verwarren
Een async bewerking met een timeoutcontext begrenzen.
Werk begrenzen met een queue en tegendruk
Een begrensde async queue als FIFO-tussenbuffer gebruiken.
Een begrensde pipeline samenstellen
Een producent en een vast aantal workers met een begrensde queue verbinden.
Idiomatisch en performance
32 praktische stappen · 240 min
Samenhang zichtbaar maken met enumerate en zip
Een positie en waarde samen verwerken zonder een losse teller.
Een sortering uitleggen met een sleutel
Een nieuwe gesorteerde lijst van sorteren ter plaatse onderscheiden.
Alleen invoer lezen die je nodig hebt
Een begrensd voorstuk zonder extra bronlezing opvragen.
Functies uitbreiden zonder hun contract kwijt te raken
Een callable met een closure omwikkelen en argumenten doorgeven.
Functies voorbereiden en een toestand opbouwen
Een echte partial met vooraf ingevulde keywordargumenten maken.
Een herhaalbare meting opzetten met timeit
Totale meettijd van tijd per uitvoering onderscheiden.
Rekenwerk bewaren en de geheugenkosten begrijpen
Een lru_cache met maximaal twee bewaarde aanroepen gebruiken.
Een prijsrapport verbeteren en het gedrag bewijzen
Herhaalde zoekrondes door een prijsindex vervangen.
Eindproject: Urenrapport
32 praktische stappen · 280 min
Van projecteisen naar een invoercontract
Een projectafspraak onderscheiden van wat Python toevallig kan lezen.
Lezen, rekenen en schrijven verbinden
De regie over een programma onderscheiden van de afzonderlijke taken.
Een registratie als gecontroleerde waarde
Samenhangende projectgegevens in een frozen dataclass bewaren.
Een CSV-bron lezen met duidelijke foutcontext
De afgesproken CSV-kop en iedere gegevensrecord valideren.
Registraties selecteren en controleerbaar optellen
Een volledig rapport met metadata en teamtotalen opbouwen.
Een rapport eerst opbouwen en daarna publiceren
Een gewone uitvoernaam en het gekozen formaat controleren.
Een CLI met echte argumenten, uitvoer en foutstatus
Posities en opties naar de bestaande projectfuncties vertalen.
De hele opdracht met echte regressietests bewaken
Een volledige CLI-opdracht met echte bestanden testen.