De Programmeursleerling (2019–2020)

Pieter Spronck

de programmeursleerling

In deze interactieve cursus leer je programmeren in Python 3. Daarbij gaan we ervan uit dat je nog geen enkele ervaring hebt met programmeren. Het leermateriaal is gebaseerd op het boek De programmeursleerling van Pieter Spronck (Tilburg University).

Leerkrachten die met deze cursus aan de slag willen gaan, nemen best ook even de documentatie door.

Boek als PDF lezen
ENGLISH VERSION

Je bent niet geregistreerd voor deze cursus.

Registreren

Oefeningenreeksen

Computers zijn prachtige machines. De meeste machines (auto’s, televisies, magnetrons) zijn gemaakt voor een specifiek doel dat ze effectief en efficiënt kunnen bereiken. Computers daarentegen zijn doelloze machines, die alles wat je maar wilt aangeleerd kunnen krijgen. De kunde die je in staat stelt om computers te laten doen wat je wilt, heet “programmeren.”

In iedere wetenschappelijke richting en in elk beroep, moeten mensen vandaag de dag omgaan met grote hoeveelheden data. Zij die in staat zijn de kracht van computers in te zetten om gebruik te maken van die data, met andere woorden, zij die kunnen programmeren, zijn veel beter in staat hun beroep uit te oefenen dan zij die dat niet kunnen. Ik durf zelfs te stellen dat in de zeer nabije toekomst zij die niet kunnen programmeren niet meer arbeidsgeschikt zijn. Daarom zie ik het als een noodzaak dat iedereen tijdens zijn of haar opleiding leert programmeren.

Programmeren betekent niet alleen dat je weet wat programmeerregels doen; het betekent ook dat je kunt denken als een programmeur, en dat je problemen kunt analyseren vanuit het perspectief dat ze opgelost moeten worden door een computer. Deze vaardigheden kun je niet leren uit een boek. Je kunt ze alleen leren door daadwerkelijk programma’s te maken.

Dit boek is geschreven om je de basis van de Python 3 computertaal te leren. Studenten leren met dit boek niet alleen de taal te gebruiken, maar doen er ook oefeningen mee.

Het boek is niet alleen bedoeld voor studenten die vanuit zichzelf al kunnen en willen programmeren. Het is ook en misschien zelfs vooral bedoeld voor hen voor wie programmeren een vreemde taak is. De teksten in dit boek zijn vaak uitgebreider dan je in andere boeken tegenkomt, en proberen problemen te voorzien die je tegen kunt komen wanneer je nieuwe concepten probeert te begrijpen.

Zoals ik heb uitgelegd in de introductie, zul je Python code moeten schrijven om te kunnen leren met dit boek. Dat betekent dat je een computer nodig hebt waarop Python geïnstalleerd is, en je moet weten hoe je Python programma’s kunt schrijven. Dit hoofdstuk legt uit hoe je Python aan het werk krijgt.

Welkom bij het eerste echte programmeerhoofdstuk. In dit hoofdstuk bespreek ik expressies, die je kunt beschouwen als berekeningen die je ook kunt uitvoeren met een simpele rekenmachine. Het is een klein begin, maar deze expressies ga je nodig hebben in alle volgende hoofdstukken.

Als je met code werkt, ben je vaak bezig met het ontwerpen van een procedure (of “algoritme”) dat een probleem op een algemeen toepasbare manier oplost. Bijvoorbeeld, in opgave 3.1 moest je de prijs van 60 boeken uitrekenen. De code die je schreef lost het probleem alleen op voor precies 60 boeken voor een bepaalde prijs. Als je een dergelijk probleem algemener wilt oplossen, moet je variabelen gebruiken om waardes in op te slaan.

Ik heb in de voorgaande hoofdstukken al gesproken over een aantal basis “functies,” zoals print() en int(). In dit hoofdstuk worden deze functies in meer detail besproken, en zal ik een aantal nieuwe functies introduceren die nuttig gaan zijn in de volgende hoofdstukken. In hoofdstuk 8 ga ik bespreken hoe je je eigen functies kunt maken.

In een programma zijn er vaak regels code die je alleen wilt uitvoeren onder bepaalde omstandigheden. Om dat te regelen, bieden alle programmeertalen zogeheten “conditionele statements” of “condities.” In dit hoofdstuk leg ik uit hoe condities werken in Python.

