Eine Übersicht über die Grundlagen von Modulen

PythonPythonBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden Sie die Grundlagen von Python-Modulen lernen. Module sind Python-Dateien mit Funktions-, Klassen- und Variablendefinitionen, die in anderen Python-Programmen verwendet werden können. Sie helfen dabei, den Code in logische Einheiten zu organisieren und die Wiederverwendbarkeit zu verbessern.

Am Ende dieses Labs werden Sie verstehen, wie Sie Ihre eigenen Module erstellen, sie auf verschiedene Weise importieren können und Sie werden die wichtigen Verhaltensweisen beim Laden von Modulen kennen, die sich auf Ihren Code auswirken.

Erstellen eines einfachen Moduls

Beginnen wir unsere Reise in die Welt der Python-Module, indem wir ein einfaches Modul erstellen. In Python ist ein Modul im Wesentlichen eine Datei mit der Endung .py, die Python-Code enthält. Stellen Sie sich es als einen Behälter vor, in dem Sie verwandte Funktionen, Klassen und Variablen zusammenfassen können. Dies macht Ihren Code besser organisiert und leichter zu verwalten, insbesondere wenn Ihre Projekte an Größe zunehmen.

  1. Öffnen Sie zunächst die WebIDE. Sobald sie geöffnet ist, müssen Sie eine neue Datei erstellen. Um dies zu tun, klicken Sie auf "File" in der Menüleiste und wählen Sie dann "New File". Benennen Sie diese neue Datei simplemod.py und speichern Sie sie im Verzeichnis /home/labex/project. In diesem Verzeichnis werden wir alle Dateien für dieses Experiment aufbewahren.

  2. Fügen wir nun etwas Code in unsere neu erstellte Datei simplemod.py ein. Der folgende Code definiert einige grundlegende Elemente, die Sie üblicherweise in einem Python-Modul finden.

## simplemod.py

x = 42        ## A global variable

## A simple function
def foo():
    print('x is', x)

## A simple class
class Spam:
    def yow(self):
        print('Yow!')

## A scripting statement
print('Loaded simplemod')

In diesem Code:

  • x = 42 erstellt eine globale Variable namens x und weist ihr den Wert 42 zu. Globale Variablen können von überall innerhalb des Moduls aus zugegriffen werden.
  • Die Funktion foo() ist so definiert, dass sie den Wert der globalen Variable x ausgibt. Funktionen sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen.
  • Die Klasse Spam ist ein Bauplan für das Erstellen von Objekten. Sie hat eine Methode namens yow(), die einfach die Zeichenkette 'Yow!' ausgibt. Methoden sind Funktionen, die zu einer Klasse gehören.
  • Die Anweisung print('Loaded simplemod') ist eine Skriptanweisung. Sie wird ausgeführt, sobald das Modul geladen wird, was uns hilft, zu bestätigen, dass das Modul erfolgreich geladen wurde.
  1. Nachdem Sie den Code hinzugefügt haben, speichern Sie die Datei. Sie können dies tun, indem Sie Strg+S auf Ihrer Tastatur drücken oder indem Sie "File" > "Save" aus dem Menü auswählen. Das Speichern der Datei stellt sicher, dass alle Änderungen, die Sie vorgenommen haben, beibehalten werden.

Schauen wir uns genauer an, was dieses Modul enthält:

  • Eine globale Variable x mit dem Wert 42. Diese Variable kann im gesamten Modul verwendet werden und sogar von anderen Modulen aus zugegriffen werden, wenn sie korrekt importiert wird.
  • Eine Funktion foo(), die den Wert von x ausgibt. Funktionen sind nützlich, um wiederholende Aufgaben auszuführen, ohne den gleichen Code mehrmals schreiben zu müssen.
  • Eine Klasse Spam mit einer Methode yow(). Klassen und Methoden sind grundlegende Konzepte der objektorientierten Programmierung, die es Ihnen ermöglichen, komplexe Datenstrukturen und Verhaltensweisen zu erstellen.
  • Eine print-Anweisung, die ausgeführt wird, wenn das Modul geladen wird. Diese Anweisung dient als visueller Indikator dafür, dass das Modul erfolgreich in die Python-Umgebung geladen wurde.

Die print-Anweisung am Ende wird uns helfen, zu beobachten, wann das Modul geladen wird, was wichtig für das Debugging und das Verständnis der Funktionsweise von Modulen in Python ist.

✨ Lösung prüfen und üben

Importieren und Verwenden von Modulen

