[ Home ] [ Seitenende ]

 

 

 

Micropython, Teil 2

 

In den Micropython Grundlagen, Teil 1Einleitung erste Schritte”, Sprachstruktur, interaktive Konsole, wurde das erste Python-Programm "hallo.py" programmiert und im YouTube-Video besprochen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Auch hier im Teil 2 der “Einleitung erste Schritte”, Sprachstruktur, interaktive Konsole, geht es weiterhin um das erste Python-Programm "hallo.py", wenn auch zunächst in abgewandelter Form.

 

Nachfolgend geht es nämlich darum, das bisherige Programm in eine sogenannte Klasse, engl. „class“, zu transferieren.

 

Doch zunächst gilt es zu klären, was es mit einer Klasse auf sicht hat. Nehmen wir zum Beispiel eine große Gesamtschule, die sich dadurch auszeichnet, dass es an dieser mehrere Schulformen (Grundschule, Haupt- und Realschule, Gymnasium) gibt. Demzufolge haben große Gesamtschulen teilweise deutlich mehr als 1.000 Schüler, sodass es an der Realschule z.B. in einer Jahrgangsstufe gleich mehrere Klassen wie z.B. Klasse 9a) bis 9d) mit jeweils bis zu 30 Schüler*innen pro Klasse, zusammen also 120 Schüler der Jahrgangsstufe 9 gibt.

 

Während also der eine oder andere Lehrer als Deutsch-, Englisch, Physik- oder Mathelehrer in allen Klassen 9a bis 9b unterrichtet, diese also kennt und z.B. hinsichtlich der schulischen Leistungen miteinander vergleichen und einschätzen kann, identifizieren sich die Schüler der Klasse 9a eben nicht mit der Jahrgangsstufe 9 insgesamt, sondern z.B. eher mit ihren sportlich ambitionierten Mitschülern ihrer Klasse 9a.

 

Während es also in der Klasse 9a überwiegend ambitionierte Fußballer gibt, gibt es in der Klasse 9b mehr engagierte Handballer, während sich die Klasse 9d sportlich abgehängt fühlt, sich dafür aber mehr der Natur verbunden fühlt und in der Klasse 9c gibt etliche Technikfreaks, die sich gerne mit Computern und Smartphones und deren Programmierung befassen.

 

Wie man sieht, unterscheiden sich die Klassen 9a bis 9d hinsichtlich der teils spezialisierten Eigenschaften (= Attribute) und Fähigkeiten (= Methoden) ganz erheblich voneinander. So schwärmt der Physiklehrer von der technisch interessierten Klasse 9d, während der Sportlehrer und Fußballfan die sportlichen Fähigkeiten der Klasse 9a besonders schätzt. Jeder eben so, wie er kann, wie es seiner Sozialisation, seinen Interessen, Fähigkeiten und Begabungen entspricht.

 

Bei der Fußball ambitionierten Klasse 9a gibt es wiederum Schüler, die sich als Stürmer in der ersten Reihe bewährt haben, während andere gerne als Verteidiger in der letzten Reihe spielen und sich nur ein einziger gerne als Torwart in den Kasten stellt.

 

In diesem Zusammenhang dient also eine Klasse, engl. „class“, z.B. dazu, junge Menschen mit besonderen sportlichen Attributen (= Eigenschaften) und fußballerischen Methoden (= Fähigkeiten, Fertigkeiten) aufzunehmen und diese bezüglich ihrer sportlichen Ambitionen entsprechend zu fördern. -

 

Nun aber rann an den Speck, erzeugen wir unsere erste Klasse namens „verwalte_Namensliste“ (siehe Programm „micro_python-hallo_2-1.py“)

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man oben im Programm „micro_python-hallo_2-1.py“ sieht, ist die Klasse „verwalte_Namensliste“ noch leer, scheint sich in dieser nichts zu tun.

 

Aber ist dem wirklich so? Wir wissen es nicht, weil wir nichts sehen! Aber das lässt sich ja ändern, indem wir in der Klasse „verwalte_Namensliste“ das „print“-Statement, wie folgt programmieren (siehe Programm „micro_python-hallo_2-2.py“):

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wenn man das Programm „micro_python-hallo_2-2.py“ ausführt, dann staunt der Laie und der Fachmann wundert sich:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wir setzen noch einen drauf und verschieben die Statements, d.h. den Programmblock aus dem Hauptprogramm in die Klasse „verwalte_Namensliste“,

 

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

starten das Programm micro_python-hallo_2-3.py“ und kommen aus dem Staunen nicht heraus,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

die Klasse „verwalte_Namensliste“ startet sich wie von Geisterhand gesteuert ganz von selbst! Ohne Zutun, ohne dass man die Klasse mittels Statement explizit starten würde! Wie kann das sein?

 

Ganz einfach, der Python-Interpreter (= Übersetzer) der „Thonny“-Entwicklungsumgebung „schaut“ sich nicht nur das (Haupt-) Programm an, sondern auch, ob es im Programm selbst auch eine oder mehrere Klassen mit Programmkode gibt.

 

Ist dies der Fall, dann verzweigt der Interpeter in die jeweiligen Klassen und „schaut“ explizit nach, was sich so in der Klasse tut, d.h. was dort so an Programmkode programmiert wurde, und ob dieser Auswirkungen in Form von Verknüpfungen, Verzweigungen, „return“-Ergebnisrückgaben ans (Haupt-) Programm usw. zur Folge hat.

 

Und, damit es später nicht zu Programmfehlern, Endlosschleifen, Programmabstürzen oder Einfrieren des Programms kommt, werden die jeweiligen Klassen beim Programmstart gleich als Erstes, d.h. noch vor dem eigentlichen Hauptprogramm, gestartet und ausgeführt! Und zwar mit der konsequenten Folge, dass das im Anschluss ausgeführte Hauptprogramm sozusagen schon im Vorgriff weiß, was auf es zukommt bzw. welche „Sauereien“ oder welcher „Spaghetti-Kode“ in der einen oder anderen Klasse programmiert wurde.

 

Diesbezüglich könnte man auch sagen, dass die Klassen nebst integrierter Funktionen, die später z.B. vom (Haupt-) Programm aus aufgerufen und ausgeführt werden, vom Interpreter vorab auf Widersprüchlichkeiten und Ungereimtheiten untersucht und getestet werden. In Wirklichkeit ist das Ganze, d.h. das was der Interpreter macht, noch viel komplexer. -

 

In diesem Zusammenhang stellt sich dann auch gleich die Frage, ob sich Funktionen innerhalb einer Klasse auch automatisch, wie von Geisterhand gesteuert, starten.

 

Nehmen wir also die Funktion „einlesen_Vornamen(namens_Liste : list)“ aus dem Programm „micro_python-hallo_26.py“,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

fügen diese in die Klasse „verwalte_namensliste“ unseres neuen Programms „micro_python-hallo_2-4.py“ wie folgt ein

 

# Programm micro_python-hallo_2-4.py

 

# ------------------------------ Anfang der Klasse 'verwalte_Namensliste' ----------------------------

 

class verwalte_Namensliste:

   

    # ------------------------------ Funktion 'einlesen_Vornamen()' --------------------------------------

 

    # Nachfolgend wird die Funktion 'einlesen_Vornamen()' programmiert ...

 

    def einlesen_Vornamen(namens_Liste : list):

 

        print("")   # Leerzeile einfügen, dient der Programm-Kosmetik

 

        namens_Liste = namens_Liste + ["Dieter", "Karin"]

 

        n = 0   # Schleifenzähler

 

        while n < len(namens_Liste):

   

            print("Lfd. Nr. = ", n , "Einlesen des Variableninhalts = ", namens_Liste[n])

   

            n += 1

 

        print("")   # Leerzeile einfügen, dient der Programm-Kosmetik

 

        # Mittels 'return()'-Statement wird die eingelesene Namensliste an

        # das (Haupt-) Programm übergeben.

 

        return(namens_Liste)

 

    # --------------------------- Ende der Funktion 'einlesen_Vornamen()' ----------------------------

   

    print("Bin jetzt in der Klasse 'verwalte_Namensliste'!\n")

   

    namens_Liste = ["Max", "Peter", "Monika", "Petra"]

 

    print("Die Namensliste 'namens_Liste' ist vom Typ: ", type(namens_Liste))

 

    print("... und hat zum Inhalt: ", namens_Liste, "\n")

 

    pass

 

# ---------------------------- Ende der Klasse 'verwalte_Namensliste' --------------------------------

 

# ---------------------------------------------- Hauptprogramm  --------------------------------------------

 

# KEIN Programmkode …

 

 

und starten es, sodass nachfolgende Bildschirmanzeige erscheint:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Anhand der Bildschirmanzeige sieht man, dass die

 

·       Funktion „einlesen_Vornamen(namens_Liste : list)“

innerhalb der

 

·       Klasse „verwalte_namensliste“  

 

eben nicht automatisch ausgeführt wird! Und das ist gut so, schließlich wollen wir als Programmierer ja entsprechenden Einfluß auf das Programm nehmen und diese programmiert steuern. Natürlich auch durch Tastendruck oder Texteingabe seitens des Anwenders.

 

Da man die Namenliste erst auf dem Bildschirm anzeigen kann, wenn man sie zuvor mittels der Funktion „einlesen_Vornamen(namens_Liste : list)“ eingelesen hat, stellt sich die Frage, ob man diese vom Hauptprogramm aus oder von der Klasse „verwalte_namensliste“ aus einliest.

 

