Python unter Linux: Module

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Module dienen dazu, zusammengehörige Funktionen und Klassen in Dateien zu gruppieren. Auf diese Weise lassen sich größere Quelltextsammlungen thematisch organisieren.

Aufbau eines Modules[Bearbeiten]

Ein Modul besteht aus einer Folge von Quelltextzeilen. Da Module nicht ausgeführt werden müssen, sparen wir uns die bei den bisherigen Programmen benutzte Interpreterdeklaration in der ersten Zeile:

def HalloWelt():
    print "Hallo, Welt!"

def addiere(a, b):
    return a + b

Ein Programm, welches dieses Modul nutzt könnte wie folgt aussehen:

#!/usr/bin/python
import modul1

print modul1.addiere(1, 2)
Align=none Ausgabe

user@localhost:~$ ./mod1.py
3

Der Präfix vor den Funktionen, die man aus einem Modul aufruft, nennt man Namensraum. Man kann beliebig viele Namensräume durch Module erzeugen, und kommt so bei der Benennung von Funktionen nicht durcheinander, wenn zwei Funktionen den selben Namen tragen.

Es kann auf alle vom Modul exportierten Elemente zugegriffen werden; es gibt keine privaten oder besonders geschützte Funktionen oder Variablen.

Importieren im Detail[Bearbeiten]

Folgendes Modul kann auf verschiedene Weisen eingebunden werden:

def multipliziere(a, b):
    return a * b

def print_mult(a, b):
    print multipliziere(a, b)

Es kann bei längeren Modulnamen umständlich erscheinen, immer wieder bei jeder importierten Funktion den Modulnamen davorzuschreiben. Eine Abkürzung bietet das lokale Umbenennen:

#!/usr/bin/python
import modul2 as X

X.print_mult(3, 3)
Align=none Ausgabe

user@localhost:~$ ./mod2.py
9

Hier wird das Modul modul2 unter dem Namen X bekanntgemacht. Auf alle Funktionen des Modules kann ab sofort mit dem neuen Namen zugegriffen werden.

Den neuen Namensraum kann man aber auch so importieren, dass man auf die Angabe des Namensraumes verzichten kann:

#!/usr/bin/python
from modul2 import *

print_mult(3, 3)
Align=none Ausgabe

user@localhost:~$ ./mod3.py
9

Es werden alle Funktionen aus dem Modul importiert, als würden sie lokal vereinbart worden sein. Der Stern dient dabei als Platzhalter für alle im Modul vorliegenden Deklarationen.

Einzelne Funktionen aus dem Modul lassen sich über die explizite Angabe der Funktionen in der import-Anweisung einbetten, alle anderen Deklarationen sind unbekannt:

#!/usr/bin/python
from modul2 import print_mult

print_mult(3, 3)
Align=none Ausgabe

user@localhost:~$ ./mod4.py
9

Bindet man aus einem Modul mehrere Funktionen ein, so sind sie mit Kommata zu separieren, beispielsweise:

#!/usr/bin/python
from modul2 import print_mult, multipliziere.

Namensräume haben den Vorteil, dass man mehrere Funktionen haben kann, die den gleichen Namen tragen. Durch die Nennung des Namensraumes in der import-Anweisung ist immer klar, welche Funktion man meint. Diesen Vorteil verliert man, wenn man den Sternchenimport benutzt.

Inhalt von Modulen[Bearbeiten]

Module enthalten von sich aus schon eine Reihe vorbelegter Variablen, die man nutzen kann. Das folgende Beispiel zeigt den Zugriff auf zwei solcher Variablen, nämlich __name__ und __doc__. Die Variable __name__ enthält den Namen der aktuell ausgeführten Funktion, dies ist bei Modulen __main__. __doc__ hingegen enthält einen Dokumentationsstring, sofern dieser am Anfang des Modules festgelegt wurde:

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""Dieses Modul enthält Funktionen
rund um erste mathematische Anweisungen. """

def addiere(a, b):
    return a + b

def multipliziere(a, b):
    return a * b
    
print __name__
print __doc__
Align=none Ausgabe

user@localhost:~$ ./modinhalt1.py
__main__
Dieses Modul enthält Funktionen
rund um erste mathematische Anweisungen.

Beachten Sie bitte, dass dieses Modul Ausführungsrechte benötigt. Nutzen kann man diese Konstanten, um eine Dokumentation ausgeben zu lassen oder den Inhalt des Moduls mit der Funktion dir() anzeigen zu lassen:

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""Dieses Modul enthält Funktionen
rund um erste mathematische Anweisungen. """

def addiere(a, b):
    return a + b

def multipliziere(a, b):
    return a * b