Nachdem wir nun ein Modul erstellt haben, ist es an der Zeit, zu verstehen, wie wir es importieren und seine Komponenten nutzen können. In Python ist ein Modul eine Datei, die Python-Definitionen und Anweisungen enthält. Wenn Sie ein Modul importieren, erhalten Sie Zugang zu allen Funktionen, Klassen und Variablen, die darin definiert sind. Dies ermöglicht es Ihnen, Code wiederzuverwenden und Ihre Programme effektiver zu organisieren.

  1. Zunächst müssen wir im WebIDE ein neues Terminal öffnen. Dieses Terminal dient als Arbeitsbereich, in dem wir Python-Befehle ausführen können. Um ein neues Terminal zu öffnen, klicken Sie auf "Terminal" > "New Terminal".

  2. Sobald das Terminal geöffnet ist, müssen wir den Python-Interpreter starten. Der Python-Interpreter ist ein Programm, das Python-Code liest und ausführt. Um ihn zu starten, geben Sie den folgenden Befehl im Terminal ein und drücken Sie die Eingabetaste:

python3
  1. Jetzt, da der Python-Interpreter läuft, können wir unser Modul importieren. In Python verwenden wir die import-Anweisung, um ein Modul in unser aktuelles Programm einzubinden. Geben Sie den folgenden Befehl im Python-Interpreter ein:
>>> import simplemod
Loaded simplemod

Sie werden bemerken, dass "Loaded simplemod" in der Ausgabe erscheint. Dies liegt daran, dass die print-Anweisung in unserem simplemod-Modul ausgeführt wird, wenn das Modul geladen wird. Wenn Python ein Modul importiert, führt es all den obersten Code in diesem Modul aus, einschließlich aller print-Anweisungen.

  1. Nachdem wir das Modul importiert haben, können wir seine Komponenten mit der Punktnotation zugreifen. Die Punktnotation ist eine Möglichkeit, Attribute (Variablen und Funktionen) eines Objekts in Python zuzugreifen. In diesem Fall ist das Modul ein Objekt, und seine Funktionen, Variablen und Klassen sind seine Attribute. Hier sind einige Beispiele, wie Sie verschiedene Komponenten des simplemod-Moduls zugreifen können:
>>> simplemod.x
42
>>> simplemod.foo()
x is 42
>>> spam_instance = simplemod.Spam()
>>> spam_instance.yow()
Yow!

In der ersten Zeile greifen wir auf die Variable x zu, die im simplemod-Modul definiert ist. In der zweiten Zeile rufen wir die Funktion foo aus dem simplemod-Modul auf. In der dritten und vierten Zeile erstellen wir eine Instanz der Spam-Klasse, die im simplemod-Modul definiert ist, und rufen ihre Methode yow auf.

  1. Manchmal können Sie beim Versuch, ein Modul zu importieren, einen ImportError erhalten. Dieser Fehler tritt auf, wenn Python das Modul, das Sie importieren möchten, nicht finden kann. Um herauszufinden, wo Python nach Modulen sucht, können Sie die sys.path-Variable untersuchen. Die sys.path-Variable ist eine Liste von Verzeichnissen, die Python durchsucht, wenn es nach Modulen sucht. Geben Sie die folgenden Befehle im Python-Interpreter ein:
>>> import sys
>>> sys.path
['', '/usr/lib/python310.zip', '/usr/lib/python3.10', '/usr/lib/python3.10/lib-dynload', '/usr/local/lib/python3.10/dist-packages', '/usr/lib/python3/dist-packages']

Das erste Element in der Liste (der leere String) repräsentiert das aktuelle Arbeitsverzeichnis. Hier sucht Python nach der Datei simplemod.py. Wenn Ihr Modul nicht in einem der in sys.path aufgeführten Verzeichnisse liegt, kann Python es nicht finden, und Sie erhalten einen ImportError. Stellen Sie sicher, dass Ihre simplemod.py-Datei im aktuellen Arbeitsverzeichnis oder in einem der anderen Verzeichnisse in sys.path liegt.

Verständnis des Modulladeverhaltens

In Python hat die Art und Weise, wie Module geladen werden, einige interessante Eigenschaften. In diesem Schritt werden wir diese Verhaltensweisen untersuchen, um zu verstehen, wie Python das Laden von Modulen verwaltet.

  1. Zunächst sehen wir uns an, was passiert, wenn wir versuchen, ein Modul erneut innerhalb derselben Python-Interpreter-Sitzung zu importieren. Wenn Sie einen Python-Interpreter starten, ist es wie das Öffnen eines Arbeitsbereichs, in dem Sie Python-Code ausführen können. Nachdem Sie ein Modul importiert haben, könnte es so aussehen, als würde das erneute Importieren des Moduls es neu laden, aber das ist nicht der Fall.