Das die Namensliste auf jeden Fall eingelesen werden muss, sollte man die Einlese-Aktion, d.h. den Aufruf bzw. das Starten der Funktion „einlesen_Vornamen(namens_Liste)“ in den Programmkode der Klasse „verwalte_namensliste“ wie folgt aufnehmen (siehe Programm „micro_python-hallo_2-5.py“):

 

# Programm micro_python-hallo_2-5.py

 

# ------------------------------ Anfang der Klasse 'verwalte_Namensliste' ----------------------------

 

class verwalte_Namensliste:

   

    # ------------------------------ Funktion 'einlesen_Vornamen()' --------------------------------------

 

    # Nachfolgend wird die Funktion 'einlesen_Vornamen()' programmiert ...

 

    def einlesen_Vornamen(namens_Liste : list):

 

       

 

        return(namens_Liste)

 

    # --------------------------- Ende der Funktion 'einlesen_Vornamen()' ----------------------------

   

    print("Bin jetzt in der Klasse 'verwalte_Namensliste'!\n")

    

    namens_Liste = ["Max", "Peter", "Monika", "Petra"]

 

    print("Die Namensliste 'namens_Liste' ist vom Typ: ", type(namens_Liste))

 

    print("... und hat zum Inhalt: ", namens_Liste, "\n")

 

    einlesen_Vornamen(namens_Liste)

 

    pass

 

# ---------------------------- Ende der Klasse 'verwalte_Namensliste' --------------------------------

 

# ---------------------------------------------- Hauptprogramm  --------------------------------------------

 

# KEIN Programmkode …

 

 

Schauen wir uns in diesem Zusammenhang noch die Bildschirmanzeige an, wenn man das Programm „micro_python-hallo_2-5.py“ startet:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Im obenstehenden Screenshot sieht man, dass die ursprüngliche Namensliste mit den vier Vornamen innerhalb der Klasse „verwalte_Namensliste“ initialisiert und mittels der Funktion „einlesen_Vornamen(namens_Liste : list)“ um zwei weitere Namen erweitert wurde:

 

    # ------------------------------ Funktion 'einlesen_Vornamen()' --------------------------------------

 

    # Nachfolgend wird die Funktion 'einlesen_Vornamen()' programmiert ...

 

    def einlesen_Vornamen(namens_Liste : list):

 

        print("")   # Leerzeile einfügen, dient der Programm-Kosmetik

 

        namens_Liste = namens_Liste + ["Dieter", "Karin"]

 

        

 

        return(namens_Liste)

 

    # --------------------------- Ende der Funktion 'einlesen_Vornamen()' ----------------------------

 

Nachfolgend wird die Funktion „einlesen_Vornamen(namens_Liste : list)“ nicht mehr innerhalb der Klasse „verwalte_Namensliste“ aufgerufen, sondern außerhalb der Klasse nämlich im Hauptprogramm!

 

Dazu muss man wissen, wie man eine Funktion, die sich innerhalb einer Klasse befindet, vom Hauptprogramm aus aufruft, nämlich durch 

 

·       den Namen der Klasse „verwalte_Namensliste“,

 

·       gefolgt von einem Punkt als Bindeglied

 

·       zum Namen der Funktion „einlesen_Vornamen(namens_Liste)“

 

Das Ganze sieht dann folgendermaßen aus:

 

·       verwalte_Namensliste.einlesen_Vornamen(vornamen_Liste)

 

Damit das dann auch wirklich funktioniert, brauchen wir noch die namens_Liste = ["Max", "Peter", "Monika", "Petra"], die sich aber im Programmblock der Klasse „verwalte_Namensliste“ befindet!

 

Dabei stellt sich sogleich die Frage, wie man vom Hauptprogramm aus an diese herankommt, nämlich durch die Angabe

 

·       des Klassenamens „verwalte_Namensliste“,

 

·       gefolgt von einem Punkt als Bindeglied

 

·       und den Namen „namens_Liste“

 

Das Ganze sieht dann folgendermaßen aus:

 

·       verwalte_Namensliste.namens_Liste

 

Die Namensliste „namens_Liste“ wiederum muss aber noch im Hauptprogramm an die Namensliste „vornamen_Liste“ wie folgt übergeben werden,

 

·       vornamen_Liste = verwalte_Namensliste.namens_Liste

 

damit auch alles wie gewünscht funktioniert:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Die Bildschirmanzeige des Programms „micro_python-hallo_2-6.py“ sieht dann folgendermaßen aus:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Das Paradoxe beim Programm „micro_python-hallo_2-6.py“ mit dem Aufruf der Namenanzeige vom Hauptprogramm aus ist, dass man sich mittels der Funktion „einlesen_Vornamen(namens_Liste)“ die Namensliste nur ausgeben/anzeigen lassen kann, wenn man Zugriff auf die Namensliste „namens_Liste“ selbst hat! Und die wiederum befindet sich zurzeit noch in der Funktion selbst! Da beißt sich also die Katze in den Schwanz, muss man wissen wie man sich vom Hauptprogramm aus erst mal die Namensliste aus der Funktion holen kann (siehe Bild oben):

 

·       vornamen_Liste = verwalte_Namensliste.namens_Liste

 

Obwohl beim Programm „micro_python-hallo_2-7.py“ der Aufruf der Namenanzeige jetzt vom Hauptprogramm aus ausgeführt wird, verhält es sich trotzdem noch immer so, dass die Klasse „verwalte_Namensliste“ nach wie vor beim Programmstart als Erstes ausgeführt wird. Zur Erinnerung an diese wichtige Erkenntnis, sozusagen in der Hoffnung auf dauerhaft tiefe Verinnerlichung, dient deshalb die Anzeige

 

 

    print("Bin jetzt NICHT mehr in der Funktion, ")

    print("sondern in der Klasse 'verwalte_Namensliste'!")

   

 

innerhalb der Klasse „verwalte_Namensliste“:

 

# Programm micro_python-hallo_2-7.py

 

# ------------------------------ Anfang der Klasse 'verwalte_Namensliste' ----------------------------

 

class verwalte_Namensliste:

   

    # ------------------------------ Funktion 'einlesen_Vornamen()' --------------------------------------

 

    # Nachfolgend wird die Funktion 'einlesen_Vornamen()' programmiert ...

 

    def einlesen_Vornamen(namens_Liste : list):

 

       

 

        return(namens_Liste)

 

    # --------------------------- Ende der Funktion 'einlesen_Vornamen()' ----------------------------

   

    print("Bin jetzt NICHT mehr in der Funktion, ")

    print("sondern in der Klasse 'verwalte_Namensliste'!")

   

    namens_Liste = ["Max", "Peter", "Monika", "Petra"]

 

    print("Die Namensliste 'namens_Liste' ist vom Typ: ", type(namens_Liste))

 

    print("... und hat zum Inhalt: ", namens_Liste, "\n")

 

    einlesen_Vornamen(namens_Liste)

 

    pass

 

# ---------------------------- Ende der Klasse 'verwalte_Namensliste' --------------------------------

 

# ---------------------------------------------- Hauptprogramm  --------------------------------------------

 

vornamen_Liste = ["Max", "Peter", "Monika", "Petra"]

 

verwalte_Namensliste.einlesen_Vornamen(vornamen_Liste)

 

 

Werfen wir also abschließend noch einen Blick auf die Bildschirmanzeige des Programms „micro_python-hallo_2-7.py“:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wir fahren fort und holen als nächstes

 

·       die Funktion „ausgabe_Vornamen()“

aus dem Programm „micro_python-hallo_26.py“ und fügen sie

 

·       der Klasse „verwalte_Namensliste“

im Programm micro_python-hallo_2-8.py

 

wieder hinzu, sodass wir nun die Namensliste nicht nur ins Programm einlesen, sondern auch wieder auslesen, indem wir diese auf dem Bildschirm anzeigen.

 

Dabei gilt es zu beachten, dass wir die Funktion „ausgabe_Vornamen()“

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

an das Ende, d.h. hinter der Funktion 'einlesen_Vornamen()' ins Programm micro_python-hallo_2-8.py“ einsetzen müssen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man oben im Programm micro_python-hallo_2-8.py“ sieht, wird die Funktion „ausgabe_Vornamen()“ vom Hauptprogramm aus aufgerufen. Demzufolge erfolgt die Programmsteuerung, d.h. das Aufrufen der jeweiligen Funktion in der funktionalen Reihenfolge, ausschließlich vom Hauptprogramm aus!

 

Schauen wir uns abschließend noch die Ausgabe/Anzeige des Programms auf den Bildschirm an:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Nachdem alles so gut geklappt hat, fehlt jetzt nur noch, dass wir die Funktion „einzelner_Vorname()“

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

wieder ins Programm „micro_python-hallo_2-9a.py“, d.h. in die Klasse „verwalte_Namensliste“ einbauen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Bei dieser Gelegenheit sollten wir uns noch einmal in Erinnerung rufen, wie die Funktion „einzelner_Vorname()“ im Einzelnen funktioniert:

 

Mit dem Statement

 

·       element_Nr_str = input("Welcher Vorname [0 ... "

                                    + str(len(hole_vornamenListe) - 1)

                                    + "] soll angezeigt werden ? ")

 

wird der Anwender gefragt, welcher der angezeigten Namen einzeln angezeigt werden soll, wobei dieser nicht den Namen selbst, sondern der Einfachheit halber den zugehörigen Index eintasten muss.

 

