|
|
[ Home ] [ Seitenende ]
|
|
||
|
|
Micropython, Teil 1 In den Micropython Grundlagen, Teil
1 “Einleitung
erste Schritte”, Sprachstruktur, interaktive Konsole, wird das erste
Python-Programm "hallo.py"
programmiert und im YouTube-Video besprochen:
(Zum Vergrößern bitte auf das
Bild klicken!) Dabei stellt sich heraus, dass das
obenstehende Programm “hallo.py”
für einen Python-Einsteiger leider gleich auf einmal zu viele Dinge, wie z.B.
die Liste “namen” mit Vornamen, die Funktion “sage_hallo()” zum Anzeigen
eines einzelnen Vornamens und eine “for”-Schleife mit dem Funktionsaufruf
“sage_hallo()” zwecks Anzeige aller Vornamen, enthält, die dem
Python-Anfänger noch gänzlich unbekannt sein dürften, sodass er zwar die
Funktionsweise des Programms, wenn sie im YouTube-Video besprochen wird,
logisch nachvollziehen kann, aber eben nicht wirklich versteht bzw. verstehen
kann, um dieses jederzeit fehlerfrei auf dem eigenen Desktop-PC bzw. dem
“HELTEC WiFi kit 32”-Mikrorechner reproduzieren zu können. Das für den Python-Einsteiger schwer zu
verstehende Programm hat mich deshalb motiviert, das Programm zu analysieren
und in mehreren, aufeinander aufbauenden Schritten neu zusammenzusetzen,
sodass man die Dinge Schritt für Schritt lernen und besser verstehen
kann. Beginnen wir deshalb mit dem ganz einfachen
(Micro-) Python-Programm “micro_python-hallo_01.py”,
(Zum Vergrößern bitte
auf das Bild klicken!) das nichts anderes tut, als den Schriftzug
“Hello World!” in der Python-Konsole der “Thonny”-Programmier- und
Entwicklungsumgebung anzuzeigen:
(Zum Vergrößern bitte
auf das Bild klicken!) Und, weil das so einfach war und so gut
geklappt hat, übersetzen wir im Python-Programm “micro_python-hallo_02.py” die
Zeichenkette (= String) “Hello World!” direkt ins Deutsche mit dem String (=
Zeichenkette) “Hallo Welt!”:
(Zum Vergrößern bitte
auf das Bild klicken!) Interessant ist dabei, dass mit jedem weiteren
“print”-Befehl eine Zeilenschaltung ausgeführt wird, sodass die nächste
Ausgabe bzw. String-Anzeige in einer neuen Zeile beginnt:
(Zum Vergrößern bitte
auf das Bild klicken!) Wichtig ist dabei, dass es sich bei der
Zeilenschaltung nicht um eine Absatzschaltung handelt! Eine Absatzschaltung ist nämlich eine
Zeilenschaltung plus Leerzeile, wie man das im Python-Programm “micro_python-hallo_03.py”
ausprobieren kann:
(Zum Vergrößern bitte
auf das Bild klicken!) Nachfolgend die Anzeige mit Absatzschaltung:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man sieht, werden zwischen “Hello World”
und “Hallo Welt!” insgesamt zwei Leerzeilen eingefügt. Die erste
Zeilenschaltung wird vom bzw. nach dem Befehl print("Hello World!")
veranlasst und die zweite Zeilenschaltung plus einer Leerzeile vom
Befehl print(“\n”). Optisch werden
deshalb zwei Leerzeilen veranlasst bzw. angezeigt. Beim Python-Programm “micro_python-hallo_04.py“ wurde
die Zeilenschaltung, engl. “new line”, ans Ende des Befehls print("Hello
World!\n”) gesetzt,
(Zum Vergrößern bitte
auf das Bild klicken!) sodass nur eine Zeilenschaltung plus eine
Leerzeile veranlasst, d.h. ausgegeben wird:
(Zum Vergrößern bitte
auf das Bild klicken!) Beim Python-Programm “micro_python-hallo_05.py“
verwenden wir erstmals eine Variable namens “variable_1” mit dem zugewiesenen
Variableninhalt “Hello World!”:
(Zum Vergrößern bitte
auf das Bild klicken!)
(Zum Vergrößern bitte
auf das Bild klicken!) Diesbezüglich verhält es sich bei
Programmiersprachen allgemein so, dass eine Variable zunächst deklariert
wird, wobei dieser einfach nur gesagt wird, um welchen Typ von Variable es
sich handeln soll: Buchstabe, engl. “char(acter)”, Zeichenkette, engl.
“str(ing)”, ganzzahliger Wert, engl. “int(eger)”, Fließkommazahl, engl.
“float”. Das Angenehme bei (Micro-) Python ist nun,
dass der Typ einer Variablen automatisch anhand der Zuweisung wie z.B. “Hello
World!” erkannt wird. Nämlich der Typ “str” für engl. “string”, d.h.
Zeichenkette. Das Zuweisen der Zeichenkette “Hello World!” an die Variable
“variable_1” nennt man initialisieren (siehe Programm „micro_python-hallo_06.py“):
(Zum Vergrößern bitte
auf das Bild klicken!)
(Zum Vergrößern bitte
auf das Bild klicken!) Mit dem Statement variable_1 = "Hello World!"
wird bei Python und Micropython die Variable “variable_1” deklariert und mit
“Hello World!” gleichzeitig initialisiert! Wenn man wissen will, von welchem Typ die
Variable “variable_1” ist, dann muss man das Python-Programm “micro_python-hallo_07.py“
aufrufen und ausführen,
(Zum Vergrößern bitte
auf das Bild klicken!) sodass man nachfolgende Bildschirmanzeige
erhält:
(Zum Vergrößern bitte
auf das Bild klicken!) Beim Python-Programm “micro_python-hallo_08.py“ wird
die erste Initialisierung der Variablen “variable_1” von der zweiten
überschrieben:
(Zum Vergrößern bitte
auf das Bild klicken!) Angezeigt wird also der Variablentyp “int”,
engl. “integer”, d.h. ganzzahlig:
(Zum Vergrößern bitte
auf das Bild klicken!) Interessant ist auch das Python-Programm “micro_python-hallo_09.py“ bei
dem der Variablen “variable_1” eine Dezimal-/Fließkommazahl zugewiesen wird:
(Zum Vergrößern bitte
auf das Bild klicken!) Hier noch die Bildschirmanzeige vom
obenstehenden Python-Programm
(Zum Vergrößern bitte
auf das Bild klicken!) Übrigens: Kennen Sie den Unterschied zwischen
Zahlen und Ziffern? Mit Zahlen kann man rechnen, mit Ziffern z.B.
nur die Uhrzeit anzeigen. Bei einer Ziffernfolge handelt es sich also um eine
Zeichenkette vom Typ “str”, engl. “string”. Beim Python-Programm “micro_python-hallo_10.py“ wird
die Variable “variable_1” zunächst mit einem leeren Textstring versehen. Und
zwar mit dem Statement “variable_1 = str()”:
(Zum Vergrößern bitte
auf das Bild klicken!) Im zweiten Schritt erfolgt dann die
Wertzuweisung in Form des Textstrings “Hello World!”, sodass sich
nachfolgende Bildschirmanzeige ergibt:
(Zum Vergrößern bitte
auf das Bild klicken!) Beim Python-Programm “micro_python-hallo_11.py“ soll
die Variable “variable_1” zunächst mit einer Fließkommazahl versehen werden,
die allerdings gleich durch das Statement “str()” in eine Zeichenkette mit
den Ziffern “0.12345” umgewandelt
wird:
(Zum Vergrößern bitte
auf das Bild klicken!) Die Bildschirmanzeige zum Programm „micro_python-hallo_11.py“ ist,
wie man sieht, nicht spektakulär:
(Zum Vergrößern bitte
auf das Bild klicken!) Wir wissen inzwischen, dass man mit einer
Zeichenfolge, die aus Ziffern besteht, wie z.B. “012345”, nicht
rechnen kann. Eben weil Ziffern keine Zahlen sind. Wenn man aber trotzdem mit Ziffern rechnen
will, dann muss man diese vor dem Rechnen in einen ganzzahlige Wert, engl.
“int(eger)” oder in eine Fließkommazahl, engl. “float”, umwandeln (siehe
Programm „micro_python-hallo_12.py“):
(Zum Vergrößern bitte
auf das Bild klicken!) Von außen betrachtet, d.h. ausgehend von der
Anzeige auf dem Display, sieht man es dem Programm nicht an, ob es sich bei
der Zeichenfolge “12345” in Wirklichkeit um einen String handelt oder um die
Zahl 12345 selbst, die im Dezimalzahlensystem zur Basis 10 den (Zahlen-) Wert
zwölftausenddreihundertfünfundvierzig, kurz 12 345 hat. Nur wenn man sich den Typ der Variablen
“variable_1” anzeigen lässt, erfährt man, dass der Variableninhalt vom Typ
“int(eger)”, d.h. ganzzahlig ist, sodass es sich bei der Zeichenfolge “12345”
in Wirklichkeit um eine Zahl handelt:
(Zum Vergrößern bitte
auf das Bild klicken!) Die vorangestellte “0” bei der Zeichenkette
“012345” wird, wie man bei der obenstehenden Bildschirmanzeige sieht, bei der
Umwandlung in die Ganzzahl 12345 unterdrückt, obwohl die Zahl 0 eben auch
eine Zahl ist. - Beim Python-Programm “micro_python-hallo_13.py“
wird erstmalig eine sogenannte Liste verwendet. Und zwar
die Liste „variablen_Liste”, die zwei Elemente in Form der Variablen “variable_1” und “variable_2” enthält. Eine Liste kann also nicht nur Elemente mit
(Text-) Strings, Ganzzahlen, Fließkommazahlen oder booleschen Werten “True” (=
wahr, richtig) oder “False” (= unwahr, falsch) enthalten, sondern eben auch
Variable:
(Zum Vergrößern bitte
auf das Bild klicken!) Dabei lässt sich eine Liste auch kombiniert
mit unterschiedlichen Typen von Elementen usw. füllen. Auch mit dem
Aufruf einer Funktion, einer Methode (= Funktion innerhalb einer Klasse) oder
eines Objektes, wie wir später noch sehen werden.
In diesem Zusammenhang lässt sich zwar eine
einfache, d.h. eindimensionale Liste mit einem sogenannten eindimensionalen Array vergleichen. Trotzdem
gilt es dabei aber zu beachten, dass eine „tuple“-Liste prinzipiell eine Datensatzliste ist und kein Array.
Arrays in C/C++ bekommen im Arbeitsspeicher
des Rechners einen festen Speicherbereich zugewiesen, der nicht wie in einer
sogenannten Sandbox gekapselt und demzufolge gegen Manipulation
abgeschottet ist. Bei einem Array wird mittels eines Zeigers,
engl. “pointer”, auf einzelne Elemente des Arrays verwiesen
und diese bei Bedarf, d.h. bei einem gezielten Zugriff zwecks Verarbeitung
zugegriffen. Der Zugriff auf einzelne Elemente eines Arrays erfolgt dabei
über die sogenannte Indexierung des Arrays, eben mittels des Pointers. Da das Array im Arbeitsspeicher des PCs zwecks
schnellem, indexiertem Zugriff auf dem sogenannten Stack abgelegt wird und
sich der Stack seitens des (Windows-) Betriebssystems und des verbauten
Intel- oder AMD-Prozessors manipulieren lässt, beherbergen Arrays,
insbesondere die Pointer auf diese, ein entsprechendes Sicherheitsrisiko. Das
liegt aber prinzipiell nicht an den Arrays selbst, sondern an der
Arbeitsweise und Verwaltung des Stacks. Da der Stack am Ende des Arbeitsspeichers,
d.h. oben über dem normalen Speicher, angesiedelt ist, lässt sich dieser
spontan nicht beliebig vergrößern. Während sich also ein in C/C++ programmiertes
Array jederzeit beliebig mit Contents “aufblasen”, d.h. vergrößern lässt, ist
dies bei dem Stack nicht zwangsläufig möglich. Der schwarze Peter liegt also beim Stack, der
immer erst nachträglich merkt, dass er zu klein ist, um ein vergrößertes
Array vollständig aufzunehmen. Das ist dann so ähnlich wie an der
Straßenbahnhaltestelle, wo viele Personen in die Straßenbahn einsteigen
wollen und dann erst merken, dass diese bereits voll besetzt ist bzw. nicht
alle aufnehmen kann. Kurz und knapp, Python umgeht die Probleme mit
den Arrays, den Pointern und dem Stack, indem ganz einfach auf Arrays
verzichtet wird. Trotzdem lässt sich in Python ein entsprechendes Array-Modul
importieren, sodass sich mittels diesem auch Arrays programmieren lassen. Schauen wir uns abschließend noch die
Ausgabe/Anzeige des Python-Programms “micro_python-hallo_13.py“ an:
(Zum Vergrößern bitte
auf das Bild klicken!) Beim Python-Programm “micro_python-hallo_14.py“
werden erstmals einzelne Elemente aus der („tuple“-) Liste “variablen_Liste”
angesprochen und mittels dem entsprechenden “print()”-Statement ausgegeben,
d.h. angezeigt:
(Zum Vergrößern bitte
auf das Bild klicken!) Da Computer, d.h. deren Prozessoren, im
Inneren nur mit Nullen und Einsen binär rechnen, ist die Zahl 0 für den
Computer von maßgeblicher Bedeutung. Das gilt sinngemäß auch für die einzelnen Elemente
der Liste “variablen_Liste”, deren Indexierung stets bei Null beginnt (siehe
oben im Programm). Interessant ist bei dem obenstehenden Programm
noch, dass man bei der “print”-Ausgabe mit den verbundenen (“+”) Elementen print("English
spoken: " + str(variablen_Liste[0]) + ", German
spoken: " + ... auf die String-Umwandlung “str()” verzichten kann, da
beide Variablen “variable_1” und “variable_2” nur Zeichenketten, engl.
“str(ings)”, enthalten, die für die “print()”-Anzeige nicht eigens in einen String
umgewandelt werden müssen:
(Zum Vergrößern bitte
auf das Bild klicken!) Ändert
man den Variableninhalt der Variablen “variable_1” mit dem Statement variable_1
= str("Hello World!") auf das Statement variable_1 = 012345 ab,
dann kommt es bei der späteren Programmausführung in der Zeile print("English
spoken: " + variablen_Liste[0] + ", German spoken: " + … zum
Programmabbruch und einer entsprechenden Fehlermeldung! - Wie bereits erwähnt, ist die Stringumwandlung
bei der Initialisierung der Variablen “variable_1” beim Statement variable_1 = str("Hello World!") logischerweise
nicht erforderlich, das es sich bei der Zuweisung der Zeichenkette “Hello
World!” bereits um einen String handelt. - Beim Python-Programm “micro_python-hallo_15.py“
(Zum Vergrößern bitte
auf das Bild klicken!) wird
im Statement variablen_Liste = tuple() zunächst
eine leere Liste vom Typ “tuple()” deklariert, kurz darauf aber mit dem
Statement variablen_Liste = (variable_1,
variable_2) initialisiert
und überschrieben. - Obwohl das Deklarieren (= Festlegen des Typs einer
Variablen mit leerem Inhalt) im allgemeinen in Python nicht erforderlich ist,
weil das Bestimmen und Festlegen eines Variablentyps bei der Initialisierung
automatisch vorgenommen wird, gibt es bei der Programmierung in Python
trotzdem Situationen, wo man zunächst eine Deklaration vornehmen muss, weil das
Initialisieren einer Variablen mit einem Inhalt erst zu einem späteren
Zeitpunkt möglich ist! Als Beispiel sei hier das Anlegen eines neuen,
anfangs leeren Objektes mit einer Klasse und einer Methode (= Funktion
innerhalb einer Klasse) genannt. Wenn dabei die in der Klasse enthaltene
Funktion aus irgendeinem Grund gleich beim Programmstart ausgeführt werden
soll, dann geht das nur, wenn die Funktion einer Klassenvariablen zugeordnet
wird, sodass diese zur Methode wird. Dabei muss die Klassenvariable, mittels
der sich die Funktion direkt beim Programmstart ausführen lässt, deklariert
werden, d.h. einem Typ von (Klassen-) Variablen zugeordnet werden. Auch und
weil es anfangs für die (Klassen-) Variable keinen Inhalt, keinen Wert gibt. Mit dem Python-Programm “micro_python-hallo_16.py“ wird
erstmals der Befehl “len()” benutzt mit dem sich die Anzahl der Elemente
einer Liste ermitteln lässt:
(Zum Vergrößern bitte
auf das Bild klicken!) Nachfolgend die dazugehörige
Bildschirmanzeige:
(Zum Vergrößern bitte
auf das Bild klicken!) Mit dem Python-Programm “micro_python-hallo_17.py“ wird
die Anzahl der Elemente der Liste “variablen_Liste” ermittelt und dazu
verwendet, um in der “while”-Schleife die Elemente der Liste, konkret die
Inhalte der Variablen-Elemente mittels des “print()”-Befehls zeilenweise
anzuzeigen:
(Zum Vergrößern bitte
auf das Bild klicken!) Da die indexierten Listenelemente
“variablen_Liste[n]” mittels des Schleifenzählers n der Reihe nach, d.h.
aufsteigend, ausgelesen und mittels “print()”-Befehl innerhalb der
“while”-Schleife zeilenweise angezeigt werden, muss der Schleifenzähler n am
Ende der “while”-Schleife mittels des Statements “n = n + 1” jeweils um + 1
erhöht werden:
(Zum Vergrößern bitte
auf das Bild klicken!) Das schrittweise Erhöhen des
Schleifenzählers um + 1 nennt man auch inkrementieren, das Verringern
des Schleifenzählers um - 1 dekrementieren! Beim Python-Programm “micro_python-hallo_18.py“ wird
noch etwas Programmkosmetik angewandt,
(Zum Vergrößern bitte
auf das Bild klicken!) indem die Ausgabe bzw. die Bildschirmanzeige
noch etwas aufgehübscht wird. Dabei fällt wieder auf, dass die Indexierung
der Listenelemente bei der laufenden Nr. = 0 beginnt:
(Zum Vergrößern bitte
auf das Bild klicken!) Mit dem Python-Programm “micro_python-hallo_19.py“
nähern wir uns wieder dem Ausgangsprogramm “hallo.py”
an, indem es ja um das Anzeigen der Namensliste “vornamen_Liste” =
(“Max", "Peter", "Monika", "Petra") geht. Allerdings verwenden wir in der Namensliste
keine statischen Werte in Form der Vornamen, sondern dynamische, indem wir
die Variablen “vorname_1”, "vorname_2”, “vorname_3” und "vorname_4”
verwenden:
(Zum Vergrößern bitte
auf das Bild klicken!) Nachfolgend noch die zum Programm gehörende
Bildschirmanzeige:
(Zum Vergrößern bitte
auf das Bild klicken!) Als nächstes programmieren wir beim Programm “micro_python-hallo_20.py“ erstmals
eine Funktion und zwar die Funktion namens “einlesen_Vornamen()”. Wie der
Funktionsname bereits ausdrückt, sollen mit der Funktion später die Vornamen
der Namensliste “vornamen_Liste” aus- und in die Funktion eingelesen werden:
(Zum Vergrößern bitte
auf das Bild klicken!) Nachdem die noch leere Funktion
“einlesen_Vornamen()” funktioniert, geht es nachfolgend darum, dass wir diese
“füllen”, indem wir die Liste “namens_Liste” mit den Vornamen in die Funktion
holen, diese zwecks Überprüfung mittels der “while”-Schleife anzeigen lassen
und über das Statement “return(namens_Liste)” wieder an das Hauptprogramm
zurückgeben (siehe Programm „micro_python-hallo_21.py“):
(Zum Vergrößern bitte
auf das Bild klicken!) Nachfolgend die Kontrollanzeige in der
obenstehenden “while”-Schleife der Funktion “einlesen_Vornamen()” zwecks
Überprüfung der Liste “namens_Liste”:
(Zum Vergrößern bitte
auf das Bild klicken!) Bei der obenstehenden Funktion
“einlesen_Vornamen()” des Python-Programms “micro_python-hallo_21.py“ gilt
es zu beachten, dass die in der Funktion verwendeten Variablen nebst der
initialisierten Inhalten nur innerhalb der Funktion selbst gültig
sind. Das gilt natürlich auch für die Liste “namens_Liste”, auf die sich von
außen, d.h. vom Hauptprogramm aus, nicht zugreifen lässt. Demzufolge sind
alle Variablen, Variableninhalte und Listen innerhalb der Funktion
“einlesen_Vornamen()” gekapselt, d.h. abgeschottet! Mit dem Funktionsausgang
“return(namens_Liste)” (siehe oben) lässt
sich allerdings die interne Namensliste an das Hauptprogramm wie folgt übergeben:
(Zum Vergrößern bitte
auf das Bild klicken!) Die Bildschirmanzeige des Hauptprogramms “micro_python-hallo_21.py” mit
der Ausgabe/Anzeige der Namensliste sieht dann wie folgt aus:
(Zum Vergrößern bitte
auf das Bild klicken!) Die im Programm “micro_python-hallo_21.py”
programmierte Funktion “einlesen_Vornamen()” hat aber nicht nur einen
(Funktions-) Ausgang mit dem Statement “return(namens_Liste)”, sondern auch
einen (Funktions-) Eingang “()”, den wir bisher aber noch nicht benutzt
haben. Mit dem Programm “micro_python-hallo_22.py”
ändert sich das aber, programmieren wir einen Funktionseingang und zwar im Funktionskopf:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man im obenstehenden Sourcecode (=
Quell-/Programmkode) sieht, wird die Namensliste vom Typ “tuple“ im Funktionskopf deklariert einlesen_Vornamen(namens_Liste : tuple) und erst später mit dem Funktionsaufruf vornamen_Liste = einlesen_Vornamen(("Max", "Peter",
"Monika", "Petra")) initialisiert, d.h. mit Inhalten in
Form der Vornamen versehen! Demzufolge sieht der Funktionsaufruf im Hauptprogramm nun folgendermaßen aus:
(Zum Vergrößern bitte
auf das Bild klicken!) Beim Programm “micro_python-hallo_23.py” wird nun
noch eine Ausgabe-/Anzeige-Funktion “ausgabe_Vornamen(hole_vornamensListe)
programmiert:
(Zum Vergrößern bitte
auf das Bild klicken!) Bei der obenstehenden
Ausgabe-/Anzeige-Funktion fällt im Funktionskopf auf, dass die (Listen-)
Variable “hole_vornamensListe” wider Erwarten nicht als Typ “tuple” deklariert
wurde, da die Namensliste “vornamen_Liste” im Hauptprogramm bereits Inhalte
in Form der Vornamen enthält, also bereits initialisiert ist:
(Zum Vergrößern bitte
auf das Bild klicken!) Die Bildschirmanzeige des Programms “micro_python-hallo_23.py” mit
der Ausgabe/Anzeige der Namensliste sieht wie folgt aus:
(Zum Vergrößern bitte
auf das Bild klicken!) Im Zusammenhang mit der Liste “vornamen_Liste”
der Ausgabe/Anzeige stellt sich noch die Frage, ob es auch möglich ist, dass
man sich nur einen einzelnen Vornamen aus der Namensliste anzeigen lässt. Prinzipiell ist das kein Problem, da ja die
Namensliste und deren einzelne Elemente indexiert sind, sodass sich ein
einzelnes Element über den Index auswählen und wie im Programm “micro_python-hallo_24.py”
realisiert, darstellen/anzeigen lässt:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man bei der obenstehenden Funktion “einzelner_Vorname()”
sieht, muss man der Funktion zwei Parameter mit auf den Weg geben. Und
zwar die Namensliste “hole_vornamenListe” und den entsprechenden Index
“lfd_Nr”. Dabei muss die Namensliste
“hole_vornamenListe” im Funktionskopf nicht extra als vom Typ “tuple”
deklariert werden, das die Namensliste ja bereits dem Hauptprogramm bekannt
ist und dem Funktionsaufruf nur noch mit auf den Weg gegeben werden muss. Da es für den Anwender wenig Sinn macht, dass
er sich einen indexierten (= “lfd_Nr”) Vornamen anzeigen lässt, den es gar
nicht gibt, weil er nicht in der Liste steht bzw. dessen “lfd_Nr”-Index sich
außerhalb des Listenbereichs von [0 … 3] befindet, fragen wir mit dem
Statement “len(vornamen_Liste)” die Anzahl der Listenelemente (= 4 Elemente bzw.
Vornamen) ab. Diesbezüglich müssen wir aber von der max. Anzahl der
Listenelemente noch 1 subtrahieren, da der Index der Namensliste beim Element
mit dem Index = 0 beginnt: element_Nr_str = input("Welcher Vorname
[0 ... " + str(len(vornamen_Liste) - 1) +
"] soll angezeigt werden? ")
(Zum Vergrößern bitte
auf das Bild klicken!) Die Bildschirmanzeige des obenstehenden
Programms “micro_python-hallo_24.py”
mit der Ausgabe/Anzeige der Namensliste sieht dann wie folgt aus:
(Zum Vergrößern bitte
auf das Bild klicken!) Bei der gewünschten Anzeige eines einzelnen
Vornamens (siehe oben) kann es seitens des Anwenders durchaus vorkommen, dass
dieser einen falschen Wert für den Listenindex von [0 … 3] eingibt, wie oben
im Programm programmiert, auf seinen Fehler hingewiesen wird und sich dabei
ärgert, weil er seinen Eingabefehler wider Erwarten nicht durch eine erneute
Eingabe korrigieren kann. Um den Anwender im Falle einer Falscheingabe
nicht zu frustrieren, sollten wir ihm eine neue Chance geben und eine
weitere, korrigierte Eingabe ermöglichen! Zu diesem Zweck müssen wir die “input”-Eingabe
im Programm “micro_python-hallo_25.py”
in die Funktion “einzelner_Vorname()” verschieben. Außerdem müssen wir den
boolschen (Wahrheits-) Schalter “wiederhole_Eingabe = False/True”
entsprechend programmieren
(Zum Vergrößern bitte
auf das Bild klicken!) und je nach Eingabe auf die richtige oder
falsche (Index-) Namensabfrage im oder außerhalb des (Index-) Bereichs
[0...3] reagieren und ggf. eine Wiederholung der “input”-Eingabe
veranlassen. In diesem Zusammenhang muss man wissen, dass
man einer Funktion einen booleschen Wahrheitswert “False/True” zuweisen und
quasi mit auf den Weg geben kann:
(Zum Vergrößern bitte
auf das Bild klicken!) Die Bildschirmanzeige, d.h. die
Anzeige/Ausgabe, sieht dann, je nach Eingabe des (Namens-) Index, wie folgt
aus (siehe Programm „micro_python-hallo_25.py“):
(Zum Vergrößern bitte
auf das Bild klicken!) Jetzt sind wir an einem Punkt angelangt, wo wir
das einfache Programm zum Einlesen, Auslesen und Anzeigen der Namensliste
schon recht weit getrieben haben. Was jetzt noch fehlt, wäre, dass sich die
Namensliste nachträglich noch erweitern lässt, indem man weitere Vornamen an
die vorhandene Liste anhängt oder aber auch aus der vorhandenen löscht! Bei den bisherigen Programmen haben wir bis
jetzt umgangssprachlich(!) von einer Liste mit Vornamen gesprochen, obwohl es
sich bei dieser stets um ein engl. “tuple”, d.h. einen Datensatz vom (Daten-) Typ
“tuple”, der sich aus mehreren Datenfeldern zusammensetzt, handelte: namens_Liste
= (“Max”,
“Peter”, “Monika”, “Petra”) Ein Datensatz vom Typ “tuple” wie z.B. die
“namens_Liste” ist aber stets statisch mit dem Nachteil, dass sich
dieser nicht ändern oder durch Anhängen eines weiteren Vornamens
erweitern lässt! Demzufolge lassen sich auch einzelne Datenfelder
inhaltlich/datenmäßig nicht verändern, sodass sich aus dem Peter keine
Petra machen lässt und umgekehrt! Da wir aber die Namensliste, pardon den
Datensatz, mittels weiterer Vornamen erweitern wollen, müssen wir uns vom “tuple”-Datensatz
verabschieden und uns der “list”-Datenliste vom Typ “list” wie folgt zuwenden: namens_Liste
= [“Max”,
“Peter”, “Monika”, “Petra”] Zum Glück verhält es sich so, dass wir beim
Programm “micro_python-hallo_26.py”
nur ganz wenige Änderungen vornehmen müssen, als da sind: 1.
Im Hauptprogramm: vornamen_Liste
= einlesen_Vornamen(["Max",
"Peter", "Monika", "Petra"]) 2.
Im Funktionkopf der Funktion “einlesen_Vornamen()” def
einlesen_Vornamen(namens_Liste : list): Wenn man das entsprechend geänderte
Programm “micro_python-hallo_26.py”
aufruft und sich die Ausgabe/Anzeige der “list”-Namensliste anzeigen lässt, dann
bekommt man folgende Bildschirmanzeige angezeigt:
(Zum Vergrößern bitte
auf das Bild klicken!) Wie man im Programmkode des Programms “micro_python-hallo_26.py”
unschwer sieht, ist es ganz einfach, die beiden Vornamen “Dieter” und “Karin”
der bisherigen “list”-Namensliste hinzuzufügen:
(Zum Vergrößern bitte
auf das Bild klicken!) Weiter zum „Micropython“-Programmieren, Teil 2“ |
|
||
|
|
[ Home ] [ Seitenanfang ] |
|