>>> import simplemod

Beachten Sie, dass Sie diesmal die Ausgabe "Loaded simplemod" nicht sehen. Dies liegt daran, dass Python ein Modul pro Interpreter-Sitzung nur einmal lädt. Nachfolgende import-Anweisungen laden das Modul nicht neu. Python merkt sich, dass es das Modul bereits geladen hat, und führt daher nicht erneut den Ladevorgang durch.

  1. Nachdem Sie ein Modul importiert haben, können Sie die Variablen darin ändern. Ein Modul in Python ist wie ein Behälter, der Variablen, Funktionen und Klassen enthält. Nachdem Sie ein Modul importiert haben, können Sie auf seine Variablen zugreifen und sie ändern, genau wie bei jedem anderen Python-Objekt.
>>> simplemod.x
42
>>> simplemod.x = 13
>>> simplemod.x
13
>>> simplemod.foo()
x is 13

Hier überprüfen wir zunächst den Wert der Variable x im simplemod-Modul, der zunächst 42 ist. Dann ändern wir seinen Wert auf 13 und überprüfen, ob die Änderung vorgenommen wurde. Wenn wir die Funktion foo im Modul aufrufen, spiegelt sie den neuen Wert von x wider.

  1. Das erneute Importieren des Moduls setzt die Änderungen, die wir an seinen Variablen vorgenommen haben, nicht zurück. Selbst wenn wir versuchen, das Modul erneut zu importieren, lädt Python es nicht neu, sodass die Änderungen, die wir an seinen Variablen vorgenommen haben, bestehen bleiben.
>>> import simplemod
>>> simplemod.x
13
  1. Wenn Sie ein Modul zwangsweise neu laden möchten, müssen Sie die Funktion importlib.reload() verwenden. Manchmal haben Sie möglicherweise Änderungen am Code des Moduls vorgenommen und möchten, dass diese Änderungen sofort wirksam werden. Die Funktion importlib.reload() ermöglicht Ihnen genau das.
>>> import importlib
>>> importlib.reload(simplemod)
Loaded simplemod
<module 'simplemod' from 'simplemod.py'>
>>> simplemod.x
42
>>> simplemod.foo()
x is 42

Das Modul wurde neu geladen, und der Wert von x wurde auf 42 zurückgesetzt. Dies zeigt, dass das Modul erneut aus seinem Quellcode geladen wurde und alle Variablen wie ursprünglich initialisiert wurden.

  1. Python verfolgt alle geladenen Module im sys.modules-Wörterbuch. Dieses Wörterbuch fungiert als Registry, in der Python Informationen über alle Module speichert, die während der aktuellen Interpreter-Sitzung geladen wurden.
>>> 'simplemod' in sys.modules
True
>>> sys.modules['simplemod']
<module 'simplemod' from 'simplemod.py'>

Indem Sie überprüfen, ob ein Modulname im sys.modules-Wörterbuch enthalten ist, können Sie feststellen, ob das Modul geladen wurde. Und indem Sie auf das Wörterbuch mit dem Modulnamen als Schlüssel zugreifen, können Sie Informationen über das Modul erhalten.

  1. Sie können ein Modul aus diesem Wörterbuch entfernen, um Python zu zwingen, es beim nächsten Import neu zu laden. Wenn Sie ein Modul aus dem sys.modules-Wörterbuch entfernen, vergisst Python, dass es das Modul bereits geladen hat. Wenn Sie es das nächste Mal versuchen, zu importieren, wird Python es erneut aus seinem Quellcode laden.
>>> del sys.modules['simplemod']
>>> import simplemod
Loaded simplemod
>>> simplemod.x
42

Das Modul wurde erneut geladen, weil es aus sys.modules entfernt wurde. Dies ist eine weitere Möglichkeit, sicherzustellen, dass Sie mit der neuesten Version des Codes eines Moduls arbeiten.

Verwendung der from module import-Syntax

In Python gibt es verschiedene Möglichkeiten, Komponenten aus Modulen zu importieren. Eine dieser Möglichkeiten ist die from module import-Syntax, die wir in diesem Abschnitt untersuchen werden.

