Module/Packages - Python Basics

Ein Modul in der Programmierung ist ein Teil der Software, der eine bestimmte Funktionalität hat. Ein Modul ist z. B. für die Spiellogik bei der Erstellung eines Tischtennisspiels zuständig, ein anderes Modul für das Zeichnen des Spiels auf dem Bildschirm. Jedes Modul ist eine eigene Datei, die separat bearbeitet werden kann.

Module schreiben

Python-Module sind im Wesentlichen Python-Dateien mit der Endung .py. Der Name des Moduls wäre der Name der Datei. Ein Python-Modul kann eine Sammlung von spezifizierten und implementierten Funktionen, Klassen oder Variablen enthalten.

meinspiel/
meinspiel/spiel.py
meinspiel/zeichnen.py

Das Python-Skript spiel.py wird das Spiel implementieren. Es verwendet die Funktion spiel_zeichnen aus der Datei spiel.py, oder anders gesagt, das Modul Zeichnen, das die Logik zum Zeichnen des Spiels auf dem Bildschirm implementiert.

Module werden mit dem import-Befehl aus anderen Modulen importiert. In diesem Beispiel könnte das Skript spiel.py etwa so aussehen:

# spiel.py
# importiert das Modul Zeichnen
import draw

def spiel_spielen():
    ...

def main():
    ergebnis = spiel_spielen()
    zeichnen.spiel_zeichnen(ergebnis)

# das bedeutet, dass wenn dieses Skript ausgeführt wird, dann wird main() ausgeführt
if __name__ == '__main__':
    main()

Das Modul Zeichnen kann etwa so aussehen:

# zeichnen.py
def spiel_zeichnen():
    ...
def bildschirm_leeren(bildschirm):
    ...

In diesem Beispiel importiert das Modul Spiel das Modul Zeichnen Die Hauptfunktion würde die lokale Funktion spiel_spielen verwenden, um das Spiel auszuführen, und dann das Ergebnis des Spiels mit einer im Zeichenmodul implementierten Funktion namens spiel_zeichnen zeichnen. Um die Funktion spiel_zeichnen aus dem Draw-Modul zu verwenden, müssten wir mit dem Operator dot angeben, in welchem Modul die Funktion implementiert ist. Um die Funktion spiel_zeichnen aus dem Spiel-Modul zu referenzieren, müssten wir das draw-Modul importieren und erst dann zeichnen.spiel_zeichnen() aufrufen.

Wenn die Direktive import draw ausgeführt wird, sucht der Python-Interpreter in dem Verzeichnis, aus dem das Skript ausgeführt wurde, nach einer Datei mit dem Namen des Moduls mit dem Suffix .py, in unserem Fall also nach zeichnen.py. Wenn er eines findet, wird er es importieren. Wenn nicht, wird er weiter nach eingebauten Modulen suchen.

Du hast vielleicht bemerkt, dass beim Importieren eines Moduls eine .pyc Datei erscheint, die eine kompilierte Python-Datei ist. Python kompiliert Dateien in Python-Bytecode, damit es die Dateien nicht jedes Mal parsen muss, wenn ein Modul geladen wird. Wenn eine .pyc-Datei existiert, wird sie anstelle der .py-Datei geladen, aber dieser Vorgang ist für den Benutzer transparent.

Importieren von Modulobjekten in den aktuellen Namespace

Wir können die Funktion spiel_zeichnen auch direkt in den Namespace des Hauptskripts importieren, indem wir den Befehl from verwenden.

# spiel.py
# importiert das Modul Zeichnen
from zeichnen import spiel_zeichnen

def main():
    ergebnis = spiel_spielen()
    spiel_zeichnen(ergebnis)

Du hast vielleicht bemerkt, dass in diesem Beispiel spiel_zeichnen nicht der Name des Moduls vorangestellt wird, aus dem es importiert wird, da wir den Modulnamen im Importbefehl angegeben haben.

Der Vorteil dieser Notation ist, dass die Funktionen innerhalb des aktuellen Moduls einfacher zu verwenden sind, da du nicht definieren musst, aus welchem Modul die Funktion kommt. Allerdings kann es in jedem Namensraum nicht zwei Objekte mit exakt demselben Namen geben, so dass ein bestehendes Objekt im Namensraum durch den import-Befehl ersetzt werden kann.

Importieren aller Objekte aus einem Modul

Wir können auch den Befehl import * verwenden, um alle Objekte aus einem bestimmten Modul zu importieren, etwa so:

# spiel.py
# importiert das Modul Zeichnen
from zeichnen import *

def main():
    ergebnis = spiel_spielen()
    spiel_zeichnen(ergebnis)

Dies ist zwar etwas riskant, da sich Änderungen im Modul auf das Modul auswirken können, das es importiert, aber es ist kürzer und erfordert auch nicht, dass du angibst, welche Objekte du vom Modul importieren möchtest.

Benutzerdefinierter Importname

Wir können Module auch unter einem beliebigen Namen laden. Dies ist nützlich, wenn wir ein Modul bedingt importieren wollen, um denselben Namen im restlichen Code zu verwenden.

Wenn du zum Beispiel zwei Zeichenmodule mit leicht unterschiedlichen Namen hast, kannst du folgendes tun:

# spiel.py
# importiert das Modul Zeichnen
if visual_mode:
    # im visuellen Modus zeichnen wir mit Grafiken
    import visuell_zeichnen as zeichnen
else:
    # im Textmodus wird ein Text ausgegeben
    import textuell_zeichnen as zeichnen

def main():
    ergebnis = spiel_spielen()
    # dies kann entweder visuell oder textuell sein, abhängig von visual_mode
    zeichnen.spiel_zeichnen(ergebnis)

Initialisierung von Modulen