Computers raken niet verveeld. Als een computer een taak honderdduizenden malen moet herhalen, protesteert hij niet. Mensen daarentegen houden niet van teveel herhaling. Daarom moeten herhalende taken aan een computer worden overgelaten. Alle programmeertalen ondersteunen herhalingen. De klasse programmeerconstructies die herhalingen mogelijk maken heten “iteraties.” Een veelgebruikte term is “loops” (Engels, spreek uit: “loeps” – dit woord kun je netjes vertalen als “lussen,” maar dat zeggen programmeurs nooit).

Dit hoofdstuk legt uit wat je moet weten over loops in Python. Als programmeren helemaal nieuw voor je is, zul je wellicht het gevoel krijgen dat loops een lastig onderwerp zijn. Als dat zo is, neem dan de tijd voor dit hoofdstuk, en werk eraan totdat je zeker weet dat je alles snapt. Loops zijn zo’n basaal programmeerconcept dat je ze goed moet begrijpen. Elk hoofdstuk dat hierna komt maakt gebruik van loops.

In hoofdstuk 5 beschreef ik hoe je eenvoudige functies kunt gebruiken, en hoe je functies kunt importeren uit modules. Dit hoofdstuk beschrijft hoe je je eigen functies en modules kunt creëren. Als je niet meer weet wat hoofdstuk 5 over functies zei, doe je er goed aan om dat hoofdstuk nogmaals door te nemen.

Recursie is een speciale techniek die je kunt gebruiken nu je geleerd hebt om functies te maken. Recursie kan bepaalde problemen op een elegante en krachtige manier oplossen, maar studenten vinden het vaak een lastig onderwerp. Daarom heb ik er een apart hoofdstuk aan gewijd. Als je bij bestudering van dit hoofdstuk denkt dat het te ingewikkeld voor je is, voel je dan vrij om het voorlopig over te slaan. Je kunt naderhand bij dit hoofdstuk terugkomen. De volgende hoofdstukken zijn weer een stuk gemakkelijker.

Tot nu toe gebruikten de meeste voorbeelden en opgaves getallen. Je hebt je misschien afgevraagd of programmeren vooral bedoeld is voor het manipuleren van getallen. In het dagelijks leven is het veel gebruikelijker om met tekstuele informatie om te gaan.

De reden dat de omgang met teksten was uitgesteld tot nu, is dat in programmeertalen het veel gemakkelijker is om met getallen om te gaan dan met teksten. Maar in dit hoofdstuk leg ik uit hoe je teksten kunt manipuleren met programma’s.

In programmeeromgevingen worden teksten weergegeven door strings. Dit hoofdstuk geeft details over strings, en over functies die beschikbaar zijn om strings aan te pakken.

Een tuple is een groep van één of meer waardes die als een geheel behandeld worden. Dit hoofdstuk legt uit hoe je tuples kunt herkennen en gebruiken.

Een “list” (Engelse woord voor “lijst”) is een geordende verzameling van data items, net zoals een tuple. Het verschil tussen lists en tuples is dat lists veranderbaar zijn. Dit maakt ze tot een zeer flexibele data structuur, waar je op veel manieren gebruik van kunt maken.

Strings, tuples en lists zijn geordende data structuren, wat inhoudt dat ze via indices benaderd kunnen worden. Maar niet alle data verzamelingen hebben een natuurlijke manier van numeriek geordend zijn, en deze kunnen dus niet (gemakkelijk) geïndiceerd worden. Python biedt “dictionaries” als een manier om ongeordende data te structureren.

Sets zijn ongeordende data structuren die alleen unieke elementen kunnen bevatten. Slechts weinig programmeertalen ondersteunen het gebruik van sets, maar Python doet het wel. Sets worden niet vaak gebruikt, maar kunnen soms een leuke oplossing geven voor een probleem.

