In Python kun je werken met funkties om bepaalde taken eenmalig te definiëren en dan vaker gebruiken of om structuur in programmaś te brengen door taken seperaat af tehandelen. De funkties kunnen dan weer in je hoofdprogramma als zwarte doos (blackbox) aan te roepen.
Maar als je nu een funktie schrijft, die je in meerdere progrmma's zou willen gebruiken, dan is het niet zo prettig om de funktie als programma code in jouw programma te zetten. Bij het aanpassen/verbeteren van een funktie geeft dit namelijk een probleem, omdat je dan in elk programma welke de betreffende funktie gebruikt dezelfde code aaan moet passen. Behalve dat dit enorm saai werk is, wordt de kans op verschillen in de diverse programma's groter.

Daarom is het mogelijk om in Python zogenaamde modules te maken, waarbij je de funkties die je ontwikkeld in een apparte python file te zetten en de funkties te gebruiken in jouw programma's, zonder de code telkens zelf opnieuw toe te moeten voegen. Het gebruiken van funkties uit zo'n module noemen we “importeren” (toevoegen).

[Programmeren met Python] [sbczob.eu]

Je hebben reeds een aantal funkties gemaakt en die funkties wil je in een nieuw programma gaan gebruiken:

• totZiens()
• maximaal()
• wisselOm()
• leesGetal()
• somGetallen()

