Modules schrijven in Python 3: Een handleiding

Introductie

Python is een van de meest gebruikte programmeertalen ter wereld. Modules zijn een cruciaal onderdeel van de Python-code. Een module is simpelweg een .py bestand in de context van Python 3. Dit betekent dat je naar elk Python-bestand kunt verwijzen als een module.

Het is mogelijk om deze modules te verkrijgen via de vooraf samengestelde bibliotheek. Je kunt een kijkje nemen in de Python Standard Library om meer te leren. Deze worden op je systeem geïnstalleerd wanneer je Python installeert. In andere situaties kun je deze modules installeren met de Python-pakketbeheerder pip. Maar wat als je een aangepaste module wilt maken? Als dat het geval is, dan zul je blij zijn te horen dat je je eigen modules kunt maken in Python.

In deze gedetailleerde gids zullen we de stappen schetsen die je moet volgen om modules te schrijven en te importeren in Python 3.

Vereisten

Voordat we beginnen, moet je ervoor zorgen dat je Python 3 hebt geïnstalleerd en een programmeeromgeving hebt ingesteld. Je kunt onze tutorial on installing Python 3 and setting up a local programming environment on Ubuntu 16.04 volgen om de installatie te voltooien voor het geval je deze nog niet klaar hebt.

Hoe schrijf je een module?

Laten we beginnen met het schrijven van een module. Je schrijft een module net zoals je elk ander Python-bestand zou samenstellen. Een typische module bestaat uit de definities van de functies, klassen en variabelen. Vervolgens kun je de module gebruiken om toe te passen op andere Python-programma's.

Om je te helpen het te begrijpen, nemen we een voorbeeld. Laten we zeggen dat we een bestand willen maken met de naam hello.py. We zullen dit later ook in een ander bestand importeren. De eerste stap in het proces is het maken van een functie. Deze functie dient om Hello, World! te printen, zoals dit:

Op dit punt zal het uitvoeren van het python hello.py commando je geen resultaat geven. Dit komt omdat we het programma nog geen instructies hebben gegeven. Om het te laten werken, moeten we de module importeren.

Hoe importeer je een module?

Om je module te importeren om er een functie van te maken, moet je een tweede bestand in dezelfde map maken. We noemen dit nieuwe bestand main_program.py. De reden waarom beide bestanden in dezelfde map moeten staan, is dat we het programma moeten vertellen waar het de module kan vinden. Dit is van toepassing op elke nieuwe, aangepaste module die niet is ingebouwd:

We hebben puntnotatie gebruikt voor de modulenaam om de functie aan te roepen. Een andere manier om dit te doen is door de from...import-methode te gebruiken. Hier roepen we de functie aan als world() door de module te importeren als from hello import world. Ten slotte kun je het commando uitvoeren:

Het commando toont je de volgende uitvoer:

Variabelen toevoegen aan een module

Vervolgens zullen we zien hoe we variabelen aan de module kunnen toevoegen door definities in de module te plaatsen:

Vervolgens roep je de variabele aan in de print()-functie. We roepen deze aan binnen het main_program.py bestand:

Het uitvoeren van het programma toont deze uitvoer:

Een klasse toevoegen aan een module

Ten slotte zullen we zien hoe je een klasse in je bestand kunt definiëren voor de module. Als we ons voorbeeld voortzetten, maken we een nieuwe klasse genaamd Octopus in het hello.py-bestand. We zullen deze ook de attributen name en color toewijzen. Vervolgens voegen we een functie toe om deze printbaar te maken:

Vervolgens moet je de klasse toevoegen aan het einde van het main_program.py bestand:

Je kunt de klasse aanroepen met het hello.Octopus()-commando. Het toont je de functies en attributen van de Octopus-klasse in de namespace van het bestand. Als zodanig kun je jesse.tell_me_about_the_octopus() in de laatste regel schrijven zonder hello aan te roepen. Het is ook mogelijk om een individueel attribuut van de klasse aan te roepen zonder hello te gebruiken. Je kunt bijvoorbeeld simpelweg jesse.color uitvoeren. Wanneer je het programma uitvoert, zal het de volgende uitvoer tonen:

Code implementeren met modules