Wenn Sie Komponenten aus einem Modul importieren, ist es oft eine gute Idee, mit einem sauberen Arbeitsbereich zu beginnen. Dies stellt sicher, dass es keine verbleibenden Variablen oder Einstellungen aus früheren Interaktionen gibt, die unseren aktuellen Versuch stören könnten.

  1. Starten Sie den Python-Interpreter neu, um einen sauberen Zustand zu erhalten:
>>> exit()

Dieser Befehl beendet die aktuelle Python-Interpreter-Sitzung. Nach dem Beenden starten wir eine neue Sitzung, um eine frische Umgebung sicherzustellen.

python3

Dieser Bash-Befehl startet eine neue Python 3-Interpreter-Sitzung. Jetzt, da wir eine saubere Python-Umgebung haben, können wir beginnen, Komponenten aus einem Modul zu importieren.

  1. Importieren Sie spezifische Komponenten aus einem Modul mit der from module import-Syntax:
>>> from simplemod import foo
Loaded simplemod
>>> foo()
x is 42

Hier verwenden wir die Anweisung from simplemod import foo, um nur die Funktion foo aus dem simplemod-Modul zu importieren. Beachten Sie, dass obwohl wir nur die Funktion foo angefordert haben, das gesamte simplemod-Modul geladen wurde. Dies wird durch die Ausgabe "Loaded simplemod" angezeigt. Der Grund dafür ist, dass Python das gesamte Modul laden muss, um auf die Funktion foo zugreifen zu können.

  1. Wenn Sie from module import verwenden, können Sie nicht auf das Modul selbst zugreifen:
>>> simplemod.foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'simplemod' is not defined

Wenn wir die from module import-Syntax verwenden, bringen wir nur die angegebenen Komponenten direkt in unseren Namensraum ein. Der Modulname selbst wird nicht importiert. Wenn wir also versuchen, auf simplemod.foo() zuzugreifen, erkennt Python simplemod nicht, weil es nicht auf diese Weise importiert wurde.

  1. Sie können mehrere Komponenten auf einmal importieren:
>>> from simplemod import x, foo
>>> x
42
>>> foo()
x is 42

Die from module import-Syntax ermöglicht es uns, mehrere Komponenten aus einem Modul in einer einzigen Anweisung zu importieren. Hier importieren wir sowohl die Variable x als auch die Funktion foo aus dem simplemod-Modul. Nach dem Import können wir direkt auf diese Komponenten in unserem Code zugreifen.

  1. Wenn Sie eine Variable aus einem Modul importieren, erstellen Sie eine neue Referenz auf das Objekt, nicht einen Link zur Variable im Modul:
>>> x = 13  ## Ändern Sie die lokale Variable x
>>> x
13
>>> foo()
x is 42  ## Die Funktion verwendet immer noch die Variable x des Moduls, nicht Ihre lokale Variable x

Wenn wir eine Variable aus einem Modul importieren, erstellen wir im Wesentlichen eine neue Referenz auf dasselbe Objekt in unserem lokalen Namensraum. Wenn wir also die lokale Variable x auf 13 ändern, wirkt sich dies nicht auf die Variable x im simplemod-Modul aus. Die Funktion foo() bezieht sich immer noch auf die Variable x des Moduls, die 42 ist. Das Verständnis dieses Konzepts ist entscheidend, um Verwirrungen in Ihrem Code zu vermeiden.

Untersuchung der Einschränkungen beim Neuladen von Modulen

Das Neuladen von Modulen ist eine nützliche Funktion in Python, aber es gibt einige Einschränkungen, insbesondere wenn es um Klassen geht. In diesem Abschnitt werden wir diese Einschränkungen Schritt für Schritt untersuchen. Das Verständnis dieser Einschränkungen ist sowohl für die Entwicklung als auch für Produktionsumgebungen von entscheidender Bedeutung.

  1. Starten Sie den Python-Interpreter neu:
    Zunächst müssen wir den Python-Interpreter neu starten. Dieser Schritt ist wichtig, da er sicherstellt, dass wir mit einem sauberen Arbeitsbereich beginnen. Wenn Sie den Interpreter neu starten, werden alle zuvor importierten Module und Variablen gelöscht. Um die aktuelle Python-Interpreter-Sitzung zu beenden, verwenden Sie den Befehl exit(). Starten Sie dann eine neue Python-Interpreter-Sitzung mit dem Befehl python3 im Terminal.
