Python-Module: Code übersichtlich und wiederverwendbar organisieren

Was sind Python-Module?

Ein Modul ermöglicht es Ihnen, Ihren Python-Code logisch zu strukturieren. Durch das Zusammenfassen zusammengehöriger Code in einem Modul wird dieser leichter verständlich und nutzbar. Technisch gesehen ist ein Modul ein Python-Objekt mit beliebig benannten Attributen, die Sie binden und referenzieren können.

Einfach ausgedrückt: Ein Modul ist eine Datei, die Python-Code enthält. Es kann Funktionen, Klassen und Variablen definieren sowie ausführbaren Code beinhalten.

Beispiel

Der Python-Code für ein Modul namens aname befindet sich normalerweise in einer Datei namens aname.py. Hier ist ein Beispiel für ein einfaches Modul, support.py:

def print_func(par):
    print("Hello :", par)
    return

Die import-Anweisung

Sie können jede Python-Quelldatei als Modul verwenden, indem Sie eine import-Anweisung in einer anderen Python-Quelldatei ausführen. Die Syntax lautet:

import module1[, module2[, ... moduleN]]

Wenn der Interpreter auf eine import-Anweisung stößt, importiert er das Modul, sofern es im Suchpfad vorhanden ist. Ein Suchpfad ist eine Liste von Verzeichnissen, die der Interpreter vor dem Importieren durchsucht. Um das Modul support.py zu importieren, fügen Sie folgenden Befehl am Anfang des Skripts ein:

#!/usr/bin/python
# Modul support importieren
import support

# Nun können Sie die definierte Funktion des Moduls aufrufen
support.print_func("Zara")

Bei der Ausführung ergibt sich folgende Ausgabe:

Hello : Zara

Ein Modul wird nur einmal geladen, unabhängig davon, wie oft es importiert wird. Dies verhindert, dass der Modulcode bei mehrfachem Import wiederholt ausgeführt wird.

Die from...import-Anweisung

Mit Pythons from-Anweisung können Sie spezifische Attribute aus einem Modul in den aktuellen Namensraum importieren. Die Syntax:

from modname import name1[, name2[, ... nameN]]

Beispiel: Um die Funktion fibonacci aus dem Modul fib zu importieren:

from fib import fibonacci

Diese Anweisung importiert nicht das gesamte Modul fib, sondern führt nur das Element fibonacci in die globale Symboltabelle des importierenden Moduls ein.

Die from...import *-Anweisung

Es ist auch möglich, alle Namen aus einem Modul in den aktuellen Namensraum zu importieren:

from modname import *

Dies bietet eine einfache Möglichkeit, alle Elemente eines Moduls zu importieren, sollte jedoch sparsam verwendet werden, um Namenskonflikte zu vermeiden.

Module finden

Beim Importieren sucht der Python-Interpreter in folgender Reihenfolge:

• Das aktuelle Verzeichnis.
• Falls nicht gefunden, jedes Verzeichnis in der Shell-Variable PYTHONPATH.
• Wenn alles fehlschlägt, der Standardpfad. Unter UNIX normalerweise /usr/local/lib/python/.

Der Modul-Suchpfad wird im Systemmodul sys als Variable sys.path gespeichert. Sie enthält das aktuelle Verzeichnis, PYTHONPATH und den installationsabhängigen Standardpfad.

Die PYTHONPATH-Variable

PYTHONPATH ist eine Umgebungsvariable, die aus einer Liste von Verzeichnissen besteht. Die Syntax entspricht der der Shell-Variable PATH.

Typisches PYTHONPATH unter Windows:

set PYTHONPATH = c:\python20\lib;

Typisches PYTHONPATH unter UNIX:

set PYTHONPATH = /usr/local/lib/python

Namensräume und Gültigkeitsbereiche

Variablen sind Bezeichner, die auf Objekte verweisen. Ein Namensraum ist ein Dictionary aus Variablennamen (Schlüsseln) und ihren zugehörigen Objekten (Werten).

Eine Python-Anweisung kann auf Variablen in einem lokalen Namensraum und im globalen Namensraum zugreifen. Haben eine lokale und eine globale Variable denselben Namen, überschattet die lokale Variable die globale.

Jede Funktion besitzt ihren eigenen lokalen Namensraum. Klassenmethoden folgen denselben Gültigkeitsregeln wie normale Funktionen.