Bei der Programmierung dieses Statements gilt es zu beachten, dass der Index der Namensliste generell bei Null beginnt und bei der Anzahl der Namensfelder ‑ 1 endet: [ 0 … 5 ]. Nach erfolgter Eingabe wird diese dann der Variablen „element_Nr_str“ als String übergeben.

 

Anschließend wird in den Statements

 

·       n = int(element_Nr_str)

 

                  if n >= 0 and n <= len(hole_vornamenListe) - 1:

                      print("Lfd. Nr. = ", n ,

                                "Auslesen/Ausgabe des einzelnen Vornamens = ",                                                        hole_vornamenListe[n])

                      wiederhole_Eingabe = False

                  else:

                      print("Fehler bei der Eingabe-Abfrage!\n")

                      wiederhole_Eingabe = True

 

dann mittels der „if“-Abfrage geprüft, ob sich der eingetastete Index „n“ der Namensliste wirklich im Bereich [ 0 … 5 ] befindet oder nicht.

 

Befindet sich der eingetastete Index „n“ im Bereich [ 0 … 5 ], dann bekommt die boolesche Variable „wiederhole_Eingabe“ den Wert „False“ (= „falsch“), sodass die Eingabe später nicht wiederholt werden muss. Anderenfalls bekommt die boolesche Variable „wiederhole_Eingabe“ den Wert „True“ (= „richtig, zutreffend, ja“), sodass die Eingabe später wiederholt werden muss:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Die Funktion „einzelner_Vorname()“ befragt den Anwender also nur über die „input“-Abfrage, welcher Index aus dem Bereich [0 ... 5] zu den Vornamen angezeigt werden soll, nicht aber nach dem Vornamen selbst. Dies hat für den Anwender den Vorteil, dass er nicht den anzuzeigenden Vornamen selbst eintasten muss, sondern eben nur den zugehörigen Index.

 

Ferner wird in der Funktion „einzelner_Vorname()“ wider Erwarten nicht der gewünschte Vorname aus der erweiterten Namensliste „vornamen_Liste“ eingelesen, sondern eben nur der Index. Der Grund dafür ist der, dass der Anwender aus Versehen oder auch aus Absicht, um das Programm und die Index-Abfrage zu testen, einen Index außerhalb des Bereichs [0 ... 5] eintastet, sodass es normalerweise zu einer entsprechenden Fehlermeldung kommen würde. Mit der „if“-Abfrage innerhalb der Funktion wird aber genau überprüft, nämlich ob die Index-Abfrage richtig, d.h. aus dem Bereich [0 ... 5], eingetastet wurde. Ist dies der Fall, dann wir die boolesche Variable „wiederhole_Eingabe“ auf den Wert „False“ (= „falsch“) gesetzt und diese mittels des „return“-Befehls an den Funktionsaufruf

 

·       fehlerStatus = verwalte_Namensliste.einzelner_Vorname(vornamen_Liste)

 

im Hauptprogramm wieder zurückgegeben. Und im Hauptprogramm wird dann erst in der „while“-Schleife anhand des Variablenwertes „fehlerStatus == True entschieden, ob die Index- bzw. Namensabfrage wiederholt werden muss oder eben nicht.

 

Dabei gilt es zu beachten, dass die Namensabfrage zwar in der Funktion „einzelner_Vorname()“ erfolgt, nicht aber deren Wiederholung bei Falscheingabe, da es ansonsten zu einer Endlosschleife innerhalb der Funktion kommen könnte. Damit genau dies nicht passiert, wird die Wiederholung der Index-Abfrage für den jeweilig anzuzeigenden Namen außerhalb der Funktion, nämlich im Hauptprogramm vorgenommen (siehe Programm „micro_python-hallo_2-9a.py“):

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Bis auf den unteren roten Kasten mit der „while“-Schleife für die wiederholte Eingabe der Indexnummer für den anzuzeigenden Vornamen (siehe im Bild oben), sieht das Hauptprogramm bisher recht ordentlich und übersichtlich aus. Damit das so übersichtlich bleibt, lagern wir den unteren roten Kasten mit der „while“-Schleife einfach in die darüber befindliche Klasse „verwalte_Namensliste“ aus:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Das obenstehende Programm „micro_python-hallo_2-10.py“ funktioniert aber nur, wenn man die Namensliste „vornamen_Liste“ ebenfalls mit in die Klasse „verwalte_Namensliste“ übernimmt. Dort muss die Namensliste aber in „namens_Liste“ wie folgt umbenannt werden:

 

·       namens_Liste = list(["Sven", "Malte", "Lisa", "Avelina"])

 

Damit man die beiden Namenslisten bei der späteren Bildschirmanzeige besser unterscheiden und verstehen kann, was im Hauptprogramm passiert und was in der Klasse „verwalte_Namensliste“ wurden der Namensliste „namens_Liste“ in der Klasse andere Vornamen geben:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Hier noch einmal der maßgebliche Quellkode, engl. source code, zur obenstehenden Bildschirmanzeige (siehe Programm „micro_python-hallo_2-10.py“):

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Jetzt sind wir an einem Punkt angekommen, wo wir uns entscheiden müssen, ob wir die Namensliste im Hauptprogramm nutzen wollen oder in der Klasse „verwalte_Namensliste“ (siehe obenstehendes Bild).

 

Wegen der guten Übersichtlichkeit des Hauptprogramms und der Option, das Programm später noch um weitere Funktionen (in einer anderen Klasse) erweitern zu können, soll die Namensliste im Hauptprogramm verbleiben! Aber nur die Namensliste, sodass wir die Statements

 

·       vornamen_Liste = verwalte_Namensliste.einlesen_Vornamen(vornamen_Liste)

·       verwalte_Namensliste.ausgabe_Vornamen(vornamen_Liste)

·       fehlerStatus = einzelner_Vorname(namens_Liste)

 

später aus dem Hauptprogramm des Programms „micro_python-hallo_2-11.py“ auslagern.

 

Es ist zwar recht praktisch, wenn die Klasse „verwalte_Namensliste“ nebst Anzeige der Namensliste noch vor der Ausführung des Hauptprogramms gestartet wird, trotzdem ist aber besser, wenn sich die Ausgabe/Anzeige der Namensliste „vornamen_Liste“ erst auf spezielle Veranlassung hin starten lässt. Aus diesem Grund wird die Ausgabe/Anzeige der Namensliste in die Funktion „anzeigen_Namensliste“ aus dem Hauptprogramm ausgelagert (siehe Programm „micro_python-hallo_2-12.py“). Dabei bietet die Funktion „anzeigen_Namensliste“ gegenüber der gekapselten Klasse „verwalte_Namensliste“ den Vorteil, dass sie sich von überall her jederzeit einfacher aufrufen und ausführen lässt:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Es gibt zwei Sprichworte: a) „Wer Ordnung hält ist nur zu faul zu suchen.“ und b) „I d’ont like the chaos, but the chaos likes met!“, d.h. „Ich missbillige das Chaos, aber das Chaos mag mich!“ Man könnte auch sagen: „Vorsicht ist die Mutter der Porzellankiste!“

 

Sei es wie es ist, wir halten Ordnung und verlagern die Funktion „anzeigen_Namensliste()“ in die Klasse „verwalte_Namensliste“, da wir später noch ein kleines Auswahlmenü programmieren werden, mittels dem man gezielt bestimmte Funktionen auswählen und aufrufen kann. Und dazu ist es hilfreich, wenn diese alle an einem Ort, d.h. in einer Klasse stehen.

 

Nachträgliches Korrigieren bzw. Ändern eines Namens

 

Als Nächstes haben wir uns eine kleine Abwechselung verdient, indem wir das bisherige Namens-Programm erweitern. Und zwar um die Funktion der nachträglichen Namensänderung. Dazu müssen wir uns mittels der Funktion „einzelner_Vorname(vornamen_Liste)“ nur den gewünschten Vornamen anzeigen lassen und diesen mittels eines weiteren „input“-Befehls namentlich abändern:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Beim Programm „micro_python-hallo_2-13.py“ und der neu hinzugefügten Funktion „korrigieren_Vorname()“ fällt auf, dass wir diese aus Gründen des logischen Sinnzusammenhangs vor die Funktion „anzeigen_Namensliste()“ positioniert haben, damit sichergestellt ist, dass die nachfolgende Funktion „anzeigen_Namensliste()“ später auch tatsächlich auf die zuvor geänderte Namensliste zugreifen kann.

 

Im Zusammenhang mit der Funktion „korrigieren_Vorname()“ entsteht nun vielleicht der Wunsch, dass man einen weiteren Datensatz (= Vornamen) der bisherigen Namensliste hinzufügen will. Wie man sich denken kann, ist das nicht weiter schwierig, muss man doch nur den hinzuzufügenden Vornamen eingeben und an die bestehende Datenbank (= Liste mit den Vornamen) wie folgt anfügen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Damit sich das Programm „micro_python-hallo_2-14.py“ und die neu hinzugefügte Funktion „anhaengen_Vorname()“ vom Hauptprogramm aus aufrufen lässt, müssen wir in diesem noch das Statement

 

1.    verwalte_Namensliste.anhaengen_Vorname(vornamen_Liste)

 

hinzufügen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man im obenstehenden Sourcecode sieht, wurde der Funktionsaufruf „korrigieren_Vorname(vornamen_Liste)“ im Programm „micro_python-hallo_2-14.py“ vorübergehend „auskommentiert“, d.h. deaktiviert, damit das Hauptprogramm, indem ja ansonsten stets alle Funktionen der Reihe aufgerufen werden, übersichtlich bleibt.

 