>>> exit()
python3
  1. Importieren Sie das Modul und erstellen Sie eine Instanz der Klasse Spam:
    Nun, da wir eine frische Python-Interpreter-Sitzung haben, werden wir das simplemod-Modul importieren. Das Importieren eines Moduls ermöglicht es uns, die in diesem Modul definierten Klassen, Funktionen und Variablen zu verwenden. Nach dem Importieren des Moduls werden wir eine Instanz der Klasse Spam erstellen und ihre Methode yow() aufrufen. Dies hilft uns, das anfängliche Verhalten der Klasse zu sehen.
>>> import simplemod
Loaded simplemod
>>> s = simplemod.Spam()
>>> s.yow()
Yow!
  1. Ändern wir nun die Klasse Spam in unserem Modul. Beenden Sie den Python-Interpreter:
    Als Nächstes werden wir Änderungen an der Klasse Spam im simplemod-Modul vornehmen. Bevor wir das tun, müssen wir den Python-Interpreter beenden. Dies liegt daran, dass wir Änderungen am Quellcode des Moduls vornehmen und dann sehen möchten, wie diese Änderungen das Verhalten der Klasse beeinflussen.
>>> exit()
  1. Öffnen Sie die Datei simplemod.py im WebIDE und ändern Sie die Klasse Spam:
    Öffnen Sie die Datei simplemod.py im WebIDE. Hier befindet sich der Quellcode des simplemod-Moduls. Wir werden die Methode yow() der Klasse Spam ändern, um eine andere Nachricht auszugeben. Diese Änderung hilft uns zu beobachten, wie sich das Verhalten der Klasse nach dem Neuladen des Moduls ändert.
## simplemod.py
## ... (lassen Sie den Rest der Datei unverändert)

class Spam:
    def yow(self):
        print('More Yow!')  ## Geändert von 'Yow!'
  1. Speichern Sie die Datei und kehren Sie zum Terminal zurück. Starten Sie den Python-Interpreter und erstellen Sie eine neue Instanz:
    Nachdem Sie die Änderungen an der Datei simplemod.py vorgenommen haben, speichern Sie sie. Kehren Sie dann zum Terminal zurück und starten Sie eine neue Python-Interpreter-Sitzung. Importieren Sie das simplemod-Modul erneut und erstellen Sie eine neue Instanz der Klasse Spam. Rufen Sie die Methode yow() der neuen Instanz auf, um das aktualisierte Verhalten zu sehen.
python3
>>> import simplemod
Loaded simplemod
>>> t = simplemod.Spam()
>>> t.yow()
More Yow!
  1. Zeigen wir nun, was beim Neuladen passiert:
    Um zu sehen, wie das Neuladen von Modulen funktioniert, verwenden wir die Funktion importlib.reload(). Diese Funktion ermöglicht es uns, ein zuvor importiertes Modul neu zu laden. Nach dem Neuladen des Moduls werden wir sehen, ob die Änderungen, die wir an der Klasse Spam vorgenommen haben, widergespiegelt werden.
>>> import importlib
>>> importlib.reload(simplemod)
Loaded simplemod
<module 'simplemod' from 'simplemod.py'>
  1. Beenden Sie Python, ändern Sie die Datei erneut und testen Sie dann beide Instanzen:
    Beenden Sie den Python-Interpreter erneut. Machen Sie dann eine weitere Änderung an der Klasse Spam in der Datei simplemod.py. Danach werden wir sowohl die alte als auch die neue Instanz der Klasse Spam testen, um zu sehen, wie sie sich verhalten.
>>> exit()
  1. Aktualisieren Sie die Datei simplemod.py:
    Öffnen Sie die Datei simplemod.py erneut und ändern Sie die Methode yow() der Klasse Spam, um eine andere Nachricht auszugeben. Diese Änderung hilft uns, die Einschränkungen beim Neuladen von Modulen besser zu verstehen.
## simplemod.py
## ... (lassen Sie den Rest der Datei unverändert)

class Spam:
    def yow(self):
        print('Even More Yow!')  ## Wieder geändert
  1. Speichern Sie die Datei und kehren Sie zum Terminal zurück:
    Speichern Sie die Änderungen an der Datei simplemod.py und kehren Sie zum Terminal zurück. Starten Sie eine neue Python-Interpreter-Sitzung, importieren Sie das simplemod-Modul und erstellen Sie eine neue Instanz der Klasse Spam. Rufen Sie die Methode yow() der neuen Instanz auf, um das aktualisierte Verhalten zu sehen.
python3
>>> import simplemod
Loaded simplemod
>>> s = simplemod.Spam()
>>> s.yow()
Even More Yow!