Nu wil je een module maken, die een aantal van deze funkties bevat. Daarvoor open je een nieuw code bestand en zet de code van de betreffende funkties in dat bestand! Als alle gewenste funkties in het nieuwe bestand staan, schrijf het dan weg met een door jouwzelf gekozen bestandsnaam met extensie “.py” (bijvoorbeeld “mijnfunkties.py”.

mijnfunkties.py

# ============================
# Module naam: mijnfunkties.py
 
def totZiens():
    print("Tot ziens!"
 
def maximaal(a,b):
    if a > b:
        return a         # Met een return, verlaat je direct de funktie
    else:
        return b
 
def wisselOm(a,b):
    return b,a           # Simpelweg de volgorde aanpassen, werkt ook!

Zorg ervoor dat het python bestand wordt opgeslagen in dezelfde lokatie, als waar jouw programma bestanden staan, of zorg ervoor dat ze in een folder staat, waar python zijn module bestanden kan vinden,

Met modules kun je nu zelf een bibliotheek van bij elkaar horende funkties maken, door de gemaakte modules een logische naam te geven. Dit is eigenlijk hetzelfde wat andere mensen hebben gedaan met beschikbare python modules, zodat jij die modules ook kunt gebruiken, zonder dat je de onderliggende code hoeft te kennen.

[top] [Programmeren met Python] [sbczob.eu]

Je hebt nu de module “mijnfunkties.py” gemaakt en het module bestand is beschikbaar voor de python interprenter. Om de funkties te kunnen gebruiken, moet je ze in jouw programma bestand bekendbaar maken, oftewel importeren. Stel we willen de funktie totZiens gebruiken in ons programma, dan kunnen we die op twee manieren importeren:

1. Door het importeren van de hele module, aanroepen met <modulenaam>.<funktienaam>
2. Door het importeren van een of meerdere funkties uit de module, aanroepen met <funktienaam>

Beide methodes zijn goed, afhankelijk van je eigen voorkeur. Let op, mocht je uit twee verschillende modules funkties met dezelfde naam nodig hebben, dan moet uiteraard de éérste methode gekozen worden, daar de python interprenter anders niet weet welke funktie gebruikt moet worden.

Een voorbeeld van de eerste methode, waar we gebruik gaan maken van de funktie maximaal() uit de mijnfunkties module. Daarvoor gaan we de hele module importeren, waarbij je simpelweg de module bestands naam neemt, zonder de extentie “.py”. De eerste regel van het programma importeer je de complete module, waardoor alle aanwezige funktie in de module in het programma beschikbaar komen. In je code gebruik je impliciet de maximaal funktie uit de mijnfunkties module door de referentie mijnfunkties.maximaal().

import mijnfunkties        # Maak alle funkties uit de mijnfunkties module bekend
 
a = 10
b = 20                     # Roep de specifieke funktie aan door te refereren naar de module.
print("A:", a, "B:", b," De hoogste waarde van deze twee getallen is:", mijnfunkties.maximaal(a,b))

Ook voor de tweede methode een voorbeeld. Daarbij zullen we de funktie wisselom() gaan gebruiken, maar nu door alleen deze specifieke funktie te importeren. Daarvoor moet je de interprenter vertellen van welke module je een (of meerdere) specifieke funktie(s) wilt gebruiken. In de eerste regel van onderstaand programma benoem je dus de funktie die je wilt importeren uit de module, waarin die funktie staat. Daarna gebruik je dus de funktie, zonder dat de module nog benoemd moet worden met referentie wisselom().

from mijnfunkties import wisselOm         # Maak de funktie wisselOm() uit de mijnfunkties module bekend
 
x = 10
y = 20
print("Voor wisselOm: X=", x, "en Y=", y)
x,y = wisselOm(x,y)                       # Hier gebruiken we de wisselOm() funktie
print("Na wisselOm: X=", x, "en Y=", y)

Wat je nu heel goed kan zien, de funkties hier echt als een zwarte doos gebruikt worden. Omdat je de funktie importeerd, zie je ook echt niet meer wat ze doet en zou je in de specifieke module moeten duiken om de werking te achterhalen!

[top] [Programmeren met Python] [sbczob.eu]

Ik ga hier nu een toetsenbord module specificeren, die de invoer leest en alleen terugkeert met de invoer waarde als het juiste type wordt ingelezen. Hiervoor bouw ik drie funkties:

• leesTekst(tekst): Lees een tekst van het toetsenbord (string)
• leesGetal(tekst): Lees een (gebroken) getal van het toetsenbord (float)
• leesGeheelGetal(tekst): Lees een geheel getal van het toetsenbord (integer)

Alle drie de funkties komen alleen maar terug met de type variabele (string, float of integer) wat je wilt hebben. Verder hebben ze maar één parameter:

• tekst: Deze parameter bepaalt de tekst die je wilt laten zien voordat de invoer plaats vindt.

Wat verder opvalt, is dat de drie funkties van elkaar gebruik maken. LeesTekst() komt met een string terug, die je in leesGetal() gebruikt om er een getal van te maken. In leesGeheelGetal() hoef je dan alleen nog te controleren, of het ingegeven getal ook een geheel getal is ¹⁾! Daardoor hoef je niet meer in elke funktie opnieuw het wiel uit te vinden!

toetsenbord.py

# ===========================
# Module naam: toetsenbord.py
 
def leesTekst(tekst):                         # Lees een tekst van het toetsenbord
    return (input(tekst))                     # Elke willekeurige tekst wordt geaccepteerd,
                                              # er is dus geen verdere controle nodig
 
def leesGetal(tekst):                         # Lees een getal van het toetsenbord
    while True:
        try:
            x = float(leesTekst(tekst))       # Lees een willekeurige tekst in
        except:                               # Er is geen getal ingevoerd
            print("Dit is geen getal!")
            continue                          # Nieuwe invoer nodig
        else:
            break                             # Er is een correct getal ingegeven
                                              # en geconverteerd naar een float
    return x
 
def leesGeheelGetal(tekst):                   # Lees een geheel getal van het toetsenbord
    while True:
        i = leesGetal(tekst)                  # Lees een (float) getal in
        if i % 1 != 0:                        # Controleer op een geheel getal
            print("Dit is geen geheel getal")
            continue                          # Opnieuw invoeren
        i = int(i)                            # Converteer naar integer
        break
    return i

Voel je uiteraard vrij, om deze module in een van jouw programma's te gebruiken. Uiteraard kun je de module ook naar behoeve aanpassen.

Ik kan nu een programma maken, wat de invoer van het toetsenbord inleest, gebruikmakend van de module als zwarte doos. Met dit programma'tje, besluit ik dit hoofdstuk.

invoer.py

#! /usr/bin/env python3
# =========================
# Programma naam: invoer.py
 
import toetsenbord
 
s = leesTekst("Geef een tekst: ")
f = leesGetal("Geef een getal: ")
i = leesGeheelGetal("Geef een geheel getal: ")
 
print("Ingegeven string:", s)
print("Ingegeven float:", f)
print("Ingegeven integer:", i)
print("Klaar")

[top] [Programmeren met Python] [sbczob.eu]