Werfen wir abschließend noch einen Blick auf die Anzeige/Ausgabe des Bildschirms, um zu sehen, dass auch alles tatsächlich wie gewünscht, d.h. programmiert, funktioniert:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Nachfolgend geht es im Programm „micro_python-hallo_2-15.py“ darum, dass wir an einer beliebigen Stelle der Namensliste „vornamen_Liste“ einen weiteren Datensatz, d.h. einen neuen Vornamen in die bestehende Namensliste einfügen, sodass diese sich um einen Datensatz entsprechend vergrößert. Diesbezüglich wenden wir einen kleinen Trick an, der aber ganz einfach ist. Und zwar arbeiten wir mit drei Datenbanken (= Namenslisten) als da sind

 

a)       die alte Namensliste „vornamen_Liste“,

 

b)              die temporäre Namensliste „temp_vornamenListe“

mit der wir konkret arbeiten und

 

c)              die neue Namensliste „neue_vornamenListe“,

die sich abschließend aus der alten plus der temporären Namensliste

zusammensetzt.

 

Bei der Programmierung des Programm „micro_python-hallo_2-15.py“ benutzen wir zunächst die alte Namensliste „vornamen_Liste“ und fragen mittels des „input“-Befehls ab, an welcher Position der Datenbank der neue Name eingefügt werden soll:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man im obenstehenden Screenshot (= Schnappschuss vom Bildschirm) sieht, wird der Inhalt des ausgewählten, indexierten Datensatzes (= Vorname) zunächst nur angezeigt (siehe grüner Kasten), damit der Anwender weiß, an welcher Position er anschließend einen neuen, d.h. weiteren/zusätzlichen Namen eintasten/anlegen kann:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man im obenstehenden Bild sieht, wird der aktuell ausgewählte Datensatz mit dem Index = 3 und dem Namen „Petra“ nicht einfach von der neuen Namenseingabe „Heinz“ überschrieben, sondern an letzter Position der Datenbank angefügt, sodass die „Petra“ eben nicht überschrieben, d.h. gelöscht wird, sondern erhalten bleibt. An letzter Stelle der Datenbank bedeutet dabei aber nicht, dass es sich bei der Petra um das Letzte handelt, sondern um die Letzte am neuen Ende der erweiterten Datenbank ;-)

 

Programmiertechnisch und logisch bedeutet dies, dass wir die alte Datenbank bis zur Index-Position [ 0 ... 2 ] (= 3 Datensätze) verwenden, d.h. unverändert beibehalten,

 

          temp_vornamenListe = list()

          temp_vornamenListe += hole_vornamenListe

 

dann beim 4. Datensatz mit dem Index = 3 den neuen Vornamen „Heinz“ hinzufügen,

 

          temp_vornamenListe[n] = str(hinzufuegen_Vorname)

 

indem der Dateninhalt „Petra“ mit „Heinz“ überschrieben wird.

 

Anschließend wird die neue Datenbank „neue_vornamenListe“ generiert und dieser der Inhalt der alten Datenbank „hole_vornamenListe“ plus neuer Vornamen „Heinz“ übergeben (= 4 Datensätze mit dem Index [ 0 … 3 ]):

 

          neue_vornamenListe = list()

          neue_vornamenListe += temp_vornamenListe

 

Abschließend wird der übrig gebliebene Datenbankinhalt „Petra“ aus der alten Datenbank „hole_vornamenListe“ geholt und der neuen wie folgt hinzugefügt (= 5 Datensätze mit dem Index [ 0 … 3 ]):

 

          neue_vornamenListe = neue_vornamenListe + [hole_vornamenListe[PosNr]]

 

Wie man im Programm „micro_python-hallo_2-15.py“ anhand des Sourcecodes sieht, ist die Programmierung, d.h. der Umgang mit drei Datenbanken (neue Datenbank = alte Datenbank bis Indexpos. 2 + Name an der Indexpos. 3 + Rest der alten Datenbank an der neuen Indexpos. 5) gar nicht so schwer:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Das Bemerkenswerte bei der obenstehenden Programmierung ist der Umstand, dass wir ganz ohne „for“- oder „while“-Schleifen sowie der Umschichtung von Datensätzen in den Datenbanken ausgekommen sind.

 

Damit das Hauptprogramm mit seinen vielen Funktionen noch übersichtlich bleibt und sich dieses auch komfortabel bedienen lässt, programmieren im Programm „micro_python-hallo_2-16.py“ noch eine entsprechende Menüauswahl mit der sich alle Funktionen je nach Bedarf einzeln aufrufen lassen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Werfen wir bei dieser Gelegenheit noch einen Blick auf die Menüauswahl, so wie sie sich auf dem Desktop des Windows-PCs darstellt, wenn man das Programm „micro_python-hallo_2-16.py“ in der „Thonny“-Entwicklungsumgebung startet:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wenn man das Programm startet und mittels der Menüauswahl mehr und mehr Funktionen ausprobiert, dann stellt man unschwer fest, dass die Menüauswahl im Fenster „Thonny Shell“ der „Thonny“-Entwicklungsumgebung nach oben aus dem Blickfeld bzw. dem Fensterausschnitt wandert, sodass man notgedrungen in der Shell nach oben scrollen muss, um wieder die Menüauswahl zu sehen und nachzuschlagen.

 

Wenn man dann mittels der Menüauswahl (6) wieder das Programm „micro_python-hallo_2-16.py“ verlassen will, dann muss man in der Shell wieder ganz nach unten scrollen bis die Eingabezeile „Treffen Sie jetzt Ihre Menüauswahl:“ erscheint, um dann die „6“ zum Verlassen des Programms eintasten zu können. Das ist natürlich alles andere als anwenderfreundlich und ergonomisch.

 

Aus diesem Grund werden wir als Nächstes die Menüauswahl (siehe im Bild oben) in eine eigene Funktion einer anderen Klasse auslagern und dabei den Menüaufruf selbst jederzeit per Tasteneingabe „m“ wiederholt zur Anzeige auf den Bildschirm bringen. -

 

Wenn man das bisherige Menü und dessen Menüauswahlen, wie zuvor beschrieben, komfortabeler und ergonomischer gestalten, d.h. programmieren will, dann muss man dieses so programmieren, dass sich das Menü sozusagen auf Knopfdruck jederzeit erneut und beliebig oft aufrufen bzw. starten lässt.

 

Wenn sich aber bestimmte Dinge immer wiederholen, wiederholen lassen, wiederholen lassen sollen oder müssen, dann braucht es im einfachsten Falle eine „for“- oder „while“-Schleife. Wenn aber das Ganze komplexer ist, dann muss man eine Funktion programmieren, die sich ähnlich einer „Endlos“-Schleife jederzeit und beliebig oft aufrufen und wiederholen lässt.

 

Schauen wir uns also den betreffenden Quellkode der Menüsteuerung noch einmal an, bevor wir uns klar darüber werden, ob sich der gesamte Quellkode oder nur Teile davon in eine separate Funktion auslagern lassen oder nicht:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Diesbezüglich stellt sich die Frage, wie eine Menüsteuerung prinzipiell funktioniert und aus welchen Teilen sie sich zusammensetzt, als da wären:

 

1. Liste „auswaehlen_Menue“ mit auswählbaren Menüfunktionen,

 

2.    Anzeige „print()“ der auswählbaren Menüfunktionen,

 

3.    Abfrage „while“ mit Prüfung, welche Menüfunktion ausgewählt wurde,

 

4.    Namensliste „vornamen_Liste“, die mittels ausgewählter Menüfunktion bearbeitet werden soll.

 

Bei der Namensliste „vornamen_Liste“, die später einmal in einer Datei gespeichert und von dort aus auch wieder eingelesen werden soll, stellte sich deshalb die Frage, wo man diese zweckmäßiger Weise im Programm bearbeitet: a) im Hauptprogramm oder b) innerhalb der Klasse „verwalte_Namensliste“.

 

Wenn man die Namensliste „vornamen_Liste“ innerhalb der Klasse „verwalte_Namensliste“ verwaltet und bearbeitet, dann hat dies den Vorteil, dass alle in der Klasse enthaltenen Funktionen, quasi wie bei einer globalen Variablen, problemlos auf diese zugreifen können.

 

Aber wo es Sonne gibt, gibt es auch Schatten, nämlich die Sorge, dass, wenn man die Namensliste innerhalb der Klasse bearbeitet, diese früher oder später unbeabsichtigt „zerschossen“ wird, indem man mit dieser arbeitet und dabei diese dann auch verändert, indem man z.B. Namen aus der Liste löscht oder welche hinzufügt, sodass die ursprüngliche Original-Namensliste für die spätere, nachträgliche Bearbeitung nicht mehr in ihrem Ursprung zur Verfügung steht! Aus diesem Grund empfiehlt es sich unbedingt, stets nur mit einer Kopie der Namensdatei zu arbeiten und eben nicht dem Original!

 

Damit sich die (Original-) Namensliste „vornamen_Liste“ später im Quellkode sofort finden lässt und nicht umständlich innerhalb der Klasse und den Funktionen gesucht werden muss, wurde diese ins Hauptprogramm aufgenommen. Unter anderem auch aus dem Grund, weil die Namensliste später noch bearbeitet, d.h. in einer Datei gespeichert werden soll. Dazu braucht es dann weitere Funktionen, wie z.B. das Laden, Lesen, Schreiben oder Erweitern einer Datei, die wiederum alle in einer gemeinsamen Klasse „Dateioperationen“ zusammengefasst werden!

 