>>> ## Beenden Sie ohne Python zu schließen, bearbeiten Sie die Datei
  1. Öffnen Sie ohne Python zu schließen die Datei simplemod.py im WebIDE und ändern Sie sie:
    Ohne den Python-Interpreter zu schließen, öffnen Sie die Datei simplemod.py im WebIDE und machen Sie eine weitere Änderung an der Methode yow() der Klasse Spam. Dies hilft uns zu sehen, wie sich das Verhalten bestehender und neuer Instanzen nach dem Neuladen des Moduls ändert.
## simplemod.py
## ... (lassen Sie den Rest der Datei unverändert)

class Spam:
    def yow(self):
        print('Super Yow!')  ## Noch einmal geändert
  1. Speichern Sie die Datei und kehren Sie zum Python-Interpreter zurück:
    Speichern Sie die Änderungen an der Datei simplemod.py und kehren Sie zum Python-Interpreter zurück. Laden Sie das simplemod-Modul mit der Funktion importlib.reload() neu. Testen Sie dann sowohl die alte als auch die neue Instanz der Klasse Spam, um zu sehen, wie sie sich verhalten.
>>> import importlib
>>> importlib.reload(simplemod)
Loaded simplemod
<module 'simplemod' from 'simplemod.py'>

>>> ## Versuchen Sie die alte Instanz
>>> s.yow()
Even More Yow!  ## Verwenden Sie immer noch die alte Implementierung

>>> ## Erstellen Sie eine neue Instanz
>>> t = simplemod.Spam()
>>> t.yow()
Super Yow!  ## Verwenden Sie die neue Implementierung

Beachten Sie, dass die alte Instanz s immer noch die alte Implementierung verwendet, während die neue Instanz t die neue Implementierung verwendet. Dies geschieht, weil das Neuladen eines Moduls bestehende Instanzen von Klassen nicht aktualisiert. Wenn eine Klasseninstanz erstellt wird, speichert sie einen Verweis auf das Klassenobjekt zu diesem Zeitpunkt. Das Neuladen des Moduls erstellt ein neues Klassenobjekt, aber die bestehenden Instanzen verweisen immer noch auf das alte Klassenobjekt.

  1. Sie können auch andere ungewöhnliche Verhaltensweisen beobachten:
    Wir können die Einschränkungen beim Neuladen von Modulen weiter untersuchen, indem wir die Funktion isinstance() verwenden. Diese Funktion prüft, ob ein Objekt eine Instanz einer bestimmten Klasse ist. Nach dem Neuladen des Moduls werden wir sehen, dass die alte Instanz s nicht mehr als Instanz der neuen Klasse simplemod.Spam angesehen wird, während die neue Instanz t es ist.
>>> isinstance(s, simplemod.Spam)
False
>>> isinstance(t, simplemod.Spam)
True

Dies zeigt, dass nach dem Neuladen simplemod.Spam auf ein anderes Klassenobjekt verweist als das, das zur Erstellung von s verwendet wurde.

Diese Einschränkungen machen das Neuladen von Modulen hauptsächlich für die Entwicklung und das Debugging nützlich, aber es wird für Produktionscode nicht empfohlen. In einer Produktionsumgebung ist es wichtig sicherzustellen, dass alle Instanzen einer Klasse dieselbe, aktuellste Implementierung verwenden. Das Neuladen von Modulen kann zu inkonsistentem Verhalten führen, das schwierig zu debuggen und zu warten ist.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Arbeit mit Modulen in Python gelernt. Sie wissen nun, wie Sie ein Python-Modul als .py-Datei mit Variablen, Funktionen und Klassen erstellen und wie Sie Module mit der import-Anweisung importieren. Sie verstehen auch, dass Python Module einmal pro Interpreter-Sitzung lädt und dass Sie importlib.reload() verwenden können, um ein Neuladen zu erzwingen.

Darüber hinaus haben Sie das sys.modules-Dictionary (Wörterbuch) zur Verwaltung von geladenen Modulen untersucht, die from module import-Syntax verwendet, um spezifische Komponenten zu importieren, und die Einschränkungen beim Neuladen von Modulen, insbesondere bei Klassen, verstanden. Diese Konzepte bilden die Grundlage für die Organisation von Python-Code in wiederverwendbare Komponenten, was für die Aufrechterhaltung der Code-Struktur und die Förderung der Wiederverwendbarkeit in größeren Anwendungen unerlässlich ist.