data.PREP #Python – Control Structures
This is a modal window.
Das Video konnte nicht geladen werden, da entweder ein Server- oder Netzwerkfehler auftrat oder das Format nicht unterstützt wird.
Formale Metadaten
| Titel |
| |
| Serientitel | ||
| Anzahl der Teile | 17 | |
| Autor | 0000-0002-5178-8497 (ORCID) | |
| Lizenz | CC-Namensnennung 4.0 International: Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen. | |
| Identifikatoren | 10.5446/65914 (DOI) | |
| Herausgeber | ||
| Erscheinungsjahr | ||
| Sprache |
Inhaltliche Metadaten
| Fachgebiet | |||||
| Genre | |||||
| Abstract |
| ||||
| Schlagwörter |
|
data.PREP #Python6 / 17
10
00:00
Vorlesung/KonferenzBesprechung/Interview
00:52
Computeranimation
01:32
Vorlesung/KonferenzComputeranimationBesprechung/Interview
08:57
Vorlesung/KonferenzComputeranimationBesprechung/Interview
Transkript: Deutsch(automatisch erzeugt)
00:08
Herzlich willkommen zu unserem Kurs Data Prep Python. Heute wollen wir uns mit dem dritten Grundbaustein der Programmierung auseinandersetzen. Wir haben Ausdrücke und Anweisungen bereits betrachtet. Anweisungen werden, soweit wir das bisher sehen, immer von oben nach unten in einem
00:25
Fragment ausgeführt. Jetzt kommen wir zu einem entscheidenden Grundbaustein, nämlich Kontrollstruktur. Das heißt, Sie können nach dieser Session unterscheiden, welche Kontrollstrukturen gibt es und damit dann aktiv auch den Programmablauf steuern. Dabei lernen Sie, dass Codeblöcke unter
00:44
bestimmten Bedingungen ausgeführt werden können oder eben Anweisungen, die man hat in einem Blog, wiederholt ausgeführt werden können. Schauen wir uns das an Beispiel mit Code an. Wir wollen also den Programmablauf kontrollieren und zwar einerseits unter bestimmten Bedingungen Code
01:02
ausführen oder andererseits Code wiederholt ausführen. Schauen wir zunächst auf das bedingte Verzweigen. Das geht mit dem Schlüsselwort IF. Das heißt, Code soll nur ausgeführt werden unter einer bestimmten Bedingung, zum Beispiel, wenn ein Wert berechnet wurde und über oder unterhalb eines Schwellwerts liegen soll oder wenn ein Sensorwert beschritten wird, dann soll eine
01:23
Berechnung ausgegeben werden oder man will eben das Resultat einer Berechnung unter bestimmten Bedingungen weiterverarbeiten. Schauen wir uns hier das Code Stück dazu an. Wir haben hier eine Berechnung durchgeführt oder ein Sensorwert ausgelesen mit 19.45, weisen dieses einer Variablen zu.
01:42
Jetzt können wir diese Variable in unserem Fall jetzt einfach zur Demozwecken einfach mal ausgeben, aber nur dann, wenn der Wert größer Null ist. Das geht in Python Code so, dass die Bedingung ausgewertet wird nach dem Schlüsselwort IF. IF myValue ist größer Null, dann print myValue
02:01
is a positive number und wenn wir das ausführen, dann sehen wir, dass 19.45 ist eine positive Zahl ausgegeben wird. Ich kann auch demonstrieren, wenn wir hier jetzt zum Beispiel einen negativen Wert hätten und wir das Ganze ausführen, dann sehen Sie, dass hier nichts ausgegeben wird. Also der Schwellwert muss überschritten werden. Ich mache das wieder zu einer positiven Zahl für das Außen. Wir
02:24
sehen, diese Print-Anweisung wird genau dann ausgeführt, wenn die Bedingung erfüllt ist. Wir sehen, nach dem Doppelpunkt ist das Print eingerückt gegenüber dem IF geschrieben. Das bedeutet, dass diese Anweisung nur dann ausgeführt wird, wenn die Bedingung auch erfüllt ist.
02:42
Das Ganze kann man auch mit mehreren Codezeilen machen. Ich habe das Beispiel hier erweitert, um zu demonstrieren, wir haben nach dem IF in dem Block zwei Anweisungen, die ausgeführt werden, wenn die Bedingung erfüllt ist und wir sehen, dass die Anweisung, die dann wieder ausgerückt ist,
03:00
also wieder nach links gerückt ist, auf jeden Fall ausgeführt wird, ohne dass die Bedingung erfüllt ist. Schauen wir mal erstmal wieder, der positive Wert wird eingelesen, die Bedingung ist erfüllt. Wir sehen, es wird ausgegeben, die beiden Anweisungen, die hier stehen. 1945 ist a positive number. This has been tested by an IF-Clause. Das ist hier eingerückt. Außerdem erfolgt
03:22
dann anschließend der wieder ausgerückte Part. Wenn wir das Ganze wieder mit einem negativen Wert betrachten und ausführen, sehen wir, dass der ganze Block, der dem IF folgt, nicht ausgeführt wird, aber immer der letzte Wert, die letzte Print-Anweisung, die wieder ausgerückt ist. Jetzt kann man Code
03:43
ausführen unter einer bestimmten Bedingung. Es kann aber auch sein, dass wir einen anderen Code ausführen wollen, wenn die Bedingung nicht erfüllt ist. Dafür gibt es die sogenannte Else-Clause, die eben zu dem IF gehört. Das heißt, wir sehen unser gleiches Beispiel wieder. Test mit einem eingerückten Block, der ausgeführt wird, wenn die Bedingung erfüllt ist. Oder wir haben Else,
04:07
den Else-Fall und wieder ein Block, der eingerückt ist. Das ist also das IF-Else-Bedingtes verzweigen und eins dieser beiden Zweige wird ausgeführt, je nachdem, ob die Bedingung erfüllt ist. Das letzte Statement wird wieder ausgeführt, immer unabhängig von der Bedingung. Schauen wir
04:22
uns einfach das positive Beispiel wieder als erstes an. Also zum Beispiel, wenn 1945 erfüllt ist, dann sehen wir, dass dieser Block ausgeführt ist. Das haben wir schon mehrfach gesehen. Oder wenn der negative Wert erfüllt ist, dann sehen wir eben jetzt, dass der Else-Teil ausgeführt wird. Also my value is not a positive number und dann können hier eben weitere Anweisungen folgen und so weiter.
04:45
Jetzt haben wir also die Möglichkeit, mit dem Bedingten verzweigen, Code-Blocke auszuführen unter bestimmten Bedingungen. Jetzt gibt es noch spezielle Fälle, dass wir mehr als entweder das eine oder das andere ausführen wollen. Dafür gibt es noch ein erweitertes Konstrukt, das aber so
05:02
ähnlich aufgebaut ist. Wir haben wieder das IF mit einer Bedingung. Wir haben auch ein Else-Fall und man kann jetzt aber mit Elif, das ist Else-IF, weitere Bedingungen dazwischenschalten. Zum Beispiel können wir sagen, wenn ein Wert 10 ist, also positiv, dann gebe ich positiv aus. Wenn ein Wert 0 ist, dann gebe ich auf, dass es weder positiv noch negativ ist. Oder wenn er negativ ist, dann
05:25
ist er negativ. Wenn ich das mit der positiven Zahl ausführe, sehen wir, dass der Zweig mit positiv wird ausgeführt. Wenn ich das mit der 0 ausführe, dann der Elif-Zweig. Wenn ich das mit negativen Wert ausführe, dann wird der negative Teil ausgeführt. Ein weiteres Beispiel, wo das
05:45
eben nützlich ist, dass wir eben mit IF bedingt Code ausführen können, ist wieder ein Beispiel. Ein Kaffeeautomat, der abfragt, möchte man den Kaffee mit oder ohne Milch und das berechnet dann den Preis 1 Euro für Kaffee ohne Milch und 30 Cent kommen drauf, wenn Milch gewünscht ist. Also
06:06
lesen wir hier ein, ob ein Kaffee mit Milch bestellt wird. Das führe ich hier mal aus und ich sage, ja, ich möchte Kaffee mit Milch und wir sehen, dieser IF-Teil, dieser Preis wird auf 1,30
06:20
berechnet, weil wir wieder Code bedingt ausgeführt haben. Der zweite Fall von Kontrollstrukturen ist wiederholtes Ausführen von Code. Das heißt, der gleiche Code soll mehrfach ausgeführt werden und wir sprechen hier beim Programmieren von sogenannten Schleifen. Das heißt, der Code wird immer wieder erneut durchgeführt. Dafür gibt es zwei Arten von Schleifen, auch wieder in allen
06:43
Programmiersprachen. Das eine ist eben, dass der Codeblock so lange ausgeführt wird, solange eine Bedingung erfüllt ist. Und das andere ist, dass man abgezählt mal einen Codeblock durchführen möchte. Das ist meistens dann der Fall, wenn wir eine Messreihe haben und wir wollen die ganze
07:02
Messreihe durchgehen und irgendwas mit dieser Messreihe machen, also bearbeiten. Schauen wir auf den ersten Fall, bedingte Schleifen. Das sind in Python sogenannte While-Schleifen. Das heißt, solange eine Bedingung erfüllt ist, wir haben hier einen Wert x gleich 1 und wir wollen, solange der Wert größer als 0 ist und kleiner als 500, wollen wir einen Codeblock ausführen. Und das ist hier
07:34
Doppelpunkt. Das ist dieser Codeblock die Bedingung. Der eingeräugte Block, der verdoppelt dann immer
07:41
den Wert und gibt ihn aus. Das heißt, wir fangen mit 1 an und laufen irgendwann über die 500 drüber. Und ich habe hier auch noch mal zu Demozwecken am Ende der Schleife und nach der Schleife geht es dann mit der Codeausführung weiter, also loop-finished auszugeben. So wir sehen, wenn wir mit 1 reingehen, verdoppeln wir den Wert, geben den aus. Das Ganze machen wir wiederholt mal, bis eben der Wert x
08:05
größer 500 ist und dann ist die Schleife beendet. Das können wir auch wieder nutzen für unseren Fall, dass wir eben Eingabe entgegennehmen wollen und wir können zum Beispiel sagen, ich möchte
08:22
eine Eingabe einlesen. Wenn die ungleich stopp ist, dann gebe ich die aus und frage die nächste Eingabe ab. Und das geht eben jetzt in einer Schleife so lange, bis ich als Nutzer dieses Code-Stückes stopp eingebe. So schauen wir uns das Beispiel mal an. Ich führe es aus. Ich frage eine
08:41
Eingabe ab. Ich kann irgendetwas eingeben und das, was ich eingegeben habe, wird ausgegeben, einfach wiederholt. Das Ganze wird wiederholt ausgeführt in der Weilschleife. Das heißt, ich gebe etwas Neues ein und kann das wieder ausgeben. Es wird wieder die Eingabe abgefragt.
09:00
Das geht so lange, bis die Bedingung stopp, also stopp eingegeben wird, dann ist die Schleife beendet. Es gibt sogenannte Endlosschleifen. Das habe ich eben auch schon demonstriert, dass diese ganze Schleife läuft quasi endlos, bis ein Benutzer stopp eingegeben hat. Und das
09:21
muss man mit Vorsicht machen. Ich habe hier ein Beispiel wieder, unser Kaffeeautomat. Der fragt eben ständig, wenn Benutzer an den Kaffeeautomaten gehen. Was möchtest du für einen Kaffee? Möchtest du Milch? Dann rechnen wir aus das Ganze und geben den Preis aus. Und dann soll ja der Automat wieder
09:40
bereit sein für den nächsten Nutzer. Also können wir uns überlegen, das machen wir endlos. Der Automat läuft also endlos, fragt immer ab, die Eingabe berechnet den Preis. Wenn ich das Ganze jetzt ausführe, dann kann ich eben jetzt hier eingeben, okay, ich möchte keine Milch und dann ist der Preis 1,0 oder ich möchte Milch, dann ist der Preis 1,30 und das Ganze läuft endlos. Nur kann
10:07
ich jetzt die Vorlesung nicht mehr fortsetzen, weil dieser Code endlos läuft. Das heißt, wenn sie solche Code-Stücke schreiben, die eben im Prinzip Endlosschleifen enthalten, dann müssen sie aufpassen und sie müssen immer innerhalb der Schleife auch ein Stop-Konstrukt aufnehmen. Und das
10:23
gibt es auch als Code. Ich habe jetzt hier die Ausführung in unserem Python-Notebook mit dem Stop unterbrochen, deshalb gibt es hier diese Fehlermeldung. Ich habe jetzt das gleiche Beispiel nochmal erneut aufbereitet und hier haben wir jetzt bedingt innerhalb der Weilschleife eine
10:42
Bedingung, nämlich immer dann, wenn der Benutzer Stop eingibt, dann wollen wir diese Endlosschleife unterbrechen. Das heißt, das ist jetzt zum Beispiel der Administrator des Kaffeeautomaten, der den abends runterfährt, der gibt dann Stop als Code ein. Ansonsten läuft diese Endlosschleife, solange Menschen vorbeikommen und sich Kaffee holen, dann läuft das und wenn dann der Administrator am
11:05
Ende des Tages Stop eingibt, dann kann er die Schleife beenden. So, das waren jetzt Beispiele für Schleifen, die unter bestimmter Bedingung Code-Stücke wiederholt ausführen. Und die zweite Art von Schleifen sind Zielschleifen, die gibt es in Python in der Form sogenannter For-Loops.
11:25
Dabei gibt es auch wieder zwei Möglichkeiten, entweder man möchte eine bestimmte Anzahl von Wiederholungen durchlaufen, also ein Code-Stück zehnmal absolvieren, also durchführen, oder was die häufigere Form der Anwendung von For-Schleifen ist, man hat eine Datenstruktur, zum Beispiel eine
11:44
Messreihe und man möchte jetzt alle Werte dieser Messreihe bearbeiten, irgendwie noch etwas damit berechnen oder die ganzen visualisieren. Man will also jeden Wert durchgehen und das heißt, zwar auch eine bestimmte Anzahl, nämlich die Anzahl der Elemente der Datenstruktur. Jetzt haben
12:03
wir bisher noch keine Datenstrukturen kennengelernt. Insofern kann ich das Beispiel für diese zweite Art am Beispiel der Datenstruktur oder des Datentyps String demonstrieren, denn ein String ist nichts anderes als eine Aneinanderreihung einzelner Buchstaben. Die For-Schleife, die also eine
12:24
Datenstruktur durchgeht und einzeln bearbeitet, sieht so aus, ich habe das Schlüsselwort For, dann definiere ich mir hier eine Variable, die ich dann innerhalb des Code-Blocks der For-Schleife verwenden kann und ich sage, welche Datenstruktur ich bearbeiten möchte. In dem Fall
12:43
steht die in der Variable in X, das heißt, For letter in X, wieder das Doppelpunkt, um diese Kontrollstruktur einzuleiten und einen eingerückten Block zu haben. Und alles, was ich jetzt in diesem Teil mache, ist ausgeben. Das heißt, ich gehe der Reihe nach durch den String durch. Die Variable
13:03
letter wird in jedem Schleifendurchlauf einzeln gesetzt, beim ersten Mal auf das E, beim zweiten Mal auf das X und so weiter. Ich gebe das in diesem Fall, in diesem Demo einfach kurz aus. Das heißt, wir haben jetzt hier eine wiederholtes Print durchgeführt für alle Elemente, alle einzelnen
13:20
Buchstaben in dieser Zeichenfolge. Die zweite Art sind Zählschleifen, die eben eine bestimmte Anzahl durchlaufen. Das geht am einfachsten zu organisieren in Python dadurch, dass ich mir hier durch eine Funktion, die range heißt, auch eine Datenstruktur erzeuge, die einfach abzählt von 1 bis 12 die
13:45
Zahlen, also 1, 2, 3, bis genau genommen 11. Das heißt, 12 ist der erste Wert, der nicht mehr Teil dieser Folge ist. Range erzeugt also eine Folge von Zahlen. In dem Fall also laufe ich von 1 bis
14:01
11 durch. Das heißt, das können wir uns vorstellen, dass der Schiedsrichter am Anfang des Fußballspiels abzählt, ob tatsächlich 11 Spieler auf dem Spielfeld stehen oder was manchmal vorkommt, auch 12 oder sowas in der Richtung. Hier gehen wir also durch. Range liefert die Zahlen 1 bis 11. Auch hier haben wir wieder die Variable i definiert, die in jedem Schleifen durchlaufen wird. Die
14:34
oder in beliebiger Richtung erzeugt werden können, von einem Anfangswert bis zu einem Endwert in
14:41
einer bestimmten Schrittweite. Wir können also zum Beispiel auch von 3 bis 0 mit der Schrittweite minus 1 das Ganze durchlaufen und ausgeben i Komma und am Ende nach der Schleife Mainz. Das würde also 3, 2, 1 runter zählen und dann 3, 2, 1 Mainz ausgeben. Wir können jetzt hier zum Beispiel mal
15:05
einen größeren Wert nehmen und wir laufen bis minus 10, aber wir nehmen auch eine größere Schrittweise, zum Beispiel minus 11 und wir sehen, dass dann eben entsprechend die Zahlen durchlaufen werden. Das heißt, hier kann man immer Anfangswert bis zu einem Wert, der erreicht wird, mit einer
15:27
Schleife. Damit haben wir in dieser Session kennengelernt die dritten Grundbausteine fürs Programmieren, nämlich Kontrollstrukturen. Kontrollstrukturen haben immer Auswertung einer Bedingung und dann eingerückt als Code-Blöcke entweder bedingt auszuführen mit if oder else
15:47
oder eben wiederholt auszuführen unter einer Bedingung, die Weilschleife oder mit einer Anzahl innerhalb von vor und das bringt uns dann auch zur nächsten Session, die wir eben separat
16:01
betrachten. Das sind dann die Datenstrukturen und die werden häufig eben mit Vorschleifen systematisch abgearbeitet.
Empfehlungen
Serie mit 17 Medien