Python #18: laden von Modulen

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“

Downloadpacket "Eclipse for Java Developer"
Downloadpacket „Eclipse for Java Developer“

Ich verwende die 64bit Version für Microsoft Windows.

Im nachfolgenden Video zeige ich dir wie du in Eclipse das Plugin PyDEV einrichtest.

Einrichten von PyDEV in der Eclipse IDE for Java Developer
Dieses Video ansehen auf YouTube.

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:

Eclipse IDE - PyDEV "Hallo Welt!"
Eclipse IDE – PyDEV „Hallo Welt!“

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“.

Projektstruktur PyDEV
Projektstruktur PyDEV

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.

Import eines Modules mit Ausgabe auf der Konsole in Python
Import eines Modules mit Ausgabe auf der Konsole in Python

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.

Import und verwenden des Modules matplotlib
Import und verwenden des Modules matplotlib

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

Import einer Methode aus einem Modul in Python
Import einer Methode aus einem Modul in Python

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.

Import von Modulen in Python mit einem Sternchen
Import von Modulen in Python mit einem Sternchen

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 das 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 so das Änderungen am Quellcode nachverfolgt werden können.

 

 

Ein Gedanke zu „Python #18: laden von Modulen

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.