Waar je modules kunt gebruiken om definities te specificeren, kun je ze ook gebruiken om code te implementeren. Laten we zeggen dat we de world()-functie willen implementeren. We zullen ons initiële hello.py-bestand volledig herschrijven:

Vanuit het main_program.py-bestand zullen we alles verwijderen behalve het import-statement, waardoor het volgende overblijft:

Het uitvoeren van het hoofdprogrammabestand geeft je deze uitvoer omdat het programma de world()-functie implementeert en uitvoert:

Hoe krijg je toegang tot een module vanuit een andere map?

Nu je weet hoe je modules maakt en wijzigt, moet je weten hoe je er toegang toe krijgt vanuit een andere map. Dit is handig wanneer je een bepaalde module in een ander project moet gebruiken. Er zijn twee manieren om dit te doen, die we hieronder zullen uitleggen.

• Paden toevoegen

De eerste methode is om het modulepad te activeren met behulp van de programmabestanden die de module al gebruiken. Helaas betekent dit niet dat de module over het hele systeem beschikbaar zal zijn. Daarom wordt het alleen als een tijdelijke oplossing beschouwd. Het wordt vaak gebruikt tijdens de ontwikkelingsfase van het project.

Je kunt het toevoegingsproces starten door de sys-module en andere belangrijke modules die je moet gebruiken te importeren. We zullen ze importeren in het hoofdprogrammabestand. Je vindt de sys module in de Python Standard Library. Je hebt deze nodig omdat deze de basisparameters en functies bevat die specifiek zijn voor jouw systeem.

Bekijk ons vorige voorbeeld nog eens. Laten we zeggen dat het hello.py-bestand zich op het pad /usr/sammy/ bevindt en het main_program.py-bestand zich in een andere map bevindt. We zullen eerst de hello-module importeren in het main_program.py-bestand met behulp van de sys-module. Vervolgens voegen we /usr/sammy/ toe aan het pad:

Als je het pad correct instelt, zal het main_program.py bestand zal probleemloos en zonder fouten worden uitgevoerd. Je ontvangt dezelfde uitvoer als toen beide bestanden zich in dezelfde map bevonden.

• Python-pad

De andere optie die je kunt kiezen is het Python-pad. Hier voeg je de module zelf toe aan een pad dat Python controleert op modules en pakketten. Zoals je waarschijnlijk kunt afleiden, maakt dit de module systeembreed beschikbaar, wat het een haalbare permanente oplossing maakt.

Om dit te doen, moet je uitzoeken waar Python naar modules zoekt. Je moet de Python-interpreter uitvoeren vanuit de programmeeromgeving, wat er als volgt uitziet:

De volgende stap is het importeren van de sys module:

Druk vervolgens het systeempad af:

Nu zie je een systeempad als uitvoer. Er zal er minstens één zijn. In een programmeeromgeving kunnen dat er echter meerdere zijn. Zoek in de lijst de omgeving op die je gebruikt. Houd er rekening mee dat je de module wellicht ook aan het hoofdsysteempad van Python wilt toevoegen. Dit ziet er als volgt uit:

Verplaats ten slotte het hello.py bestand naar deze map en importeer de module als volgt:

Je poging is geslaagd als het programma het bestand uitvoert zonder fouten te produceren. Als resultaat van dit proces heb je toegang tot de module vanuit elke map op je systeem.

Conclusie

Het doel van deze handleiding was om je vertrouwd te maken met het schrijven van Python-modules. Het is zeer vergelijkbaar met hoe je een ander Python .py bestand. We hebben eerst besproken wat een Python-module en de bijbehorende functies eigenlijk zijn. Vervolgens hebben we ontdekt hoe we deze definities kunnen toepassen in andere programmeerbestanden in Python. Ten slotte hebben we de details van de toegankelijkheid van modules uitgezocht. Nu weet je hoe je modules schrijft in Python 3 en hoe je ze kunt openen.

Om je kennis over de programmeertaal Python verder uit te breiden, raadpleeg onze blog voor meer bronnen:

• Python 3: Een gids voor het converteren van gegevenstypen
• Lussen in Python 3: Het gebruik van Break-, Continue- en Pass-statements
• Python 3 String-formatters gebruiken

Veel programmeerplezier!