Einführung
Python ist eine der am häufigsten verwendeten Programmiersprachen weltweit. Module sind ein entscheidender Teil des Python-Codes. Ein Modul ist einfach eine .py-Datei im Kontext von Python 3. Das bedeutet, dass Sie jede Python-Datei als Modul bezeichnen können.
Es ist möglich, diese Module über die vorgefertigte Bibliothek zu beziehen. Sie können einen Blick auf die Python-Standardbibliothek werfen, um mehr zu erfahren. Diese werden auf Ihrem System installiert, wenn Sie Python installieren. In anderen Situationen können Sie diese Module mit dem Python-Paketmanager pip installieren. Aber was ist, wenn Sie ein benutzerdefiniertes Modul erstellen möchten? Wenn dies der Fall ist, wird es Sie freuen zu hören, dass Sie in Python Ihre eigenen Module erstellen können.
In dieser detaillierten Anleitung werden wir die Schritte beschreiben, die Sie befolgen müssen, um Module in Python 3 zu schreiben und zu importieren.
Voraussetzungen
Bevor wir beginnen, müssen Sie sicherstellen, dass Sie Python 3 installiert und eine Programmierumgebung eingerichtet haben. Sie können unserem Tutorial zur Installation von Python 3 und zur Einrichtung einer lokalen Programmierumgebung auf Ubuntu 16.04 folgen, um die Installation abzuschließen, falls Sie diese noch nicht bereit haben.
Wie schreibt man ein Modul?
Beginnen wir mit dem Schreiben eines Moduls. Sie schreiben ein Modul genau so, wie Sie jede andere Python-Datei verfassen würden. Ein typisches Modul umfasst die Definitionen von Funktionen, Klassen und Variablen. Anschließend können Sie das Modul verwenden, um es auf andere Python-Programme anzuwenden.
Um Ihnen das Verständnis zu erleichtern, betrachten wir ein Beispiel. Nehmen wir an, wir möchten eine Datei namens hello.py erstellen. Wir werden diese später auch in eine andere Datei importieren. Der erste Schritt in diesem Prozess ist das Erstellen einer Funktion. Diese Funktion dient dazu, Hello, World! wie folgt auszugeben:
|
1 2 3 |
# Eine Funktion definieren def world(): print("Hello, World!") |
Zu diesem Zeitpunkt wird das Ausführen des Befehls python hello.py Ihnen kein Ergebnis liefern. Das liegt daran, dass wir dem Programm noch keine Anweisungen gegeben haben. Damit es funktioniert, müssen wir das Modul importieren.
Wie importiert man ein Modul?
Um Ihr Modul zu importieren, damit es als Funktion genutzt werden kann, müssen Sie eine zweite Datei im selben Verzeichnis erstellen. Wir nennen diese neue Datei main_program.py. Der Grund, warum sich beide Dateien im selben Verzeichnis befinden müssen, ist, dass wir dem Programm zeigen müssen, wo es das Modul findet. Dies gilt für jedes neue, benutzerdefinierte Modul, das nicht integriert ist:
|
1 2 3 4 5 |
# Modul hello importieren import hello # Funktion aufrufen hello.world() |
Wir haben die Punktschreibweise für den Modulnamen verwendet, um die Funktion aufzurufen. Eine andere Möglichkeit hierfür ist die Verwendung der Methode from...import. Hier rufen wir die Funktion als world() auf, indem wir das Modul als from hello import world importieren. Schließlich können Sie den Befehl ausführen:
|
1 |
python main_program.py |
Der Befehl zeigt Ihnen die folgende Ausgabe:
|
1 2 |
Ausgabe: Hello, World! |
Variablen zu einem Modul hinzufügen
Als Nächstes werden wir sehen, wie man Variablen zum Modul hinzufügt, indem man Definitionen in das Modul einfügt:
|
1 2 3 4 5 6 |
# Eine Funktion definieren def world(): print("Hello, World!") # Eine Variable definieren shark = "Sammy" |
Anschließend rufen Sie die Variable in der Funktion print() auf. Wir rufen sie innerhalb der Datei main_program.py auf:
|
1 2 3 4 5 6 7 |
# Modul hello importieren import hello # Funktion aufrufen hello.world() # Variable ausgeben print(hello.shark) |
Das Ausführen des Programms zeigt diese Ausgabe:
|
1 2 3 |
Ausgabe: Hello, World! Sammy |
Eine Klasse zu einem Modul hinzufügen
Zuletzt werden wir sehen, wie Sie eine Klasse in Ihrer Datei definieren können. Um unser Beispiel fortzusetzen, werden wir eine neue Klasse namens Octopus in der Datei hello.py erstellen. Wir werden ihr auch die Attribute name und color zuweisen. Dann fügen wir eine Funktion hinzu, um sie druckbar zu machen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# Eine Funktion definieren def world(): print("Hallo, Welt!") # Eine Variable definieren shark = "Sammy" # Eine Klasse definieren class Octopus: def __init__(self, name, color): self.color = color self.name = name def tell_me_about_the_octopus(self): print("Dieser Krake ist " + self.color + ".") print(self.name + " ist der Name des Kraken.") |
Als Nächstes müssen Sie die Klasse nahe dem Ende der main_program.py-Datei:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# hello-Modul importieren import hello # Funktion aufrufen hello.world() # Variable ausgeben print(hello.shark) # Klasse aufrufen jesse = hello.Octopus("Jesse", "orange") jesse.tell_me_about_the_octopus() |
Sie können die Klasse mit dem Befehl hello.Octopus() aufrufen. Er zeigt Ihnen die Funktionen und Attribute der Octopus-Klasse im Namensraum der Datei. Daher können Sie in der letzten Zeile jesse.tell_me_about_the_octopus() schreiben, ohne hello aufzurufen. Es ist auch möglich, ein einzelnes Attribut der Klasse aufzurufen, ohne hello zu verwenden. Sie können beispielsweise einfach jesse.color ausführen. Wenn Sie das Programm ausführen, wird die folgende Ausgabe angezeigt:
|
1 2 3 4 5 |
Ausgabe: Hallo, Welt! Sammy Dieser Krake ist orange. Jesse ist der Name 'des Kraken. |
Code mit Modulen implementieren
Wo Sie Module verwenden können, um Definitionen festzulegen, können Sie sie auch zur Implementierung von Code nutzen. Nehmen wir an, wir möchten die world()-Funktion implementieren. Wir werden unsere ursprüngliche hello.py-Datei komplett umschreiben:
|
1 2 3 4 5 6 |
# Eine Funktion definieren def world(): print("Hallo, Welt!") # Funktion innerhalb des Moduls aufrufen world() |
Aus der main_program.py-Datei werden wir alles außer der Import-Anweisung löschen, sodass Folgendes übrig bleibt:
|
1 2 |
# hello-Modul importieren import hello |
Das Ausführen der Hauptprogrammdatei liefert diese Ausgabe, da das Programm die world()-Funktion implementiert und ausführt:
|
1 2 |
Ausgabe: Hallo, Welt! |
Wie greift man von einem anderen Verzeichnis aus auf ein Modul zu?
Da Sie nun wissen, wie Sie Module erstellen und ändern, müssen Sie wissen, wie Sie von einem anderen Verzeichnis aus auf sie zugreifen können. Dies ist nützlich, wenn Sie ein bestimmtes Modul in einem anderen Projekt verwenden müssen. Es gibt zwei Möglichkeiten, dies zu tun, die wir im Folgenden erläutern werden.
-
Pfade anhängen
Die erste Methode besteht darin, den Modulpfad mithilfe der Programmierdateien zu aktivieren, die das Modul bereits verwenden. Leider bedeutet dies nicht, dass das Modul im gesamten System verfügbar sein wird. Daher wird es nur als temporäre Lösung angesehen. Es wird häufig während der Entwicklungsphase des Projekts eingesetzt.
Sie können den Anhängevorgang starten, indem Sie das Modul sys und andere wichtige Module importieren, die Sie verwenden müssen. Wir werden sie in die Hauptprogrammdatei importieren. Sie finden das Modul sys in der Python-Standardbibliothek. Sie benötigen es, da es die grundlegenden Parameter und Funktionen enthält, die für Ihr System spezifisch sind.
Betrachten wir noch einmal unser vorheriges Beispiel. Nehmen wir an, die hello.py-Datei befindet sich im Pfad /usr/sammy/ und die main_program.py-Datei befindet sich in einem anderen Verzeichnis. Wir werden das hello-Modul in der main_program.py-Datei zuerst mithilfe des sys-Moduls importieren. Als Nächstes hängen wir /usr/sammy/ an den Pfad an:
|
1 2 3 4 5 6 |
import sys sys.path.append('/usr/sammy/') import hello ... |
Wenn Sie den Pfad korrekt eingestellt haben, wird die main_program.py Datei wird problemlos und ohne Fehler ausgeführt. Sie erhalten dieselbe Ausgabe wie zuvor, als sich beide Dateien im selben Verzeichnis befanden.
-
Python-Pfad
Die andere Option, die Sie wählen können, ist der Python-Pfad. Hierbei fügen Sie das Modul selbst zu einem Pfad hinzu, den Python nach Modulen und Paketen durchsucht. Wie Sie sich wahrscheinlich schon denken können, macht dies das Modul systemweit verfügbar, was es zu einer praktikablen dauerhaften Lösung macht.
Um dies zu tun, müssen Sie herausfinden, wo Python nach Modulen sucht. Sie müssen den Python-Interpreter aus der Programmierumgebung ausführen, was so aussieht:
|
1 |
python |
Der nächste Schritt besteht darin, das sys -Modul zu importieren:
|
1 |
>>> import sys |
Als Nächstes geben Sie den Systempfad aus:
|
1 |
>>> print(sys.path) |
Nun sehen Sie einen Systempfad als Ausgabe. Es wird mindestens einer vorhanden sein. In einer Programmierumgebung kann es jedoch auch mehrere geben. Suchen Sie in der Liste nach der Umgebung, die Sie verwenden. Denken Sie daran, dass Sie das Modul möglicherweise auch dem Haupt-Python-Pfad des Systems hinzufügen möchten. Das sieht dann so aus:
|
1 2 |
Ausgabe: '/usr/sammy/my_env/lib/python3.5/site-packages' |
Verschieben Sie schließlich die hello.py -Datei in dieses Verzeichnis und importieren Sie das Modul wie folgt:
|
1 2 |
import hello ... |
Ihr Versuch ist erfolgreich, wenn das Programm die Datei ohne Fehler ausführt. Als Ergebnis dieses Prozesses können Sie von jedem Verzeichnis auf Ihrem System aus auf das Modul zugreifen.
Fazit
Das Ziel dieses Tutorials war es, Ihnen das Schreiben von Python-Modulen näherzubringen. Es ist sehr ähnlich wie das Schreiben einer beliebigen Python- .py-Datei. Wir haben zuerst darüber gesprochen, was ein Python-Modul und die damit verbundenen Funktionen eigentlich sind. Dann haben wir herausgefunden, wie man diese Definitionen in anderen Programmierdateien in Python anwendet. Schließlich haben wir die Details der Modul-Zugänglichkeit geklärt. Jetzt wissen Sie, wie Sie Module in Python 3 schreiben und darauf zugreifen können.
Um Ihr Wissen über die Programmiersprache Python weiter auszubauen, lesen Sie unseren Blog für weitere Ressourcen:
- Python 3: Ein Leitfaden zur Konvertierung von Datentypen
- Schleifen in Python 3: Verwendung von Break-, Continue- und Pass-Anweisungen
- Verwendung von Python 3 String-Formatierern
Viel Spaß beim Programmieren!
Kommentare
Noch keine Kommentare. Schreiben Sie den ersten.