Kurz und knapp, das Arbeiten mit Klassen und den darin enthaltenen Funktionen macht Sinn, lassen sich doch programmiertechnisch und thematisch zusammenhängende Sachverhalte in Form von Funktionen innerhalb einer Klasse zusammenfassen und deren Variablen nebst (Variablen-) Inhalten auf den lokalen Zugriff innerhalb einer Funktion beschränken. Dabei erfolgt der Zugriff auf Daten von Variablen innerhalb einer Funktion hauptsächlich durch den Funktionskopf und/oder über das Statement „return“ bzw. „return()“ für die entsprechende Rückgabe an die Klasse oder das Hauptprogramm. Je nachdem von wo aus die Funktion aufgerufen wurde.

 

Innerhalb einer Klasse können Funktionen mit anderen Funktionen miteinander und untereinander kommunizieren und Daten in Form von Variableninhalten austauschen, indem sie dazu ein- und dieselbe Variable verwenden, die dabei aber wiederum in der gemeinsamen Klasse deklariert, initialisiert oder einfach nur benutzt werden muss.

 

Innerhalb einer Klasse lassen sich Funktionen der eigenen Klasse durch Aufruf des Funktionsnamens nebst eventueller Übergabe von Parametern im Funktionskopf starten und ausführen:

 

·       Statement „einlesen_Vornamen(vornamen_Liste)

 

Dabei lassen sich im Funktionskopf auch neue Variable deklarieren, die wiederum innerhalb der gesamten Funktion gültig sind!

 

Wenn man eine Funktion von außerhalb der Klasse, z.B. vom Hauptprogramm aus, aufrufen will, dann muss man dem Funktionsnamen den Klassennamen, in dem sich Funktion befindet, wie folgt voranstellen:

 

·       Statement „verwalte_Namensliste.einlesen_Vornamen(vornamen_Liste)

 

Ähnlich verhält es sich, wenn man Variablen und Variableninhalte einer Klasse von außerhalb der Klasse, wie z.B. aus dem Hauptprogramm heraus, ansprechen und nutzen will. Diesbezüglich lassen sich Variablen und deren Variableninhalte einer Klasse von außerhalb der Klasse durch Aufruf des Klassennamens gefolgt vom Variablennamen wie folgt verwenden:

 

·       Statement „verwalte_Namensliste.vornamen_Liste

 

Beim Programm „micro_python-hallo_2-16.py“ nutzen wir alle die soeben besprochenen Möglichkeiten wie z.B. das Aufrufen von Funktionen aus dem Hauptprogramm heraus (siehe Menüverwaltung) und das Übertragen der Variableninhalte „vornamen_Liste“ an die jeweiligen Funktionen (siehe Menüauswahl). Und trotzdem hat das Programm „micro_python-hallo_2-16.py“ noch einen erheblichen „Schönheitsfehler“, der das ordnungsgemäße Funktionieren des Programms unmöglich macht.

 

Zwar ist es uns gelungen, die Namensliste „vornamen_Liste“ vom Hauptprogramm aus im Funktionskopf an verschiedene Funktionen (siehe Menüauswahl) zu übergeben, d.h. zu transferieren. Wider Erwarten ist es uns aber bisher noch nicht gelungen, die um den Vornamen „Petrus“ erweiterte Namensliste „vornamen_Liste“ wieder an das Hauptprogramm zurückzugeben:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

 

In Funktionen mittels „self“-Statement auf Klassenvariablen zugreifen

 

Für das im obenstehenden Bild beschriebene Manko, dass sich die erweiterte Namensliste „vornamen_Liste“ wider Erwarten bisher nicht wieder an das Hauptprogramm zurückgeben lässt, gibt es aber einen einfachen Grund! Nämlich den, dass wir bisher noch nicht wirklich wissen, wie man Variableninhalte aus dem Hauptprogramm an die Klasse „verwalte_Namensliste“ und somit auch an alle in der Klasse enthaltenen Funktionen transferieren kann!

 

Mit dem Programm „micro_python-hallo_2-17.py“ aber ist das beschriebene Manko endgültig behoben! Probieren Sie es aus, und finden Sie heraus, wie der Nachteil, dass sich die namentlich erweiterte Namensliste „vornamen_Liste“ wider Erwarten bisher nicht wieder ans Hauptprogramm oder an andere Funktionen der Klasse „verwalte_Namensliste“ zurückgeben ließ, behoben wurde!

 

Nachfolgend geht es darum, den Zugriff auf die (Klassen-) Variable „klassen_Var“ innerhalb der Klasse „verwalte_Namensliste“ als auch auf die (Funktions-) Variable „funktions_Var“ innerhalb der Funktion „einlesen_Vornamen()“ zu bewerkstelligen (siehe Programm „micro_python-hallo_2-18.py“):

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man anhand des Programm „micro_python-hallo_2-19.py“ sieht,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

kommt man vom Hauptprogramm aus nur an den Variableninhalt der Variablen „funktions_Var“ mittels des Statements „return(funktions_Var)“. Dies gelingt aber nur, wenn man vom Hauptprogramm aus die Funktion „einlesen_Vornamen()“ aufruft!

 

Wie man anhand des Programm „micro_python-hallo_2-20.py“ sieht,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

lässt sich die Funktion „einlesen_Vornamen()“ auch aus der Klasse „verwalte_Namensliste“ heraus aufrufen und ausführen. Auf die Variable „export_funktions_Var“ lässt sich dann vom Hauptprogramm aus mittels des Statements „verwalte_Namensliste.export_funktions_Var“ zugreifen. –

 

Wie man anhand des Programms „micro_python-hallo_2-21.py“ sieht,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

lässt sich der Variableninhalt „Ich bin die Funktionsvariable 'funktions_Var'“ der Variablen „funktions_Var“ in der Funktion „einlesen_Vornamen(self)“ auch ganz ohne Statement „return(funktions_Var) und auch ohne das Statement export_funktions_Var = einlesen_Vornamen() (= Funktionsaufruf „einlesen Vorname()“ mit anschließender Übertragung des „return“-Variableninhalts der Variablen „funktions_Var“ an die Variable „export_funktions_Var“) bewerkstelligen.

 

Dabei ist das Besondere am Programm „micro_python-hallo_2-21.py“, dass das

 

·       Statement „verwalte_Namensliste.einlesen_Vornamen(verwalte_Namensliste)

 

im Hauptprogramm die Funktion „einlesen_Vornamen(self)“ aufruft und mittels der Variablen „self“ den Klassennamen „verwalte_Namensliste“ mit auf den Weg gibt, der dann über den Funktionskopf eingelesen und an die Funktion selbst übergeben, d.h. verfügbar gemacht wird!

 

Demzufolge ist die Variablen „self“ innerhalb der Funktion „einlesen_Vornamen(self)“ keine Unbekannte mehr und lässt sich demzufolge im

 

·       Statement self.export_funktions_Var = funktions_Var“

 

entsprechend nutzen, um den Variableninhalt der lokalen (Funktions-) Variablen „funktions_Var“ an die (Klassen-) Variable „self.export_funktions_Var zu übergeben, wobei der vorherige Variableninhalt „Ich bin die NEUE Export-Funktionsvariable!“ überschrieben wird!

 

Die Klassenvariable „export_funktions_Var der Klasse „verwalte_Namensliste“ lässt sich also nur deshalb innerhalb der Funktion „einlesen_Vornamen(self)“ nutzen, weil wir den Klassennamen „verwalte_Namensliste“ über den Funktionskopf mittels der Variablen „self“ innerhalb der Funktion verfügbar gemacht haben, sodass wir mit der zusammengesetzen Variablen „self.export_funktions_Var innerhalb der Funktion arbeiten können! –

 

Last but not least haben wir aus der Funktion „einlesen_Vornamen(self)“ heraus eine neue Klassenvariable „export_funktions_Var erzeugt, die zur Klasse „verwalte_Namensliste“ gehört und sich nun auch vom Hauptprogramm aus aufrufen, auslesen und inhaltlich verändern lässt!

 

 

In diesem Zusammenhang könnte man nun auf die Idee kommen und sagen, dass man innerhalb der Funktion „einlesen_Vornamen(self)“ anstelle des

 

·       Statements self.export_funktions_Var = funktions_Var“

 

gleich das

 

·       Statement verwalte_Namensliste.export_funktions_Var = funktions_Var“

 

verwendet, um sich auf diese Weise den ganzen „self“-Kladderadatsch zu ersparen. Aber genau das geht so leider nicht, weil der Klassennamen „verwalte_Namensliste“ der Funktion „einlesen_Vornamen()“ nicht bekannt ist, sondern erst durch den Funktionsaufruf „einlesen_Vornamen(self)“ noch bekannt gemacht werden muss. Mit anderen Worten: die Funktion „einlesen_Vornamen()“ weiß von sich aus gar nicht, dass es eine Klasse „verwalte_Namensliste“ gibt; deshalb der „Umweg“ über „self“ im Funktionsaufruf „einlesen_Vornamen(self)“. -

 

Jetzt wo im Programm „micro_python-hallo_2-21.py“ die neue Klassenvariable „export_funktions_Var“ in der Funktion „einlesen_Vornamen(self)“ mittels des

 

·       Statement self.export_funktions_Var = funktions_Var“

 

initialisiert wurde, kann man die vorausgegangene Initialisierung innerhalb der Klassen „verwalte_Namensliste“ mittels des

 

