Wenn wir große Projekte / Programme entwickeln wollen, kommen wir nicht umher den Quellcode in mehrere Module zu packen. In diesem Beitrag möchte ich dir also nun zeigen wie du Quellcode in mehrere Module aufteilen kannst und somit deinen Code besser strukturierst.
Ein weiterer Vorteil von Modulen ist dass, häufig verwendete Methoden ausgelagert und wiederverwendet werden können, zbsp. ein Reader für eine CSV Datei.
Für dieses Beispiel verwende ich statt der IDE Anaconda und jypiter die Entwicklungsumgebung Eclipse. Das liegt an dem Caching der Imports aber dazu später mehr.
Installieren der Eclipse IDE & einrichten von PyDEV
Wie bereits erwähnt verwende ich für diesen Beitrag die Entwicklungsumgebung Eclipse und das Plugin PyDEV (welches später über den Eclipse Marketplace installiert wird).
Zunächst benötigen wir die IDE Eclipse die kann von der Seite https://www.eclipse.org/downloads/packages/ kostenfrei heruntergeladen werden.
Ich verwende zunächst das Packet „Eclipse IDE for Java Developers“
Ich verwende die 64bit Version für Microsoft Windows.
Im nachfolgenden Video zeige ich dir wie du in Eclipse das Plugin PyDEV einrichtest.
Wenn die IDE eingerichtet wurde, kann ein neues Projekt erstellt werden in welchem wir dann unseren Quellcode schreiben.
prüfen der Installation und Konfiguration
Wenn die Installation und Konfiguration abgeschlossen ist, prüfen wir kurz ob alles korrekt eingerichtet ist. Dazu erstellen wir uns eine neue Quellcode Datei und benennen diese in „moduleTest.py“.
Nun geben wir mit dem Befehl:
print("Hallo Welt!")
die Zeichenkette „Hello World!“ auf der Konsole aus.
Wenn alles klappt sollte also folgende Ausgabe erfolgen:
Import von Modulen
Nachdem wir nun die Entwicklungsumgebung eingerichtet und getestet haben, können wir uns dem eigentlichen Thema widmen „laden von Modulen in Python3“. Das laden von Modulen kann ganz unterschiedlich erfolgen im nachfolgenden möchte ich auf jede mir bekannte Möglichkeit eingehen und ein Beispiel dazu zeigen.
Was ist ein Modul?
Ein Modul ist ein Ordner in welchem Python Dateien (*.py) liegen welche importiert werden können. In diesem Ordner muss zusätzlich die Datei „__init__.py“ abgelegt werden.
In dieser Datei können spezielle Befehle den Import von Modulen aus diesem Packet erweitern bzw. ermöglichen.
Projektstruktur PyDEV
Im nachfolgenden zeige ich ein Screenshot von der Projektstruktur in PyDEV.
Es ist bereits ein Modul „modul1“ angelegt sowie eine Pythondatei „myModul1.py“ und die Konfigurationsdatei „__init__.py“.
Befehl import
Mit dem Befehl „import“ gefolgt vom Pfad und Namen des Modules können wir dieses importieren.
import modul1.myModul1
Wenn ein Modul importiert wird, wird dieses sogleich auch ausgeführt. D.h. wenn wir in dem Modul „myModul1.py“ eine Ausgabe auf der Konsole tätigen (außerhalb einer Methode) dann wird diese sofort ausgegeben wenn wir unsere Pythondatei starten.
Wir sehen hier es wird das Modul „modul1.myModul1“ importiert und sofort die Ausgabe auf der Konsole ausgeführt, danach erfolgt die Ausgabe von „Hallo Welt!“.
„Umbenennen“ von Modulen beim import
Der Name „myModul1“ ist jetzt noch relativ kurz aber wenn man zbsp. das Modul matplotlib.pyplot zum zeichnen von Diagramme verwenden möchte, müsste man immer vor jedem aufruf einer Methode „matplotlib.pyplot“ schreiben.
Damit man sich die Pfadangabe sparen kann gibt es nun das Schlüsselwort „as“, damit können wir den Pfad in einen zbsp. kürzeren oder aber auch sprechenden Namen „umbenennen“.
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()
einzelne Methoden importieren
Ein Modul kann aus mehreren Pythondateien bestehen. Nun könnten wir wie bereits erwähnt das gesamte Modul importieren und entweder mit dem Namen (inkl. Pfad) des Modules die Methoden ansprechen oder man importiert die einzelnen Methoden.
Um eine einzelne Methode aus einem Modul zu importieren muss man diese wie folgt importieren:
from modul1.myModul1 import abc
Nun haben wir die Methode „abc“ in das Pythonprojekt importiert und können darauf zugreifen wie auf jede andere innere Methode auch.
from modul1.myModul1 import abc
def xyz():
print("xyz")
abc()
xyz()
Ausgabe auf der Konsole
Wir haben jedoch nur die Methode „abc“ importiert und nicht die Methode „efg“ (siehe Screenshot). Wenn wir nun auf die Methode „efg“ zugreifen wollen müssten wir diese durch ein Komma getrennt in die Liste der Imports aufnehmen.
from modul1.myModul1 import abc, efg
alle Module aus einem Packet importieren
Um alle Methoden aus einem Modul zu importieren kann man ein Sternchen „*“ hinter dem Befehl „from <Packet> import“ anführen. Damit man Python jedoch weiß welche Dateien gemeint sind müssen diese in der Datei „__init__.py“ in der Liste „__all_“ aufgeführt werden.
__all__ = ['myModul1']
Es ist nun unser einziges Modul „myModul1“ in der Liste aufgeführt und wir können nun wie bereits bekannt auf die Methoden zugreifen jedoch müssen wir den Dateinamen des Modules davorsetzen.
Ich sehe hier keinen direkten vorteil denn man muss sich noch viel mehr mit dem eigentlichen Modul auseinandersetzen denn woher erfahren ich sonst das die Methode „abc“ in dem Modul „myModul1“ enthalten ist?
Beispiel
Hier nun ein Beispiel. Wir haben unsere KfZ Flotte mit Autos und LKWs. Die entsprechenden Klassen Auto & LKW wollen wir nun getrennt von einander verwalten.
Datei auto.py
class Auto():
def __init__(self, marke, modell, baujahr):
self.marke = marke
self.modell = modell
self.baujahr = baujahr
def typ(self):
return self.marke + ", " + self.modell +", " + str(self.baujahr)
def __str__(self):
return self.typ()
def __repr__(self):
return self.typ()
Datei lkw.py
from module.auto import Auto
class LKW(Auto):
def __init__(self, marke, modell, baujahr, ladegewicht):
super().__init__(marke, modell, baujahr)
self.ladegewicht = ladegewicht
def typ(self):
return super().typ() + ", " + str(self.ladegewicht)
Datei main.py
from module.auto import Auto
from module.lkw import LKW
auto1 = Auto("VW", "Golf", 2010)
auto2 = Auto("Ford", "Escord", 2002)
lkw1 = LKW("Mercedes", "Vito", 2005, 7.5)
lkw2 = LKW("Renault", "Trafic", 2015, 3.5)
flotte = [auto1, lkw1, auto2, lkw2]
print(flotte)
Ausgabe auf der Konsole
[VW, Golf, 2010, Mercedes, Vito, 2005, 7.5, Ford, Escord, 2002, Renault, Trafic, 2015, 3.5]
Der Vorteil an der Aufteilung ist nun, dass wir die Daten bequem mit anderen Entwicklern teilen können. Des Weiteren werden Softwareprojekte in einem Quellcodeverwaltungssystem wie SVN, Git, Mercury und andere gespeichert / verwaltet, sodass Änderungen am Quellcode nachverfolgt werden können.