if __name__ == "__main__":
    print __doc__
    print dir()
Align=none Ausgabe

user@localhost:~$ ./modinhalt2.py
Dieses Modul enthält Funktionen
rund um erste mathematische Anweisungen.
['__builtins__', '__doc__', '__file__', '__name__', 'addiere', 'multipliziere']

Wenn dieses Modul aufgerufen wird, dann gibt es den Docstring aus, gefolgt von dem Inhalt des Moduls. Mit dieser Technik verhindert man, dass versehentlich das falsche Modul ausgeführt wird und man keine Programmausgabe erhält. Außerdem ist es bequem, so auf seine Module zugreifen zu können. dir() gibt den gesamten Inhalt des Moduls aus. Neben den Namen der Funktionen werden einige Variablen, die automatisch erzeugt wurden, aufgeführt. dir() können Sie auf alle Objekte, also auch Funktionen, Strings, Zahlen, Listen und so fort anwenden.

Außerhalb des Moduls, kann man auf diese Modulvariablen ebenfalls zugreifen, wobei dann ihr Inhalt anders lautet. Zum Beispiel gibt:

#!/usr/bin/python
import modul3b

print modul3b.__name__

den String modul3b aus. Die Anweisungen aus diesem Modul werden nicht berührt, da das Modul ja nicht ausgeführt wird.

Pakete[Bearbeiten]

Pakete sind (thematische) Zusammenfassungen von Modulen in einer Verzeichnisstruktur. Hierbei werden mehrere Modul-Dateien hierarchisch gegliedert in einem Verzeichnis abgelegt. Hinzu kommt pro Verzeichnis-Ebene eine Initialisierungsdatei. Diese Initialisierungsdatei enthält für diese Ebene die gemeinsame Dokumentation und übernimmt Initialisierungsaufgaben. Der Inhalt dieser Datei wird beim Import gelesen und ausgeführt. Es ist hierbei nicht notwendig, dieser Datei Ausführungsrechte zu geben. Ein typischer Paket-Verzeichnisbaum kann folgendermaßen aussehen:

mathe/
mathe/__init__.py

mathe/addiere/
/mathe/addiere/addiere.py
/mathe/addiere/__init__.py

mathe/subtrahiere/
/mathe/subtrahiere/subtrahiere.py
/mathe/subtrahiere/__init__.py

Die Initialisierungsdatei kann leer sein oder folgenden Aufbau haben (mathe/addiere/__init__.py):

"""Die hiesigen Module dienen zum Addieren von Zahlen"""

print "Initialisierung von mathe/addiere/*"

Das war es schon. Die print-Anweisung wird ausgeführt, wenn Module aus dieser Ebene importiert werden.

Der Aufbau von Modulen unterscheidet sich hierbei nicht von dem oben gesagten. Der Vollständigkeit fügen wir hier noch ein Modul ein (mathe/addiere/addiere.py):

def add(a, b):
    return a+b

Ein Programm, welches Module aus einem Paket benutzt sieht so aus:

#!/usr/bin/python

import mathe.addiere.addiere

print mathe.__doc__
print "-"
print mathe.addiere.__doc__

print mathe.addiere.addiere.add(2, 2)
Align=none Ausgabe

user@localhost:~$ ./paket1.py
Initialisierung von mathe/addiere/*
Dieses Paket enthält einige Mathematik-Module
-
Die hiesigen Module dienen zum Addieren von Zahlen
4

Dieses Programm gibt die Dokumentation der Module aus und benutzt eine in einem Paketmodul definierte Funktion. Beachten Sie bitte, dass die Ausgabe beim Testen der hier vorgestellten Dateien von unserer Darstellung abweicht. Der Grund ist, dass wir die Datei mathe/__init__.py nicht vorgestellt haben.

Paketmodule erkennt man an ihrer Punkt-Darstellung beim Import. Es wird hier aus dem mathe-Paket im Verzeichnis addiere/ das Python-Modul addiere.py importiert und daraus die Funktion add() aufgerufen. Man kann pro Verzeichnisebene mehrere Module haben.

Pakete werden ihnen im weiteren Verlauf des Buches an vielen Stellen begegnen.

Zusammenfassung[Bearbeiten]

Module unterscheiden sich in ihrem Aufbau nicht von anderen Python-Dateien. Sie gliedern zusammengehörige Codeteile und können auf mehrere Weisen eingebunden werden. Eine reine import-Anweisung erzeugt einen neuen Namensraum, von denen man nie genug haben kann. Module kann und sollte man mit einem Docstring versehen. Es gibt viele vorbelegte Variablen rund um Module, von denen wir einige hier kennengelernt haben. Module kann man zu Paketen gruppieren.