Wenn ein Modul zum ersten Mal in ein laufendes Python-Skript geladen wird, wird es initialisiert, indem der Code des Moduls einmal ausgeführt wird. Wenn ein anderes Modul in deinem Code dasselbe Modul erneut importiert, wird es nicht zweimal, sondern nur einmal geladen - lokale Variablen innerhalb des Moduls verhalten sich also wie ein "Singleton" - sie werden nur einmal initialisiert.

Das ist nützlich zu wissen, denn das bedeutet, dass du dich bei der Initialisierung von Objekten auf dieses Verhalten verlassen kannst. Zum Beispiel:

# zeichnen.py

def spiel_zeichnen():
    # beim Leeren des Bildschirms können wir das in diesem Modul initialisierte Hauptbildschirmobjekt verwenden
    bildschirm_leeren(hauptbildschirm)
    ...

def bildschirm_leeren(bildschirm):
    ...

class Bildschirm():
    ...

# hauptbildschirm als Singleton initialisieren
hauptbildschirm = Bildschirm()

Erweiterter Modul-Ladepfad

Es gibt mehrere Möglichkeiten, dem Python-Interpreter mitzuteilen, wo er nach Modulen suchen soll, abgesehen von der Voreinstellung, die aus dem lokalen Verzeichnis und den eingebauten Modulen besteht. Du kannst entweder die Umgebungsvariable PYTHONPATH verwenden, um zusätzliche Verzeichnisse anzugeben, in denen nach Modulen gesucht werden soll, etwa so:

PYTHONPATH=/foo python spiel.py

Dies führt spiel.py aus und ermöglicht es dem Skript, Module sowohl aus dem Verzeichnis foo als auch aus dem lokalen Verzeichnis zu laden.

Eine weitere Methode ist die Funktion sys.path.append. Du kannst sie ausführen, bevor du einen Import-Befehl ausführst:

sys.path.append("/foo")

Dadurch wird das Verzeichnis foo zur Liste der Pfade hinzugefügt, in denen ebenfalls nach Modulen gesucht werden soll.

Eingebaute Module in Python

Zwei sehr wichtige Funktionen sind bei der Suche nach Modulen in Python sehr nützlich - die Funktionen dir und help.

Wenn wir das Modul urllib importieren wollen, das es uns ermöglicht, Lesedaten aus URLs zu erzeugen, importieren wir einfach das Modul:

# importiert die Bibliothek 
import urllib

# verwende sie
urllib.urlopen(...)

Mit der Funktion dir können wir nachsehen, welche Funktionen in den einzelnen Modulen implementiert sind:

>>> import urllib
>>> dir(urllib)
['ContentTooShortError', 'FancyURLopener', 'MAXFTPCACHE', 'URLopener', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__version__', '_ftperrors', '_get_proxies', '_get_proxy_settings', '_have_ssl', '_hexdig', '_hextochr', '_hostprog', '_is_unicode', '_localhost', '_noheaders', '_nportprog', '_passwdprog', '_portprog', '_queryprog', '_safe_map', '_safe_quoters', '_tagprog', '_thishost', '_typeprog', '_urlopener', '_userprog', '_valueprog', 'addbase', 'addclosehook', 'addinfo', 'addinfourl', 'always_safe', 'basejoin', 'c', 'ftpcache', 'ftperrors', 'ftpwrapper', 'getproxies', 'getproxies_environment', 'getproxies_macosx_sysconf', 'i', 'localhost', 'main', 'noheaders', 'os', 'pathname2url', 'proxy_bypass', 'proxy_bypass_environment', 'proxy_bypass_macosx_sysconf', 'quote', 'quote_plus', 'reporthook', 'socket', 'splitattr', 'splithost', 'splitnport', 'splitpasswd', 'splitport', 'splitquery', 'splittag', 'splittype', 'splituser', 'splitvalue', 'ssl', 'string', 'sys', 'test', 'test1', 'thishost', 'time', 'toBytes', 'unquote', 'unquote_plus', 'unwrap', 'url2pathname', 'urlcleanup', 'urlencode', 'urlopen', 'urlretrieve']

Wenn wir die Funktion in dem Modul gefunden haben, das wir verwenden wollen, können wir mit der Hilfe-Funktion innerhalb des Python-Interpreters mehr darüber lesen:

help(urllib.urlopen)

Schreiben von Packages

Packages sind Namensräume, die selbst mehrere Packages und Module enthalten. Sie sind einfach Verzeichnisse, aber mit einem Twist.

Jedes Package in Python ist ein Verzeichnis, das eine spezielle Datei namens __init__.py enthalten MUSS. Diese Datei kann leer sein und zeigt an, dass das darin enthaltene Verzeichnis ein Python-Paket ist, so dass es auf die gleiche Weise importiert werden kann wie ein Modul.

Wenn wir ein Verzeichnis mit dem Namen foo erstellen, das den Paketnamen markiert, können wir dann innerhalb dieses Pakets ein Modul mit dem Namen bar erstellen. Wir dürfen auch nicht vergessen, die Datei __init__.py innerhalb des Verzeichnisses foo hinzuzufügen.

Um das Modul bar zu verwenden, können wir es auf zwei Arten importieren:

import foo.bar

or:

from foo import bar

In der ersten Methode müssen wir das Präfix "foo" verwenden, wenn wir auf das Modul "bar" zugreifen. In der zweiten Methode müssen wir das nicht, weil wir das Modul in den Namespace unseres Moduls importieren.

Die Datei __init__.py kann auch entscheiden, welche Module das Paket als API exportiert, während andere Module intern bleiben, indem die Variable __all__ überschrieben wird, etwa so:

__init__.py:

__all__ = ["bar"]

Übung

Gib eine alphabetisch sortierte Liste aller Funktionen im Modul re aus, die das Wort finden enthält.