Python Module Importeren – Praktische Gids met Voorbeelden

Wat zijn Python Modules?

Een module is een enkel Python-bestand dat variabelen, functies en klassen kan bevatten. Wanneer je het bestand guru99.py noemt, wordt de module benaderd als guru99. Modules laten je een groot programma opsplitsen in logische stukjes, zodat je code georganiseerd en herbruikbaar blijft.

Waarom modules importeren?

Om code te gebruiken die in een ander bestand is gedefinieerd, moet je het importeren. Importeren geeft je toegang tot de functies, klassen en variabelen van de module, net als het import-sleutelwoord in talen zoals JavaScript, Java of Ruby.

Een module maken en importeren

Laten we door een simpel voorbeeld lopen.

Mapstructuur:

modtest/
    test.py
    display.py

1. Maak test.py:

def display_message():
    return 'Welkom bij Guru99 Tutorials!'

2. Maak display.py en importeer test:

import test
print(test.display_message())

Het uitvoeren van display.py print:

Welkom bij Guru99 Tutorials!

Een klasse importeren uit een module

Stel Car.py definieert een autoklasse:

class Car:
    brand_name = 'BMW'
    model = 'Z4'
    manu_year = '2020'

    def __init__(self, brand_name, model, manu_year):
        self.brand_name = brand_name
        self.model = model
        self.manu_year = manu_year

    def car_details(self):
        print('Automerk is', self.brand_name)
        print('Automodel is', self.model)
        print('Autofabrikatiejaar is', self.manu_year)

    def get_car_brand(self):
        print('Automerk is', self.brand_name)

    def get_car_model(self):
        print('Automodel is', self.model)

Gebruik het in display.py:

import Car
car_det = Car.Car('BMW', 'Z5', 2020)
print(car_det.brand_name)
car_det.car_details()
car_det.get_car_brand()
car_det.get_car_model()

Output:

BMW
Automerk is BMW
Automodel is Z5
Autofabrikatiejaar is 2020
Automerk is BMW
Automodel is Z5

from gebruiken om specifieke items te importeren

Wanneer je maar een paar functies of variabelen nodig hebt, importeer ze direct:

from test import display_message
print(display_message())

Als je probeert een naam te gebruiken die niet geïmporteerd is, geeft Python een NameError:

from test import display_message
print(display_message1())

Alles importeren uit een module

Importeer de gehele module met import test en prefix namen met de module, of importeer alle namen in de huidige namespace met from test import *. Het laatste is handig maar kan de namespace vervuilen.

dir() begrijpen

De ingebouwde dir()-functie lijst alle attributen van een object, inclusief die gedefinieerd in een module:

import Car
print(dir(Car))

Voor standaardbibliotheken:

import json
print(dir(json))

Werken met packages

Een package is een directory met een __init__.py-bestand en een of meer modules. Bijvoorbeeld:

Directory-indeling:

mypackage/
    __init__.py
    module1.py
    module2.py
    module3.py

In module1.py:

def mod1_func1():
    print('Welkom bij Module1 functie1')

def mod1_func2():
    print('Welkom bij Module1 functie2')
# …

Importeren met een alias:

import mypackage.module1 as mod1
mod1.mod1_func1()
mod1.mod1_func2()

Python Module Zoekpad

Wanneer Python een import oplost, controleert het:

1. De huidige werkdirectory.
2. Ingebouwde modules.
3. Directories in sys.path.

Inspecteer het met:

import sys
print(sys.path)

Aliassen voor modules gebruiken

Geef een module een kortere naam voor betere leesbaarheid:

import test as t
print(t.display_message())
print(t.my_name)

Absolute vs. Relatieve Imports

In een multi-module project kun je modules benaderen via hun volledige pad (absolute) of relatief ten opzichte van het huidige bestand.

Absolute Import Voorbeeld

from package1.module1 import myfunc1
# of
import package1.module1
package1.module1.myfunc1()

Relatieve Import Voorbeeld

from .module1 import myfunc1
# of
from .subpkg.module3 import myfunc3

Absolute imports zijn duidelijker en minder foutgevoelig wanneer een project wordt verplaatst, maar kunnen verbose worden. Relatieve imports houden code beknopt maar kunnen lastiger te traceren zijn in grote projecten.

Belangrijkste leerpunten

• Modules laten je Python-code opsplitsen in aparte bestanden.
• Gebruik import of from … import … om toegang te krijgen tot module-inhoud.
• Aliassen (as) maken lange modulenamen makkelijker te hanteren.
• Packages organiseren modules in directories, met __init__.py als markering.
• Begrijp sys.path om import-fouten op te lossen.
• Kies absolute imports voor duidelijkheid, relatieve imports voor beknoptheid.