Module und Pakete in Python importieren

Einleitung

In diesem Lab lernen Sie, wie Sie Module und Pakete in Python importieren und verwenden. Wir beginnen mit der Erkundung von Python-Modulen und der Verwendung des pydoc-Tools, um deren Dokumentation anzuzeigen. Dabei verstehen wir, wie Module als Container für Python-Code dienen.

Anschließend üben Sie den Import ganzer Module mit der import-Anweisung und lernen, wie Sie spezifische Objekte (Funktionen, Klassen, Variablen) aus einem Modul mit der from...import-Anweisung importieren. Abschließend behandelt das Lab das Konzept von Python-Paketen, die Sammlungen von Modulen sind, und zeigt, wie Sie diese effektiv in Ihren Programmen nutzen.

Python-Module mit pydoc erkunden

In diesem Schritt erkunden wir Python-Module und wie das pydoc-Tool zur Anzeige von Dokumentationen verwendet wird. Ein Modul in Python ist einfach eine Datei, die Python-Code enthält, typischerweise mit der Erweiterung .py. Module können Funktionen, Klassen und Variablen definieren, die dann durch Importieren des Moduls in anderen Python-Programmen verwendet werden können. So greifen Sie auf die riesige Sammlung der Standardbibliotheken und Drittanbieterbibliotheken von Python zu.

Um herauszufinden, welche Standardbibliotheken in Ihrer Python-Umgebung verfügbar sind, ist die offizielle Python-Dokumentation die beste Ressource. Die Dokumentation der Standardbibliothek finden Sie hier.

Alternativ können Sie das Kommandozeilen-Dienstprogramm pydoc verwenden, um die Dokumentation für in Ihrer aktuellen Umgebung installierte Module anzuzeigen.

Öffnen Sie zuerst das Terminal in der WebIDE. Das Standardverzeichnis ist ~/project.

Führen Sie nun den folgenden Befehl im Terminal aus, um den pydoc-Webserver zu starten. Wir verwenden 0.0.0.0 für die IP-Adresse und 8080 für den Port, um ihn zugänglich zu machen.

python3 -m pydoc -n 0.0.0.0 -p 8080

Server ready at http://0.0.0.0:8080/
Server commands: [b]rowser, [q]uit

Sie sehen eine Ausgabe, die anzeigt, dass der Server bereit ist. Um auf die Weboberfläche zuzugreifen, müssen Sie den von LabEx bereitgestellten Webdienst öffnen. Klicken Sie auf die Schaltfläche "Web Service" in der oberen rechten Ecke der WebIDE-Oberfläche. Dies öffnet einen neuen Browser-Tab mit der pydoc-Dokumentation.

Auf der pydoc-Webseite sehen Sie eine Liste von Modulen. Dies sind die in Ihrer Python-Umgebung verfügbaren Module. Typischerweise sind Module in Verzeichnissen wie /usr/lib/python3.10 Teil der Standardbibliothek, während Module in Verzeichnissen wie /usr/local/lib/python3.10/dist-packages oder /home/labex/.local/lib/python3.10/site-packages Drittanbieterbibliotheken sind.

Scrollen Sie nach unten und klicken Sie auf einen Modulnamen, um dessen Dokumentation anzuzeigen. Sie können beispielsweise auf das requests-Modul klicken, wenn es aufgeführt ist (es ist eine beliebte Drittanbieterbibliothek, die oft vorinstalliert ist). Dies zeigt die Hilfeinformationen für dieses Modul an, einschließlich seiner Funktionen, Klassen und Methoden.

Nachdem Sie die Dokumentation erkundet haben, kehren Sie zum Terminal zurück, in dem pydoc ausgeführt wird. Drücken Sie die Taste q, um den pydoc-Webserver zu beenden.

Server ready at http://0.0.0.0:8080/
Server commands: [b]rowser, [q]uit
q

Der pydoc-Server wird heruntergefahren, und Sie kehren zur Terminal-Eingabeaufforderung zurück.

Module mit der import-Anweisung importieren

In diesem Schritt lernen wir, wie man Module in Python mit der import-Anweisung importiert. Die import-Anweisung ist die gebräuchlichste Methode, um die in einem Modul definierten Funktionen, Klassen und Variablen für die Verwendung in Ihrem aktuellen Skript oder Ihrer interaktiven Sitzung verfügbar zu machen. Die grundlegende Syntax lautet import modul_name. Sie können mehrere Module importieren, indem Sie ihre Namen mit Kommas trennen: import modul1, modul2, ....

Ein wichtiger Punkt, den Sie beachten sollten, ist, dass unabhängig davon, wie oft Sie eine import-Anweisung für dasselbe Modul ausführen, der Code des Moduls nur einmal ausgeführt wird. Dies verhindert eine redundante Ausführung des Modulinitialisierungscodes.