·       Statements „export_funktions_Var = ‚Ich bin die NEUE Export-Funktionsvariable!’“

 

verzichten und diese im Programm „micro_python-hallo_2-22.py“ mittels „#“ auskommentieren, d.h. deaktivieren:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Mit dem Programm „micro_python-hallo_2-23.py

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

lässt sich zeigen, dass sich die neue Klassenvariable „export_funktions_Var“ tatsächlich auch in der Funktion „einlesen_Vornamen(self)“ nutzen und deren Variableninhalt „Das HAUPTPROGRAMM(!) initialisiert NEUE Klassenvariable!“ mittels des Statements „return(self.export_funktions_Var)“ wieder an das Hauptprogramm zurückgeben lässt:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Jetzt können wir das neu erworbene Wissen über das Initiieren von globalen Klassen- oder Funktionsvariablen, die sich quer über alle Funktionen und Klassen nutzen lassen, konkret anwenden.

 

Zu diesem Zweck greifen wir wieder das Programm „micro_python-hallo_2-17.py“ auf, verbessern es im ersten Schritt bei der Funktion „starte_Menueauswahl()“, indem wir die Funktion auf das Anwenden der „self“-Variable wie folgt umstellen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Leider verhält es sich bei dem im Bild obenstehenden Quellkode der Funktion „starte_Menueauswahl(self)“ so, dass sich das „self“-Statement wider Erwarten nicht auf die Tabelle „auswaehlen_Menu = ( … )“ anwenden lässt, da das Statement „exec(auswaehlen_Menue[lfdNr_Menue])“ das „self“-Statement nicht auflösen kann.

 

Wie man aber anhand des

 

·       Statements self.einlesen_Vornamen(self.vornamen_Liste)

 

sieht, lassen sich die Menüfunktionen trotzdem jederzeit auf konventionelle Weise mittels „self“-Statement aufrufen und ausführen.

 

Was noch erwähnt werden muss, ist, dass die (Menü-) Funktion „starte_Menueauswahl(self) zwischenzeitlich in die eigene Klasse „verwalte_Menueauswahl“ aufgenommen wurde, sodass Menüorganisation und Verwaltung funktionell von der Klasse „verwalte_Namensliste“ strikt getrennt sind.

 

Achtung: Beim Programm „micro_python-hallo_2-24.py“ wurde das „self“-Statement jetzt der Klasse „verwalte_Menueauswahl“ zugewiesen! -

 

 

Datentransfer mittels „self“-Statement von Klasse 1 zu Klasse 2

 

Um den Umgang und die Handhabung mit dem „self“-Statement noch besser zu verstehen und anwenden zu können, schauen wir uns das Programm „micro_python-hallo_2-25.py“ genauer an:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie aber funktioniert das obenstehende Programm „micro_python-hallo_2-25.py“?

 

In der Funktion „Funktion_1“ wird die Textstringvariable „TextStrVar_1“ initialisiert und diese über das Statement „self“ der Klasse „Klasse_1“ zugewiesen. Damit das dann auch funktioniert, muss im Hauptprogramm der Variablen „self“ der Klassenname „Klasse_1“ zugewiesen werden! Auf diese Weise wird die Funktion „Funktion_1“ zum Sender, d.h. zur Quelle, engl. source“, während gleich die Funktion „Funktion_2“ zum Empfänger, d.h. zur Senke, engl. sink“ wird.

 

In der Funktion „Funktion_2“ soll die Textstringvariable „TextStrVar_1“ den Variableninhalt der Klassenvariablen „self.TextStrVar_1 der Klasse „Klasse_1“ entgegennehmen. Damit das auch funktioniert, muss der lokalen(!) Textstringvariable „TextStrVar_1“ der Funktion „Funktion_2“(!) noch die Variable „self“ vorangestellt werden, damit diese ebenfalls, wie die bereits bestehende, globale(!) Klassenvariablen „self.TextStrVar_1 der Funktion „Funktion_1“ (= Sender), zur globalen(!) Klassenvariablen „self.TextStrVar_1 der Funktion „Funktion_2“(!) (= Empfänger) wird und auf den Variableninhalt derselben zugreifen kann. Anschließend lässt sich dann der Variableninhalt der globalen(!) Klassenvariablen „self.TextStrVar_1 der Klasse „Klasse_1“ in der Funktion „Funktion_2“(!) mittels des „print“-Statements anzeigen.

 

Wichtig dabei ist, dass man sich darüber klar wird, dass wir es mit zwei globalen(!) Variablen gleichen Variablennamens „self.TextStrVar_1 zu tun haben!

 

Dabei wird die eine Klassenvariable „self.TextStrVar_1 (= Sender) in der Funktion „Funktion_1“ der Klasse „Klasse_1“ initialisiert und die andere Klassenvariable „self.TextStrVar_1 (= Empfänger) in der Funktion „Funktion_2“ der Klasse „Klasse_2“ deklariert.

 

 

Die Klassenvariable „self.TextStrVar_1 (= Empfänger) in der Funktion „Funktion_2“ der Klasse „Klasse_2“ kann aber erst dann den Variableninhalt der anderen Klassenvariable „self.TextStrVar_1 (= Sender) in der Funktion „Funktion_1“ der Klasse „Klasse_1“ entgegennehmen und mittels des „print“-Statements anzeigen, wenn im Hauptprogramm das Statement „Klasse_2.Funktion_2(Klasse_1)“ ausgeführt wird:

 

Statement „Klasse_1.Funktion_1(Klasse_1)“ Statement „Klasse_2.Funktion_2(Klasse_1)“

 

Da man aber zu Zwecken des besseren Verständnisses und zur Vermeidung von Verwechselungsgefahren  - man sieht den beiden Briefkästen gleichen Namens nicht an, dass der eine Bewohner Müller im Ergeschoß und die andere Bewohnerin Müller im 5. Stock wohnt -  namensgleiche Variablennamen tunlichst vermeiden soll, verwenden wir im Programm „micro_python-hallo_2-26.pyunterschiedliche Variablennamen mit dem Vorteil, dass sich das Programm dabei auch noch besser verstehen lässt:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Jetzt drängt sich gleich noch die Frage auf, ob sich der „self“-Datentransfer auch in die umgekehrte Richtung, d.h. rückwärts vornehmen lässt (sieh Programm „micro_python-hallo_2-27.py“):

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man anhand der roten Richtungspfeile im obenstehenden Bild sieht, lässt sich der Datentransfer zwischen den Funktionen auch rückwärts, d.h. von unten nach oben vornehmen. Ungewohnt beim Lesen des Quellkodes ist dabei, dass man diesen jetzt auch rückwärts von unten nach oben lesen muss, um das Ganze auch zu verstehen.

 

Schließlich geht es beim Datentransfer darum, dass wir diesen von Funktion 2 zur Klasse 2 und dann weiter nach oben zur Klasse 1 und von dort aus zur Funktion 1 durchführen, wobei die Lesart des Quellkodes von unten nach oben ungewohnt erscheint (siehe Programm „micro_python-hallo_2-27.py“).

 

Damit sich keine Fehler einschleichen, sollten wir die Lesart des Quellkodes von oben nach unten beibehalten und zu diesem Zweck die beiden Klassen nebst Funktionen wie folgt vertauschen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wenn wir bei der Programmierung des Quellkodes und der gewohnten Lesart von oben nach unten bleiben, dann fällt auf, das der Datenaustausch zwischen der Variablen „self.SendeVar“ und „self.EmpfangsVar“ stets in der unteren Klasse bzw. Funktion erfolgt, was ja auch logisch ist (siehe Programm „micro_python-hallo_2-28.py“). –

 

Wie man anhand des Quellkodes im obenstehenden Bild sieht, bewirkt das Statement „Klasse_2.Funktion_2(Klasse_1)“ im Hauptprogramm, dass die Funktion „Funktion _2“ zusammen mit dem Parameter „Klasse_1“ aufgerufen wird und dabei der Parameter „Klasse_1“ an die Stringvariable „self“ im Funktionskopf übergeben wird. Da wir aber im Programm „micro_python-hallo_2-29.py“ in der Funktion „Funktion _2“ das

 

·       Statement self.SendeVar = ‚Ich bin Text aus der Funktion 2!’“ auf das

 

·       Statement Klasse_1.SendeVar = ‚Ich bin Text aus der Funktion 2!’“

 

abgeändert haben, machen wir vom „self“-Parameter im Funktionskopf keinen Gebrauch. Und siehe da, das Programm funktioniert trotzdem in der gewohnten Weise,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

gibt keine Abweichung beim Ergebnis bzw. der Anzeige auf dem Bildschirm. -

 

Da wir in der Funktion „Funktion _2“ von dem „self“-Parameter keinen Gebrauch mehr machen, können wir dieses auch weglassen, sodass sich auch der Funktionsaufruf der Funktion „Funktion _2“ aus dem Hauptprogramm heraus entsprechend vereinfacht (siehe Programm „micro_python-hallo_2-30.py“):

 

·       Statement „Klasse_2.Funktion_2()

 

In der Funktion „Funktion _1(self)“ der Klasse „Klasse_1“ benutzen wir zwar noch den „self“-Parameter im

 

·       Statement „print("Inhalt der Variablen 'SendeVar' = ", self.EmpfangsVar, "\n")“,

 