Tot nu toe heb ik Python programma’s behandeld als functionaliteiten die los staan van alles wat zich buiten het programma bevindt. Python programma’s draaien echter op een computer, en zo nu en dan moet een programma omgaan met de eigenschappen van een specifieke computer. Vanaf hoofdstuk 16 gaat dit een belangrijke rol spelen, omdat ik dan het omgaan met bestanden ga behandelen. Om met de eigenschappen van een specifieke computer te kunnen omgaan, introduceert Python een aantal functies in de os module, waar os de afkorting is voor “operating system” (besturingssysteem). Dit hoofdstuk bespreekt de belangrijkste functies uit de os module.

Eén van de belangrijkste toepassingen van Python voor dataverwerking is het lezen, wijzigen, en schrijven van tekstbestanden. Data wordt vaak opgeslagen in tekstbestanden, omdat dit soort bestanden gemakkelijk tussen verschillende programma’s overgedragen kan worden. Er zijn meerdere standaard bestandsformaten voor tekstbestanden, zoals “comma-separated values” (CSV) bestanden. Python ondersteunt een aantal van die formaten via modules, waarvan ik sommige later zal bespreken. Dit hoofdstuk focust op het openen, lezen, schrijven, en sluiten van willekeurige bestanden, ongeacht het formaat.

Soms treden runtime errors op niet omdat je een programmeerfout hebt gemaakt, maar omdat er een probleem optreedt dat je niet kon voorzien toen je het programma schreef. Dit is buitengewoon relevant als je met bestanden werkt: bijvoorbeeld, als je een bestand verwerkt dat op een USB-stick staat, en de gebruiker verwijdert de USB-stick tijdens de verwerking, krijg je uiteraard een fout die je niet echt zou kunnen voorzien in je code. Iedere runtime error genereert in de code een zogenaamde “exception” (“uitzondering”) die je kunt “afvangen.” Het afvangen van een exception betekent dat je in je programma code opneemt die ervoor zorgt dat de opgetreden fout zoveel mogelijk netjes wordt afgehandeld, in plaats van je programma abrupt af te breken.

“Binaire bestanden” is de term die gebruikt wordt om te refereren aan alle bestanden die geen tekstbestanden zijn. Uitvoerbare programma’s zijn binaire bestanden, evenals plaatjes, films, tekstverwerker documenten, en vele andere bestandstypes. Het is niet gebruikelijk om binaire bestanden af te handelen met Python code (voor veel soorten binaire bestanden zijn gerichte programma’s geschreven om ze te bewerken – denk bijvoorbeeld aan een programma als GIMP of Photoshop om plaatjes te bewerken), maar het is wel mogelijk. Dit hoofdstuk legt uit hoe je met binaire bestanden omgaat.

Hoofdstuk 18 besprak het omgaan met binaire bestanden. Wanneer je binaire bestanden gebruikt, ben je niet langer bezig met tekens en getallen, maar je werkt met bytes. Om informatie op het niveau van bytes te verwerken, biedt Python een aantal zogeheten “bitsgewijze operatoren.” Je hebt deze operatoren niet vaak nodig, maar als je binaire bestanden gaat bewerken kunnen ze van pas komen.

De hoofdstukken tot dit punt bespraken een manier van programmeren die vaak “gestructureerd programmeren” of “imperatief programmeren” genoemd wordt. Deze aanpak betreft programma’s die bestaan uit een sequentie van statements, beslissingen, en loops. Je kunt ieder programmeerprobleem oplossen middels deze aanpak. In de laatste decennia echter zijn er andere programmeer “paradigma’s” ontwikkeld, die helpen bij het ontwerpen en implementeren van grote programma’s. Een van de meest succesvolle paradigma’s is “object oriëntatie,” en de meeste moderne programmeertalen ondersteunen dit paradigma. Python is eigenlijk een object-georiënteerde taal.

Hoewel object oriëntatie een natuurlijke manier biedt om problemen en oplossingen te bezien, is het behoorlijk lastig om een object georiënteerd programma te ontwerpen. De reden dat het lastig is, is dat je het probleem dat je onderhanden hebt moet doorgronden in al zijn aspecten, voordat je begint met programmeren. Voor de meer complexe problemen kan dit behoorlijk overweldigend zijn, zeker als je weinig ervaring hebt met programmeren. Maar voor de grotere problemen moet je zowiezo veel tijd besteden aan het analyseren van je oplossing, en de object georiënteerde aanpak kan dan behulpzaam zijn bij het creëren van die oplossing. Je zult ook ontdekken dat de meeste modules object georiënteerd zijn opgezet, en dat object oriëntatie ook nuttig kan zijn bij de aanpak van kleinere problemen.