Python geht davon aus, dass jede Variable, der in einer Funktion ein Wert zugewiesen wird, lokal ist. Um einer globalen Variablen innerhalb einer Funktion einen Wert zuzuweisen, müssen Sie zuerst die global-Anweisung verwenden.

Die Anweisung global VarName teilt Python mit, dass VarName eine globale Variable ist. Python sucht dann nicht mehr im lokalen Namensraum nach der Variable.

Beispiel: Wir definieren eine Variable Money im globalen Namensraum. Innerhalb der Funktion Money weisen wir Money einen Wert zu, weshalb Python Money als lokale Variable annimmt. Da wir jedoch auf den Wert der lokalen Variable Money zugreifen, bevor wir sie setzen, entsteht ein UnboundLocalError. Das Auskommentieren der global-Anweisung behebt das Problem.

#!/usr/bin/python
Money = 2000
def AddMoney():
    # Entkommentieren Sie die folgende Zeile, um den Code zu reparieren:
    # global Money
    Money = Money + 1
    print(Money)

AddMoney()
print(Money)

Die dir()-Funktion

Die eingebaute Funktion dir() gibt eine sortierte Liste von Strings zurück, die die Namen enthalten, die von einem Modul definiert werden.

Die Liste umfasst alle Module, Variablen und Funktionen, die in einem Modul definiert sind. Ein einfaches Beispiel:

#!/usr/bin/python
# Eingebautes Modul math importieren
import math
content = dir(math)
print(content)

Ausgabe:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

Hier ist die spezielle String-Variable __name__ der Name des Moduls, und __file__ ist der Dateiname, aus dem das Modul geladen wurde.

Die globals()- und locals()-Funktionen

Die Funktionen globals() und locals() geben die Namen im globalen bzw. lokalen Namensraum zurück, abhängig davon, von wo sie aufgerufen werden.

• Wird locals() innerhalb einer Funktion aufgerufen,返回所有可以从该函数局部访问的名称。
• Wird globals() innerhalb einer Funktion aufgerufen,返回所有可以从该函数全局访问的名称。

Der Rückgabetyp beider Funktionen ist ein Dictionary. Daher können Namen mithilfe der keys()-Funktion extrahiert werden.

Die reload()-Funktion

Wenn ein Modul in ein Skript importiert wird, wird der Code im oberen Teil des Moduls nur einmal ausgeführt.

Um den Code auf oberster Ebene in einem Modul erneut auszuführen, können Sie die reload()-Funktion verwenden. Sie importiert ein zuvor importiertes Modul erneut. Syntax:

reload(module_name)

Hierbei ist module_name der Name des neu zu ladenden Moduls, nicht der String mit dem Modulnamen. Beispiel für das Neuladen des Moduls hello:

reload(hello)

Pakete in Python

Ein Paket ist eine hierarchische Dateiverzeichnisstruktur, die eine einzelne Python-Anwendungsumgebung definiert, die aus Modulen, Unterpaketen und weiter verschachtelten Unterpaketen besteht.

Betrachten Sie eine Datei Pots.py im Verzeichnis Phone mit folgendem Quellcode:

#!/usr/bin/python
def Pots():
    print("I'm Pots Phone")

Ähnlich haben wir zwei weitere Dateien mit unterschiedlichen Funktionen unter demselben Namen:

• Phone/Isdn.py mit Funktion Isdn()
• Phone/G3.py mit Funktion G3()

Erstellen Sie nun eine weitere Datei __init__.py im Verzeichnis Phone:

• Phone/__init__.py

Um alle Funktionen verfügbar zu machen, wenn Sie Phone importieren, fügen Sie explizite Import-Anweisungen in __init__.py ein:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Nach Hinzufügen dieser Zeilen zu __init__.py stehen all diese Klassen beim Import des Phone-Pakets zur Verfügung:

#!/usr/bin/python
# Jetzt importieren Sie Ihr Phone-Paket.
import Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()

Bei Ausführung ergibt sich folgende Ausgabe:

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

Im obigen Beispiel haben wir je eine Funktion pro Datei verwendet, aber Sie können mehrere Funktionen in Ihren Dateien belassen. Sie können auch verschiedene Python-Klassen in diesen Dateien definieren und daraus Ihre Pakete erstellen.