bräuchten das aber eigentlich nicht mehr, da die Klassenvariable self.EmpfangsVar“ gleichbedeutend ist mit der Klassenvariablen Klasse_1.EmpfangsVar“:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Im Programm „micro_python-hallo_2-31.pyverzichten wir erstmals auf alle „self“-Parameter,

 

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

ohne dass sich irgendeine Fehlfunktion, ein Fehler oder fehlerhafte Anzeige einstellen würden! –

 

Wenn wir z.B. den Variableninhalt einer lokalen Variablen oder den Textstring „Ich bin Text aus der Funktion 2!“ innerhalb der Funktion „Funktion_2()“ nach außen, d.h. im Hauptprogramm oder in der Funktion „Funktion_1()“, verfügbar machen wollen, dann musste bisher stets ein Aufruf der Funktion über die zugehörige Klasse im Hauptprogramm veranlasst werden (siehe Quellkode im obenstehenden Bild).

 

Dabei ist der Grund dafür der, dass Funktionen innerhalb einer Klasse ziemlich stringent gekapselt sind. Und, wenn man auf Variableninhalte einer Funktion zugreifen will und dieser dabei stets direkt oder indirekt über das Hauptprogramm veranlasst werden muss, dann ist das Hauptprogramm stets involviert, ist dieses quasi auf den Variablenzugriff einer lokalen Variablen einer Funktion informiert!

 

Wie wir aber gleich sehen werden, geht es auch ohne den Umweg über das Hauptprogramm, lassen sich Variableninhalte auch direkt von Funktion zu Funktion übertragen und zugänglich machen! Zu diesem Zweck müssen wir uns an eine Eigenart von Klassen erinnern: Klassen mit oder ohne Funktion, werden beim Programmstart noch vor dem Abarbeiten von Quellkode des Hauptprogramms aufgerufen und ausgeführt!

 

Macht man sich diese Eigenart von Klassen zunutze, dann kann man aus der Klasse heraus auch die darin befindliche Funktion starten und den Inhalt einer lokalen Funktionsvariablen mittels „return“-Statement an die jeweilige Klasse übertragen, sodass dieser mittels der Klassenvariablen von überall her verfügbar ist. Auch und gerade durch eine weitere Funktion einer weiteren Klasse (siehe Programm „micro_python-hallo_2-32.py“):

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Selbstverständlich lässt sich der im Bild obenstehende Sourcecode auch noch kürzer, d.h. kompakter programmieren (siehe Programm „micro_python-hallo_2-33.py“):

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man im obenstehenden Quellkode sieht, kann man sich in der Funktion „Funktion_2()“ den Textstring „Ich bin Text aus der Funktion 2!“ mittels des „return“-Statements zurückliefern lassen. Und zwar an die Klassenvariable „SendeVar“ der Klasse „Klasse_2“. Zu diesem Zweck muss man aber im

 

·       Statement „SendeVar = Funktion_2()“

 

zunächst die Funktion „Funktion_2()“ aufrufen und den mittels „return“-Statement zurück gelieferten Textstring der Klassenvariablen „SendeVar“ zu weisen (siehe roter Kasten im obenstehenden Quellkode bei der „Funktion_2“)!

 

Dabei gilt es zu beachten, dass es sich bei Variablen, die innerhalb einer Klasse deklariert bzw. initialisiert wurden, stets um Klassenvariablen handelt, die sich z.B. auch innerhalb einer Funktion z.B. als Klassenvariable „Klasse_2.SendeVar“ ansprechen und benutzen lassen! Das gilt übrigens auch für Variablen vom Typ „self“.

 

Wenn man das weiß, dann kann man, wie im Programm „micro_python-hallo_2-34.py“ gezeigt, auch ganz auf die beiden Funktionen „Funktion_2“ und „Funktion_1“ verzichten:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

 

Autostart von Klassen und Steuerung von Klassen durch Funktionen

 

So, jetzt sind wir wieder da angekommen, von wo aus wir im Prinzip gestartet sind. Allerdings mit einem Unterschied, dass wir wieder eine ganze Menge gelernt haben. Aber bekanntlich lernt man ja nie aus, gibt es immer wieder etwas Neues zu entdecken und auszuprobieren.

 

Zurück zu den Wurzeln und zwar zum Programm „micro_python-hallo_2-35.py bei dem wir es mit den beiden Klassen „Klasse_1“ und „Klasse_2“ zu tun haben, wobei beide Klassen mit Programmcode zwecks Anzeige von Variableninhalten ausgestattet sind. Das Interessante am Programm „micro_python-hallo_2-35.py“ ist dabei,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

dass mit dem Programmstart beide Klassen „Klasse_1“ und „Klasse_2“ mit samt dem Programmkode der Reihe nach ausgeführt werden. Und zwar ohne dass es irgendeines Aufrufs aus dem Hauptprogramm bedarf. Mal abgesehen davon, dass das im Moment auch gar nicht funktionieren würde, weil sich Klassen per se nicht aufrufen und ausführen lassen. Außer mit einem kleinen Trick, wie wir gleich noch sehen werden.

 

Interessant ist am Programm „micro_python-hallo_2-35.py auch noch, dass wir sozusagen von außen nicht so ohne Weiteres an den Variableninhalt der lokalen Variablen „lokale_SendeVar“ in der Funktion „Funktion_1()“ herankommen! Es sei denn, dass wir diese an die Klasse „Klasse_1“ übergeben, indem wir die Funktion „Funktion_1()“ aufrufen und den Wert der lokalen (Funktions-) Variablen „lokale_SendeVar“ an die (Klassen-) Variable „SendeVar“ übertragen (siehe obenstehendes Bild). -

 

Im Programm „micro_python-hallo_2-36.py geht es bei der Klasse „Klasse_1“ darum, diese jederzeit aufrufbar und ausführbar zu machen. Zu diesem Zweck wird die Klasse „Klasse_1“ in die äußere Funktion „anzeigen_Klasse_1()“ verfrachtet, d.h. verschoben, wodurch die Klasse ihre bisherige selbststartende Eigenschaft beim Programmstart verliert!

 

Um die bisherige selbststartende Eigenschaft der Klasse „Klasse_1“ beim Programmstart wieder herzustellen, programmieren wir die (Hilfs-) Klasse „starte_Klasse_1“, sodass sich die Klasse „Klasse_1“ wieder jederzeit  - und nicht nur beim Programmstart -  aufrufen und ausführen lässt:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Das Komplexe am Programm „micro_python-hallo_2-36.py ist eigentlich nur die Funktion „Funktion_1()“, wenn diese den Variableninhalt der Variablen „lokale_SendeVar“ ganz nach außen in die Funktion „anzeigen_Klasse_1()“ transferieren und an die Variable „SendeVar“ in der Klasse „starte_Klasse_1“ übergeben soll (siehe obenstehendes Bild).

 

Aber da das Transferieren von Variableninhalten nach außen bis ins Hauptprogramm hinein eher die Ausnahme ist und bleibt, bleiben die Funktionen und ihre (Funktions-) Variableninhalte innerhalb der Klasse „Klasse_1“, sodass der Quellkode auch und gerade bei mehreren Funktionen innerhalb einer Klasse übersichtlich bleibt (siehe Programm „oled_demo-01-29.py).

 

Im Programm „micro_python-hallo_2-37.py wird es noch komplexer, aber nur deshalb, weil gezeigt wird, wie sich der Variableninhalt der lokalen Variablen „lokale_SendeVar“ der Funktion „Funktion_1“ mittels der selbststartenden Klasse „starte_Klassen_1u2“ bis ins Hauptprogramm hinein mittels der Variablen „starte_Klassen_1u2.SendeVar weiterreichen lässt! Darüber hinaus lassen sich die beiden Funktionen „anzeigen_Klasse_1()“ und „anzeigen_Klasse_2()“ zusammen mit ihren Klassen „Klasse_1“ und „Klasse_2“ jederzeit auch vom Hauptprogramm aus aufrufen:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

 

Übergeordnete Instanzen als Herrscher über alle Klassen und Funktionen

 

Bei der „Python“-Programmierung gibt es nicht nur Funktionen und Klassen, sondern auch sogenannte Methoden, die nichts anderes sind also Funktionen innerhalb einer Klasse. Dabei beschreibt eine Methode das zielgerichtete Vorgehen zur Erlangung eines speziellen Zieles wie z.B. bei einem Rezept oder einer Rezeptur.

 

Wenn man sich bei einem Kochrezept die entsprechenden Ressourcen (= Ausgangsmaterialien nebst Zutaten) besorgt und sich streng an die Rezeptur, d.h. die Anleitung hält, wie man welche Ressourcen zu einem bestimmten Zeitpunkt zusammen führt, d.h. miteinander durch Rühren vermischt, dann kann beim Backen, Braten oder Kochen nichts schief gehen, erreicht man mit ziemlicher Sicherheit sein Ziel in Form des leckeren Kuchens oder Bratens.

 

Wie wir inzwischen gelernt haben, lassen sich Funktionen und Klassen sowie in Funktionen eingebettete Klassen unterschiedlich handhaben, je nachdem, was bezweckt werden soll.

 

Eine in eine Funktion eingebettete Klasse bietet den Vorteil, dass sich die Klasse mehrfach wiederholt aufrufen und starten lässt, indem man einfach die übergeordnete Funktion startet. Wenn man dabei außerdem erreichen will, dass sich die Klasse auch mittels „Autostart“-Funktion beim Programmaufruf automatisch startet, dann muss man zusätzlich noch eine entsprechende „Autostart“-Klasse programmieren, die beim Programmstart dafür sorgt, dass die gewünschte Funktion nebst integrierter Klasse aufgerufen, d.h. gestartet wird (siehe Klasse „starte_Klassen_1u2“ im Programm „micro_python-hallo_2-37.py).

 