Omdat object oriëntatie een erg breed onderwerp is, ga ik er meerdere hoofdstukken aan besteden, waarvan dit de eerste is. Dit hoofdstuk bediscussieert de basis van object oriëntatie, en laat de meer gespecialiseerde (en krachtige!) aspecten van object oriëntatie over aan latere hoofdstukken.

“Operator overloading” is een ongelofelijk krachtige techniek die object oriëntatie meedraagt, waarmee je op een natuurlijke manier nieuwe data types (classes) in een programma kunt integreren. Operator overloading is altijd gebaseerd op de definitie van een aantal speciale methodes, die de typische __<naam>__() structuur hebben.

Overerving (Engels: “inheritance”) is een mechanisme om een nieuwe class te baseren op een bestaande class, door enkel en alleen de verschillen tussen de twee aan te geven. Dit is een bijzonder krachtig concept dat het mogelijk maakt hoogst flexibele en gemakkelijk onderhoudbare programma’s te schrijven.

Iteratoren maken het mogelijk ervoor te zorgen dat je een zelf-gedefinieerde class kunt gebruiken in for … in … statements. Generatoren zijn een eenvoudige manier om iteratoren te creëren.

In hoofdstuk 15 merkte ik op dat als je grote hoeveelheden data wilt verwerken die verspreid is over meerdere bestanden, je soms Python programma’s wilt schrijven die in de command shell draaien. Dit wordt command line verwerking genoemd. Dit hoofdstuk beschrijft hoe je dat moet aanpakken.

Als je een probleem moet oplossen met tekstanalyse, data verwerking, het zoeken van patronen in grote data verzamelingen, of het filteren van data uit webpagina’s, en je zoekt op het Internet naar een oplossing voor het probleem, dan zul je zien dat het eerste antwoord dat meestal op vragen hierover gegeven wordt is “Waarom gebruik je geen reguliere expressies?” of zelfs “Gebruik gewoon regex,” zonder verdere uitleg. Dat zijn nogal zelfingenomen antwoorden, aangezien maar weinig mensen de term reguliere expressies kennen, en zelfs als ze hem kennen, ze reguliere expressies vaak eng en onbegrijpelijk vinden. En het is waar dat op het eerste gezicht reguliere expressies zo esoterisch en verwarrend zijn dat de meeste mensen liever besmuikt wegsluipen dan er tijd aan te besteden. Wat jammer is, daar reguliere expressies een krachtig hulpmiddel zijn dat niet mag ontbreken in de gereedschapskist van eenieder die regelmatig moet omgaan met tekstuele data.

In dit hoofdstuk leg ik uit hoe je basale reguliere expressies schrijft en gebruikt met Python. Je zult ontdekken dat ze een krachtige manier bieden om snel complexe patronen in data te identificeren, en toegang geven tot functionaliteiten die in gewoon Python lastig te implementeren zijn. Hoewel dit hoofdstuk geen compleet overzicht verschaft over reguliere expressies, zul je aan het einde ervan voldoende begrijpen om de meeste, zo niet alle problemen rondom het identificeren van patronen in teksten op te kunnen lossen, en je kunt beginnelingen toespreken met de woorden: “Je moet reguliere expressies gebruiken om je problemen op te lossen.” Nu kun jij ook zelfingenomen zijn!

Data is meestal opgeslagen in bestanden, die geconstrueerd zijn volgens een specifiek bestandsformaat. Gestandaardiseerde bestandsformaten worden door Python vaak ondersteund door een module. In dit hoofdstuk beschrijf ik een aantal veelgebruikte bestandsformaten en de modules die ze ondersteunen.

Op dit punt in het boek heb ik min of meer alles wat je echt moet weten om een goede Python programmeur – of misschien zelfs een goede programmeur in het algemeen – te zijn aan de orde gebracht. Ik wil nu nog snel een aantal nuttige modules naar voren brengen die geen eigen hoofdstuk nodig hebben. Ik ga niet veel details geven; als je eenmaal weet wat het nut van een module is, kun je er meer informatie over vinden in de Python handleiding.