Erstellen wir eine einfache Python-Datei, um den Modulimport zu demonstrieren. Stellen Sie in der WebIDE sicher, dass Sie sich im Verzeichnis ~/project befinden. Erstellen Sie eine neue Datei namens hello.py.

Öffnen Sie die Datei hello.py im Editor und fügen Sie den folgenden Code hinzu:

print("hello")

if __name__ == "__main__":
    print("world")

Speichern Sie die Datei.

Lassen Sie uns dieses Skript nun direkt vom Terminal aus ausführen.

python3 hello.py

hello
world

Wie Sie sehen können, wurden beide print-Anweisungen ausgeführt.

Als Nächstes sehen wir, was passiert, wenn wir diese Datei als Modul importieren. Öffnen Sie eine Python-interaktive Sitzung im Terminal, indem Sie python3 eingeben.

python3

Python 3.10.12 (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>

Importieren Sie nun das hello-Modul. Beachten Sie, dass Sie beim Importieren nicht die .py-Erweiterung angeben.

import hello

hello

Beachten Sie, dass beim Importieren des Moduls nur die erste print-Anweisung ("hello") ausgeführt wurde. Die zweite print-Anweisung ("world") wurde nicht ausgeführt.

Dieses Verhalten wird durch den Block if __name__ == "__main__": gesteuert. __name__ ist eine spezielle integrierte Variable in Python. Wenn eine Python-Datei direkt als Skript ausgeführt wird, wird die Variable __name__ auf den String "__main__" gesetzt. Wenn die Datei jedoch als Modul in ein anderes Skript oder eine interaktive Sitzung importiert wird, wird die Variable __name__ auf den Namen des Moduls gesetzt (in diesem Fall "hello").

Die Bedingung if __name__ == "__main__": prüft, ob das Skript direkt ausgeführt wird. Wenn ja, wird der Code innerhalb des if-Blocks ausgeführt. Wenn das Skript als Modul importiert wird, ist die Bedingung falsch und der Code innerhalb des if-Blocks wird übersprungen. Dies ist ein gängiges Muster, um Code einzuschließen, der nur ausgeführt werden soll, wenn das Skript direkt ausgeführt wird, z. B. Test- oder Setup-Code.

Sie können den Wert von __name__ überprüfen, wenn das Modul importiert wird, indem Sie auf das __name__-Attribut des importierten Moduls zugreifen:

hello.__name__

'hello'

Dies bestätigt, dass beim Importieren der __name__ des hello-Moduls tatsächlich "hello" ist.

Lassen Sie uns nun untersuchen, wie Python Module findet, wenn Sie die import-Anweisung verwenden. Python sucht nach Modulen in einer Liste von Verzeichnissen. Sie können diese Liste anzeigen, indem Sie das sys-Modul importieren und auf die Variable sys.path zugreifen.

Beenden Sie zuerst die aktuelle Python-interaktive Sitzung, indem Sie exit() eingeben oder Strg + D drücken.

exit()

Starten Sie nun eine neue Python-interaktive Sitzung.

python3

Importieren Sie das sys-Modul und geben Sie sys.path aus:

import sys
print(sys.path)

['', '/usr/lib/python310.zip', '/usr/lib/python3.10', '/usr/lib/python3.10/lib-dynload', '/home/labex/.local/lib/python3.10/site-packages', '/usr/local/lib/python3.10/dist-packages', '/usr/lib/python3/dist-packages']

Die Ausgabe ist eine Liste von Verzeichnissen. Python sucht in diesen Verzeichnissen nach Modulen in der Reihenfolge, in der sie in der Liste erscheinen. Der erste Eintrag, '', repräsentiert das aktuelle Verzeichnis (~/project in diesem Fall). Das bedeutet, dass Python zuerst in dem Verzeichnis nach Modulen sucht, in dem das Skript ausgeführt wird oder die interaktive Sitzung gestartet wurde. Deshalb konnten wir hello.py direkt aus dem Verzeichnis ~/project importieren.

Wenn ein Modul mit demselben Namen in mehreren Verzeichnissen in sys.path vorhanden ist, wird dasjenige importiert, das in dem Verzeichnis gefunden wird, das in der Liste früher erscheint.

Erstellen wir als Nächstes eine weitere Python-Datei, um den Zugriff auf Variablen und Funktionen aus einem importierten Modul zu üben. Erstellen Sie im Verzeichnis ~/project eine neue Datei namens abcd.py.

Öffnen Sie abcd.py und fügen Sie den folgenden Code hinzu:

x = 5
y = 9

def a():
	print("This is function a")

def b():
	print("This is function b")

def c():
	print("This is function c")

def d():
	print("This is function d")

Speichern Sie die Datei. Dieses Modul definiert zwei Variablen (x und y) und vier einfache Funktionen (a, b, c und d).

Lassen Sie uns nun das abcd-Modul in einer Python-interaktiven Sitzung importieren und auf dessen Inhalte zugreifen. Beenden Sie die aktuelle Python-Sitzung, falls Sie sich noch in einer befinden (exit() oder Strg + D). Starten Sie eine neue Sitzung.

python3

Importieren Sie das abcd-Modul:

import abcd

Nun können Sie über den Punktoperator (.) auf die in abcd.py definierten Variablen und Funktionen zugreifen:

abcd.x

abcd.y

abcd.a()

This is function a

Sie können ähnlich abcd.b(), abcd.c() und abcd.d() aufrufen. Dies zeigt, wie Sie mit der Syntax modul_name.member_name auf die Elemente eines importierten Moduls zugreifen.

Spezifische Objekte mit from...import importieren

In diesem Schritt werden wir eine weitere Methode untersuchen, um spezifische Objekte (wie Funktionen, Variablen oder Klassen) aus einem Modul mithilfe der from...import-Anweisung zu importieren. Dies ist nützlich, wenn Sie nur wenige spezifische Elemente aus einem Modul benötigen und direkt auf sie über ihre Namen zugreifen möchten, ohne das Präfix modul_name. zu verwenden.

Die grundlegende Syntax lautet from modul_name import objekt1, objekt2, ....

Verwenden wir die Datei abcd.py, die wir im vorherigen Schritt erstellt haben. Sie enthält die Variablen x und y sowie die Funktionen a, b, c und d.

Beenden Sie zuerst jede aktive Python-interaktive Sitzung (exit() oder Strg + D). Starten Sie eine neue Python-interaktive Sitzung im Terminal.

python3

Lassen Sie uns nun nur die Funktion a aus dem abcd-Modul mithilfe der from...import-Anweisung importieren:

from abcd import a

>>> from abcd import a
>>>

Nach diesem Import ist die Funktion a direkt in Ihrem aktuellen Gültigkeitsbereich (scope) verfügbar. Sie können sie ohne das Präfix abcd. aufrufen:

a()

This is function a

Versuchen wir nun, auf andere Objekte aus dem abcd-Modul zuzugreifen, die wir nicht explizit importiert haben, wie z. B. die Variable x oder die Funktion b.

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined

b()

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined

Wie erwartet führt der Versuch, auf x oder b zuzugreifen, zu einem NameError, da sie nicht in den aktuellen Gültigkeitsbereich importiert wurden. Wenn Sie from modul import objekt verwenden, wird nur das angegebene objekt direkt verfügbar gemacht. Das Modul selbst (abcd) wird nicht in den aktuellen Gültigkeitsbereich aufgenommen, und seine anderen Mitglieder sind nicht direkt zugänglich.

Wenn Sie mehrere spezifische Objekte aus einem Modul importieren müssen, können Sie diese durch Kommas getrennt auflisten:

from abcd import x, y, b

Nun sind x, y und b direkt verfügbar:

b()

This is function b

a, c und d sind jedoch immer noch nicht direkt verfügbar, es sei denn, Sie nehmen sie ebenfalls in die Importanweisung auf.

Diese from...import-Anweisung bietet mehr Kontrolle darüber, was Sie in Ihren aktuellen Namensraum (namespace) importieren. Dies kann helfen, Namenskonflikte zu vermeiden, wenn Sie mit mehreren Modulen arbeiten, die Objekte mit demselben Namen haben könnten.

Python-Pakete verstehen und verwenden

In diesem Schritt lernen wir Python-Pakete kennen. Pakete sind eine Methode zur Strukturierung des Python-Modul-Namensraums unter Verwendung von "punktierten Modulnamen". Ein Paket ist im Wesentlichen ein Verzeichnis, das eine spezielle Datei namens __init__.py enthält. Diese Datei kann leer sein, aber ihre Anwesenheit signalisiert Python, dass das Verzeichnis als Paket behandelt werden soll. Unterverzeichnisse innerhalb eines Pakets können ebenfalls Pakete sein, wodurch eine Hierarchie entsteht.

Erstellen wir eine einfache Paketstruktur mithilfe der Dateien, die wir in den vorherigen Schritten erstellt haben. Beenden Sie zuerst jede aktive Python-interaktive Sitzung (exit() oder Strg + D).

Stellen Sie im Terminal sicher, dass Sie sich im Verzeichnis ~/project befinden. Erstellen Sie ein neues Verzeichnis namens use.

mkdir use

Verschieben Sie nun die Dateien abcd.py und hello.py in das Verzeichnis use.

mv abcd.py hello.py use/

Erstellen Sie als Nächstes eine leere Datei namens __init__.py im Verzeichnis use. Diese Datei ist entscheidend dafür, dass Python use als Paket erkennt.

touch use/__init__.py

Ihre Verzeichnisstruktur sollte nun wie folgt aussehen:

~/project/
└── use/
    ├── abcd.py
    ├── hello.py
    └── __init__.py

Nachdem wir nun ein Paket namens use mit den Modulen abcd und hello erstellt haben, sehen wir, wie wir daraus importieren können. Starten Sie eine neue Python-interaktive Sitzung im Terminal.

python3

Um ein Modul innerhalb eines Pakets zu importieren, verwenden Sie den Paketnamen, gefolgt von einem Punkt und dem Modulnamen. Um beispielsweise das abcd-Modul aus dem use-Paket zu importieren, würden Sie Folgendes verwenden:

import use.abcd

>>> import use.abcd
>>>

Nun können Sie auf die Inhalte des abcd-Moduls über den vollständigen punktierten Namen zugreifen:

use.abcd.x

use.abcd.a()

This is function a

Sie können auch die from...import-Anweisung mit Paketen verwenden, um spezifische Objekte oder Module zu importieren. Um beispielsweise nur die Funktion a aus dem abcd-Modul innerhalb des use-Pakets zu importieren:

from use.abcd import a

>>> from use.abcd import a
>>>

Nun ist die Funktion a direkt verfügbar:

a()

This is function a

Sie können auch das gesamte abcd-Modul direkt in Ihren aktuellen Namensraum importieren, indem Sie from...import verwenden:

from use import abcd

>>> from use import abcd
>>>

In diesem Fall ist das abcd-Modul selbst verfügbar, und Sie können über abcd.member_name auf seine Inhalte zugreifen:

abcd.x

abcd.b()

This is function b

Schließlich betrachten wir die Anweisung from package import *. Diese Anweisung wird oft abgeraten, da sie zu unerwartetem Verhalten und Namenskonflikten führen kann. Standardmäßig importiert from package import * alle Namen, die in der __init__.py-Datei des Pakets definiert sind. Wenn __init__.py eine Liste namens __all__ definiert, importiert from package import * nur die in __all__ aufgeführten Namen.

Lassen Sie uns die Datei use/__init__.py ändern. Öffnen Sie use/__init__.py im Editor.

Fügen Sie die folgende Zeile zur Datei hinzu:

__all__ = ['abcd']

Speichern Sie die Datei. Diese __all__-Liste gibt an, dass beim Verwenden von from use import * nur das abcd-Modul importiert werden soll.

Beenden Sie die aktuelle Python-interaktive Sitzung (exit() oder Strg + D). Starten Sie eine neue Sitzung.

python3

Verwenden Sie nun die Anweisung from use import *:

from use import *

>>> from use import *
>>>

Versuchen wir, auf etwas aus dem abcd-Modul und dem hello-Modul zuzugreifen.

abcd.a()

This is function a

hello.print("test")

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'hello' is not defined

Wie Sie sehen können, wurde abcd importiert und seine Inhalte sind zugänglich, aber hello wurde nicht importiert, da es nicht in der __all__-Liste in use/__init__.py enthalten war.

Wenn die Datei __init__.py keine __all__-Liste hat, importiert from package import * alle Namen, die in __init__.py selbst definiert sind, aber es importiert nicht automatisch alle Untermodule innerhalb des Pakets. Sie müssten die Untermodule zuerst explizit importieren (z. B. import use.abcd), bevor Sie from use import * verwenden, um deren Inhalte verfügbar zu machen. Aufgrund dieser potenziellen Verwirrung und des Risikos, unerwünschte Namen zu importieren, werden explizite Importe wie import package.module oder from package.module import object im Allgemeinen from package import * vorgezogen.

Zusammenfassung

In diesem Lab haben wir Python-Module und den Zugriff auf deren Dokumentation mit dem pydoc-Tool untersucht. Wir haben gelernt, dass Module Python-Dateien sind, die Code enthalten, und dass sie grundlegend für die Organisation und Wiederverwendung von Code sind, einschließlich der Standardbibliothek und von Drittanbieter-Paketen. Wir haben geübt, den pydoc-Webserver zu starten und seine Benutzeroberfläche zu navigieren, um die Dokumentation für installierte Module anzuzeigen.

Anschließend haben wir gelernt, wie man Module mit der import-Anweisung in unsere Python-Programme importiert, was uns ermöglicht, die darin definierten Funktionen, Klassen und Variablen zu verwenden. Wir haben auch die from...import-Anweisung erkundet, die eine direktere Möglichkeit bietet, spezifische Objekte aus einem Modul zu importieren, wodurch unser Code prägnanter wird. Schließlich haben wir ein Verständnis für Python-Pakete als Sammlungen von Modulen, die in Verzeichnissen organisiert sind, und wie man Module aus Paketen importiert, gewonnen.