In der Bundesrepublik Deutschland haben wir es mit der Staatsform einer Demokratie zu tun, der das Grundgesetz (GG) als Verfassung zugrunde liegt. Diesbezüglich gibt es in Deutschland das sogenannte Gewaltmonopol, demzufolge Gewalt nur vom Staat selbst ausgehen darf und niemanden sonst. Dabei stützt sich das Gewaltmonopol auf die Gewaltenteilung von Legislative (= Parlament, Gesetzgebung), Exekutive (= Ministerien zur Ausübung und Durchführung von Gesetzen und Verordnungen) sowie Judikative (= Rechtsprechung durch Gerichte).

 

Bezüglich der Rechtsprechung und der Gerichte haben wir es in Deutschland auf der untersten Ebene mit dem sogenannten Schiedsgericht zu, das je nach Bundesland meistens in die Zuständigkeit des Ortsvorstehers z.B. eines Stadtteils oder eines Bezirksamtes fällt. Dabei dient das Schiedsgericht dazu, kleinere Streitigkeit wie z.B. zwischen Nachbarn zu schlichten. Wenn es in einem Stadtteil keinen Ortsvorsteher nebst Schiedsgericht gibt, dann muss sich der Bürger im Falle Streitigkeiten an das vor Ort in der Stadt oder Kreisstadt ansässige Amtsgericht wenden und Klage einreichen. Wenn die Klage vom Amtsgericht abgelehnt oder durch Urteil abgewiesen wird, dann kann man die nächst höhere Instanz anrufen und zwar in Form des Landgerichtes. Falls die Klage auch vorm Landgericht scheitert, kann man bei maßgeblichen Streitfällen oder Straftaten wiederum in Berufung gehen, d.h. die nächst höhere Instanz anrufen und vor’s Oberlandesgericht ziehen.

 

Ähnlich verhält es sich bei den Staatsanwaltschaften, die für die Anklageerhebung zwecks Einhaltung von Bestimmungen, Verordnungen und Gesetzen zuständig sind und die der Exekutive zuzurechnen sind. Demzufolge ist die nächst höhere Instanz über der Staatsanwaltschaft die Oberstaatsanwaltschaft. Und die wiederum nächst höhere Instanz der Oberstaatsanwaltschaft ist die Bundesstaatsanwaltschaft mit der noch darüber befindlichen, d.h. vorgesetzen Dienststelle und Dienstaufsicht des Bundesgeneralanwaltes. Demzufolge kann der Generalbundesanwalt als oberste Dienstbehörde der Staatsanwaltschaften die Ermittlungen im Falle schwerer, verfassungsschutzrechtlicher Straftaten (= Terrorismus, terroristische Vereinigung) der ansonsten zuständigen Oberstaatsanwaltschaft entziehen und selbst ermitteln. -

 

Bei höheren Programmiersprachen (kein Assembler) geht es nicht wie bei der Landwirtschaft mit Kraut und Rüben durcheinander, sondern mehr oder weniger geordnet zu. Während es bei der „BASIC“-Programmiersprache mittels „gosub“-Sprungbefehlen noch kreuz und quer ging und man chaotischen „Spaghetti“-Kode programmieren konnte, geht es bei den höheren, meist Objekt orientierten Programmiersprachen (OOP) wie z.B. Java, C/C++, C# von Microsoft, Python schon deutlich „gesitteter“ zu, gibt es z.B. keine direkten Sprungbefehle mehr!

 

Auch in der „Python“-Programmierung gibt es keine direkten Sprungbefehle, programmiert man seinen Programmkode anfangs hauptsächlich im Hauptprogramm, das in anderen Programmiersprachen „main“ heißt.

 

Wenn dann der Programmkode umfangreicher wird und Programmteile in einem bestimmten Zusammenhang stehen, etwas gemeinsam miteinander zu tun haben oder z.B. eine bestimmte Funktionalität beschreiben/programmieren, dann fasst man diesen zusammenhängen Programmkode in einer Funktion zusammen.

 

Wenn sich dann im Laufe der Zeit mehrere Funktionen ansammeln, die alle im Zusammenhang mit dem Erledigen einer Aufgabe zu tun haben, dann kommt man auf die Idee, diese in einer Klasse zusammenzufassen. Getreu dem Motto „Was ich alles in einer Klasse zusammengefasst habe, muss ich nicht mehr im Kopf haben, funktioniert, kann ich ad acta legen.“ Dass man aber mehrere Funktionen in einer Klasse zusammenfassen kann, ist nur die halbe Wahrheit. Zur vollen Wahrheit gehört nämlich, dass man in einer Klasse auch sehr komfortabel Programmkode programmieren kann mit dem sich Funktionen aufrufen und Variableninhalte bequem austauschen lassen, ohne dass man dazu das Hauptprogramm bemühen muss. Wenn man dann aber früher oder später eine Klasse mehrfach, d.h. öfters aufrufen, starten und ausführen möchte, so wie das z.B. bei der „Autostart“-Funktion geschieht, gerät man schnell an seine Grenzen, könnte man letztlich auch daran verzweifeln und scheitern. Es sei denn, wenn man eine innere Klasse(!) in eine äußere Funktion(!) integriert, da sich Funktionen mit der darin enthaltenen Klasse oder Klassen jederzeit aufrufen und ausführen lassen (siehe Programm „micro_python-hallo_2-37.py)!

 

Im Zusammenhang mit dem Programm „micro_python-hallo_2-37.py“ stellt sich dann auch früher oder später die Frage, ob sich komplexe Funktionen und/oder Klassen zu etwas Höherem berufen lassen, die sozusagen über allen Funktionen und/oder Klassen stehen und eine höhere, weil mächtigere Instanz bilden. Eine Instanz als alleiniger Herrscher und Beherrscher aller, d.h. mehrerer Klassen und Funktionen.

 

Beim Programm „micro_python-hallo_2-38.py gibt es gleich zwei Instanzen und zwar

 

1.    die Instanz „InstanzVar_Funktion_anzeigen_Klasse_2“

 

in Form der Funktion „anzeigen_Klasse_2()“ mit dem

(Rückgabe-) Statement „return(Klasse_2.EmpfangsVar)“ an die vorgenannte Instanzvariable und

 

2.    die Instanz „InstanzVar_Klasse_starte_Klassen_1u2“

 

in Form der (Klassen-) Variablen „starte_Klassen_1u2.EmpfangsVar an die Instanzvariable.

 

Wie man unschwer sieht, handelt es sich bei beiden Instanzen in Wirklichkeit um Instanzvariablen nebst deren Inhalten:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Wie man im abgespeckten Programm „micro_python-hallo_2-39.py sieht,

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

kann beim Arbeiten mit den Instanzen „Instanz_anzeigen_Klasse_2“ und „Instanz_starte_Klassen_1u2“ auf die Klasse „starte_Klassen_1u2“ ganz verzichten, weil die beiden Instanzen selbst der Funktion „anzeigen_Klasse_2()“ entsprechen!

 

Im Moment sieht es also so aus, als ob das Arbeiten mit der Instanz „anzeigen_Klasse_2“ außer der verkürzten Schreibweise keine besonderen Vorteile ergibt.

 

Diesbezüglich stellt sich die Frage, ob es besondere Vorteile bringt, wenn man eine Klasse zur Instanz erklärt. –

 

Um das zu klären, wenden wir uns wieder dem Programm „micro_python-hallo_2-35.py“ zu, das wir auf das Programm „micro_python-hallo_2-40.py kopieren und wie folgt erweitern:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Besonders interessant an der Instanz „Instanz_Klasse_1“ ist nun, dass sich mittels dieser sowohl

 

·       die Funktion „Funktion_1()“ als auch

 

·       die Klassenvariable „SendeVar“

 

direkt ansprechen, aufrufen und benutzen lassen. Und zwar ohne den Umweg über das

 

·       Statement „rueckgabeWert = Klasse_1.Funktion_1() als auch

 

·       Statement „print(“Inhalt der Klassenvariablen ’SendeVar’: “, Klasse_1.SendeVar)“

 

Wenn man bei der Wahl des Instanznamens, im vorliegenden Fall „Instanz_Klasse_1“, vom logischen Sinnzusammenhang als Hinweis auf die Klasse „Klasse_1“ abweicht, dann sieht man es dem Instanznamen nicht mehr an, auf welche Klasse sich die Instanz „xy“ bezieht! Auch sieht man es dem Instanznamen nicht mehr an, ob es sich bei diesem um eine Instanz, eine Klasse, eine Funktion oder Variable handelt.

 

Um Missverständnisse zu vermeiden, sollte man deshalb stets einen Instanznamen wählen, der im Sinnzusammenhang mit der entsprechenden Klasse, Funktion oder der Variablen steht! -

 

Werfen wir abschließend noch einen Blick auf die Bildschirmausgabe des Programms „micro_python-hallo_2-40.py:

 

 

(Zum Vergrößern bitte auf das Bild klicken!)

 

Bezüglich der Instanz „Instanz_Klasse_1“ muss noch festgestellt werden, dass sich damit die Klasse „Klasse_1“ selbst wider Erwarten nicht noch ein weiteres Mal starten und ausführen lässt! -

 

Weiter zum „Micropython“-Programmieren, Teil 3

 

 

 

[ Home ] [ Seitenanfang ]