Bedingte Anweisungen sind Befehle, welche dann ausgeführt werden, wenn eine gewisse Bedingung erfüllt ist.
Inhaltsverzeichnis
Einordnung
Kursblog L8T1: bedingte Anweisungen
Dieser Blog wird vom IAIP gratis zur Verfügung gestellt. Der Blog ist ein Bestandteil des Kurses K103 «Programmieren mit Turtle Graphics» und gehört zur Lektion 8, Themenblock 1 (L8T1).
Der Kurs führt dich durch die einzelnen Blogs, enthält Zusatzmaterialien und Quizze zur Lernkontrolle. Der Kurs hat eine Kursgebühr von CHF 50.- Mit dem Einschreiben zum Kurs hilfst du mit, dass solche Blogs auch zukünftig noch gratis zur Verfügung gestellt werden können.
Rückblick
Normalerweise wird in einem Programm eine Zeile nach der anderen, von oben nach unten, abgearbeitet. Das Programm beginnt bei der obersten Zeile und ist bei der letzten Zeile fertig. Wollen wir eine Figur zeichnen, dann geben wir dem Computer Schritt für Schritt Anweisungen, wie er diese Figur zu zeichnen hat. In den Lektionen 1-6 haben wir zahlreiche solche Programme kennengelernt und geschrieben (Programmstruktur: Sequenz).
Wir haben ebenfalls bereits erwähnt, dass es beim Programmieren sogenannte Kontrollstrukturen gibt. Kontrollstrukturen erlauben es, den Ablauf der Anweisungen zu kontrollieren. Im letzten Kapitel (Lektion 7) haben wir die for Schleife kennengelernt. Dank solcher Schleifen können wir Anweisungen mehrmals ausführen lassen (Programmstruktur: Iteration).
In dieser Lektion liegt der Schwerpunkt nun bei bedingten Anweisungen und Verzweigungen. Dabei handelt es sich um andere Form von Kontrollstrukturen. Hier werden Anweisungen nicht wiederholt, sondern selektiv ausgeführt (Programmstruktur: Selektion).
Schwerpunkte
- allgemeine Syntax und Funktionsweise bedingter Anweisungen (if- Anweisungen)
- Unterscheidung zwischen Vergleich == und Zuweisung =
- Strukturierung über Einschübe (Identation)
- Flussdiagramm und Struktogramm
Bedingte Anweisungen mit if realisieren
Einführendes Beispiel
Du wirst kaum ein sinnvolles Programm schreiben können, welches ohne jede Art von Bedingungen auskommt. In der Regel hat jedes Programm haufenweise Anweisungen, welche nur in gewissen Situationen, d.h. unter gewissen Bedingungen, ausgeführt werden sollen. Solche «bedingte Anweisungen» gehören gewissermassen zum 1×1 jeder Programmiersprache. Denn ansonsten würde das Programm jedes Mal exakt dasselbe machen. Schauen wir uns ein kleines Beispiel an:
from turtle import *
frage = textinput("Frage", "Möchtest Du ein Viereck zeichnen?")
if frage == "ja":
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
exitonclick() Das Programm fragt unseren User, ob er ein Viereck zeichnen möchte. Seine Eingabe wird in der Variable frage abgelegt. Schreibt der User «ja», dann (und nur dann) zeichnet das Programm anschliessend ein Viereck. Gibt er etwas anderes ein, dann passiert nichts.
Im Programm sind 2 Sachen von besonderer Bedeutung:
- Wir haben nicht mehr eine (klassische) sequentielle Programmstruktur, in welcher immer alle Anweisungen der Reihe nach ausgeführt werden. Vielmehr werden neu gewisse Anweisungen nur manchmal ausgeführt. Nämlich genau dann, wenn eine Bedingung erfüllt ist. In unserem Beispiel wird das Viereck nur dann gezeichnet, wenn der Benutzer "ja" eingegeben hat.
- Gewisse Anweisungen (Zeilen 6-13) sind im Code etwas eingerückt! Wir haben ein zusätzliches "Strukturelement". Über das Einschieben gewisser Anweisungen können wir dem Computer mitteilen, welche Anweisungen zu der jeweiligen Bedingung gehören. In unserem Beispiel sind es die Anweisungen, welche man zum Zeichnen für das Quadrat benötigt.
Syntax bedingter Anweisungen
Bedingte Anweisungen sind also Befehle, welche dann ausgeführt werden, wenn eine gewisse Bedingung erfüllt ist. Solche Strukturen werden in den meisten Programmiersprachen durch die if Anweisung umgesetzt. Das Wort «if» stammt aus dem Englischen und bedeutet zu Deutsch «wenn» bzw. «falls».
Die Syntax einer bedingten Anweisung in Python ist wie folgt:
if Bedingung:
Anweisung 1
Anweisung 2
Anweisung 3
Unsere if Anweisung (in der Fachsprache spricht man von einem zusammengesetzten Kommando) besteht aus 3 Teilen:
- Sie beginnt mit dem Schlüsselwort if. Das Schlüsselwort sagt dem Computer, dass es sich bei den nachfolgenden Befehlen um bedingte Anweisungen handelt. Also Anweisungen, die nur ausgeführt werden, falls eine Bedingung erfüllt ist.
- Direkt anschliessend folgt die Bedingung, welche der Computer überprüfen soll. Diese wird ausgewertet, und falls sie erfüllt ist (und nur dann) wird ein spezieller Codeabschnitt ausgeführt. In unserem Beispiel soll das Quadrat ja nur gezeichnet werden, wenn der Benutzer «ja» im Eingabefeld eingegeben hat.
Diese ersten zwei Teile bezeichnet man auch als Kopf des Kommandos. Der Kopf endet in Python mit einem Doppelpunkt! In unserem Beispielprogramm ist der Kopf if frage == «ja»:
- Der eingeschobene Rumpf (Codeabschnitt) seinerseits kann aus einer oder mehreren Anweisungen bestehen. Diese sind die eigentlichen (bedingten) Anweisungen. Die Anweisungen sind eingerückt, und in der Regel steht pro Programmzeile eine Anweisung. Theoretisch könnt man auch mehrere Kommandos auf eine Zeile schreiben, sofern man diese durch Semikolons (Strichpunkte) trennt. Es ist aber eher unübersichtlich und wird deshalb nicht empfohlen.
Merke dir:
- In der Bedingung hat es immer ein doppeltes == Zeichen! In Python schreibt man == , wenn zwei Sachen miteinander verglichen werden sollen. Hat man nur ein einfaches =, so handelt es sich um eine Zuweisung! Zugewiesen werden Werte (Objekte) zu Variablen (Namen), also beispielsweise a = 3 oder antwort = "ja". In der Bedingung wollen wir aber nicht der Variable frage den Wert "ja" zuweisen, sondern vielmehr überprüfen, ob die Variable frage den Wert "ja" hat.
- Python vergleicht exakt. Die Anweisungen werden nur ausgeführt, wenn der User auch wirklich ja eingibt. Schreibt er Ja ins Eingabefeld, so passiert nichts. Gross- und Kleinschreibung sind nicht identisch.
- Am Ende der Kopfzeile steht immer ein Doppelpunkt. Wir haben dies schon bei der for Schleife gesehen.
- Die (bedingten) Anweisungen sind immer gleich viel eingerückt.
- Löse jetzt die Aufgabe 1
Einrücken der bedingten Anweisungen (Identation)
Das Konzept der eingerückten Anweisungen haben wir bereits bei der for Schleife kennengelernt. Nur so kann Python wissen, welche Anweisungen zum Kopf gehören. Soll heissen: nur so kann Python wissen, was genau zu machen ist, wenn die Bedingung erfüllt ist.
Weil das Einrücken von Zeilen gerade zu Beginn vielen Kopfzerbrechen bereitet, nachfolgend nochmals ein Beispiel:
from turtle import *
frage = textinput("Frage", "Punkt setzen?")
forward(100)
if frage == "ja":
dot(10)
right(90)
forward(50)
exitonclick() Studiere das Programm sorgfältig! Im Beispiel ist nur eine Zeile (Zeile 7) eingerückt. Die der if Anweisungen vorangehende Zeile mit der Anweisung forward(100) sowie die nachfolgenden zwei Anweisungen right(90) und forward(50) werden in jedem Fall ausgeführt.
from turtle import *
frage = textinput("Frage", "Punkt setzen?")
forward(100)
if frage == "ja":
dot(10)
right(90)
forward(50)
exitonclick() Was ist der Unterschied? Probiere es selber aus! Gibt der Benutzer jetzt beispielsweise «nein» ein, so zeichnet das Programm lediglich einen geraden Strich mit der Länge 150 (einen Strich mit 100 und einen direkt anschliessenden Strich mit 50, ohne Ecken).
Gerade anfangs muss man beachten, dass die eingeschobenen Anweisungen immer gleich viel eingeschoben sind. Die nachfolgende Bedingung führt beispielsweise zu einer Fehlermeldung.
if frage == "ja":
dot(10)
right(90)
forward(50)
Zur Strukturierung der Anweisungen wird in Python also die Zeile eingerückt. Zusammengehörige Anweisungen sind immer gleich viel eingerückt. Es ist somit nicht wichtig, wie viele Zeichen eine Anweisung nun effektiv eingerückt ist. Leistungsfähige Editoren erkennen gewisse Schlüsselwörter und machen automatisch einen Vorschlag.
Andere Programmiersprachen verwenden andere Methoden zur Strukturierung des Codes. Beispielsweise geschweifte Klammern oder spezielle Schlüsselwörter (beispielsweise BEGIN und END). Dank dieser Methoden weiss dann der Interpreter, welche Anweisungen zusammengehören. Um im Code einfacher den Überblick zu behalten, rücken die meisten Programmierer trotz dieser Schlüsselwörter oder Klammern zusätzlich die Zeilen noch ein. Dort geht es aber dann lediglich um den optischen Eindruck (also nicht wie in Python).
Theoretisch könnte man auch mehrere Kommandos auf eine Zeile schreiben, sofern man diese durch Semikolons (Strichpunkte) trennt. Das gehört aber nicht zu einem guten Programmierstil und sollte deshalb nicht gemacht werden. Wichtig dabei ist, dass man dann auch alle bedingten Anweisungen durch Strichpunkte getrennt hinter die Kopfzeile schreibt.
if Bedingung: Anweisung 1; Anweisung 2; Anweisung 3
Man kann also nicht einen Teil der bedingten Anweisungen mit Strichpunkten schreiben, und einen zweiten Teil desselben Codeblocks eingeschoben auf die Folgezeilen notieren.
if Bedingung: Anweisung 1; Anweisung 2;
Anweisung 3
In der Praxis kommt dieser Programmierstil (Anweisung direkt in Kopfzeile) vor allem zum Einsatz, wenn man nur eine einzelne Anweisung hat.
Mehrere bedingte Anweisungen
Und selbstverständlich kann man beliebig viele Blöcke mit bedingten Anweisungen in einem Programm haben. Wir können beispielsweise unser Programm erweitern. Nachfolgend soll das Programm einen besonders grossen Punkt setzen, wenn der Benutzer «Ja» (mit einem grossen Anfangsbuchstaben!) eingegeben hat.
from turtle import *
frage = textinput("Frage", "Punkt setzen?")
forward(100)
if frage == "ja":
dot(10)
if frage == "Ja":
dot(30)
right(90)
forward(50)
exitonclick() Möchten wir, dass die Anweisung right(90) wiederum ebenfalls zum Rumpf gehört, dann können wir diese wie gezeigt einschieben. Zu beachten ist hier lediglich, dass wir die Anweisung 2x schreiben müssen. Da die Anweisung neu zu einem bedingten Codeblock gehört, muss diese natürlich in beiden eingeschobenen, bedingten Codeblöcken vorkommen.
from turtle import *
frage = textinput("Frage", "Punkt setzen?")
forward(100)
if frage == "ja":
dot(10)
right(90)
if frage == "Ja":
dot(30)
right(90)
forward(50)
exitonclick() Das Programm führt zu folgender Ausgabe:
- Löse jetzt die Aufgaben 2 und 3
Äpfel mit Äpfel vergleichen (Datentypen)
Ein zweiter Punkt, welcher Anfangs immer wieder Kopfzerbrechen bereitet, ist die Vergleichbarkeit der Objekte. Wenn wir die Bedingung nach dem if Schlüsselwort formulieren, dann vergleichen wir jeweils 2 Sachen miteinander. Also beispielsweise den Inhalt der Variable frage mit dem Wort «ja». Damit Python diese 2 Sachen (Objekte) vergleichen kann, müssen sie vom selben (Daten-) Typ sein. Das ist wie im richtigen Leben auch: wir können nur Äpfel mit Äpfel vergleichen, und nicht etwa Äpfel mit Häusern.
Wir haben bereits mehrfach erwähnt, dass Zeichenfolgen (Texte, Sätze, aber auch einzelne Buchstaben oder Zeichen) in Python von Zahlen zu unterschieden sind. Zeichenfolgen sind vom Datentyp str, wohingegen Zahlen vom Datentyp int (Ganzzahlen) oder float (Kommazahlen) sind. Zeichenfolgen werden in einfache ‹ ‹ oder doppelte » » Anführungs- und Schlusszeichen gepackt, bei Zahlen fehlen solche. Für Python ist diese Unterscheidung wichtig. Je nachdem, was man hat, «rechnet» der Computer dann auch anders. So ist in Python 2 * 2 = 4 und 2 * «2» = «22». Diese wichtige Unterscheidung ist nun auch bei der Bedingung von Bedeutung.
Hierzu wiederum ein Beispiel. Das folgende Programm zeichnet ein regelmässiges Fünfeck, wobei der User am Anfang nach der Seitenlänge gefragt wird. Wir verwenden hierzu die Eingabeanweisung numinput(), welche im Unterschied zu textinput() ja Zahlen zurückgibt. Speziell dabei soll sein, dass eine Eingabe von 0 auf 10 korrigiert wird.
from turtle import *
ecken = 5
dist = numinput("Distanz", "Bitte Distanz eingeben")
if dist == 0:
dist = 10
for i in range(ecken):
forward(dist)
left(360/ecken)
exitonclick() Für uns an dieser Stelle interessant ist die Bedingung dist == 0 in Zeile 6. Da es sich bei der Variable dist um eine Zahl handelt (genauer: um ein Objekt vom Typ float), müssen wir die Variable dist auch mit einer Zahl (hier 0) vergleichen. Wir können hier also nicht dist == «0» schreiben! In Python ist der direkte Vergleich mit == zwischen einer Zahl und einer Zeichenfolge zwar zulässig, aber als Resultat bekommt man False.
In Zeile 6 und Zeile 7 des vorangehenden Programms sieht man nochmals den Unterschied zwischen einem Vergleich (==) und einer Zuweisung (=) gut.
- Löse jetzt die Aufgaben 4 und 5
Verglichen werden immer 2 Objekte.
objekt1 == objekt 2
In unserem vorangehenden Beispiel in Zeile 6 ist das Objekt 1 die Variable dist mit der Eingabe des Benutzers, und das Objekt 2 ist die Zahl im Programm, sprich 0. Die zu vergleichenden Objekte müssen theoretisch vom gleichen Datentyp sein.
Die Anweisung numinput() liefert eine Zahl (ein Objekt) vom Datentyp float zurück. Das sind (Gleit-) Kommazahlen. In diesem Sinne ist der Vergleich dist == 0 deshalb nicht wirklich «erlaubt», da er die Variable (das Objekt vom Typ float) mit der Ganzzahl 0 vergleicht. Ganzzahlen haben einen anderen Datentyp, namentlich int. Python ist hier aber etwas flexibel und lässt solche Vergleiche zu.
Korrekterweise müsst man allerdings schreiben: dist == 0.0
Eine Alternative besteht darin, dass wir eines der Objekt umwandeln. Hierzu können wir die Umwandlungsfunktionen str(), int() und float() verwenden. Beispielsweise so: int(dist) == 0
Und natürlich können wir so auch eine Texteingabe umwandeln
from turtle import *
ecken = 5
text = textinput("Distanz", "Bitte Distanz eingeben")
dist = int(text)
if dist == 0:
dist = 10
for i in range(ecken):
forward(dist)
left(360/ecken)
exitonclick() - Löse jetzt die Aufgabe 6
Struktogramm und Flussdiagramm (ergänzende Informationen)
Manchmal ist es hilfreich, die Funktionsweise bedingter Anweisungen ganz abstrakt anhand eines sog. Struktogramms oder eines Flussdiagramms darzustellen. Solche Struktogramme und Flussdiagramme sind bekannte Hilfsmittel bei der Entwicklung von Algorithmen. Sie haben aber auch einen hohen didaktischen Wert, insbesondere wenn es darum geht, die Funktionsweise von Kontrollstrukturen (bedingte Anweisungen, Verzweigungen, Schleifen) zu illustrieren.
Das Struktogramm (links) bzw. Flussdiagramm (rechts) einer bedingten Anweisung ist nachfolgend dargestellt.
Wie sie genau funktionieren, soll anhand eines kleinen Beispiels demonstriert werden.
Flussdiagramm und Struktogramm ohne bedingte Anweisungen
Als erstes betrachten wir ein Programm ohne bedingte Anweisungen. Wir sprechen also von der klassischen sequentiellen Programmstruktur, in welcher eine Anweisung nach der anderen der Reihe nach abgearbeitet wird.
from turtle import *
zustand = textinput("Zustand", "Wie geht es dir heute?")
penup()
hideturtle()
# ....
goto(0, -20)
write("Ende")
exitonclick()
Wir können das Programm ohne grossen Aufwand in einem Flussdiagramm darstellen.
Solche Flussdiagramme lesen sich ganz einfach. Begonnen wird oben beim Punkt Start (Start-«Knoten»). Dann folgt man den Pfeilen bis zum Ende (Ende – «Knoten»). Jede Box im Bild entspricht einer auszuführenden Anweisung (einem Lösungsschritt), wobei man den Pfeilen folgend die einzelnen Schritte (die in den Boxen enthaltenen Anweisungen) ausführt.
Das Struktogramm sieht hier ganz ähnlich aus. Im Unterschied zum Flussdiagramm verzichtet man einfach auf die verbindenden Pfeile. Jede Box im Bild entspricht einer auszuführenden Anweisung (einem Lösungsschritt), wobei man wiederum von oben nach unten der Reihe nach die Instruktionen ausführt.
Links im Bild ist ein Struktogramm, in welchem der Programmcode zur Veranschaulichung wiederum direkt eingesetzt wurde. Rechts im Bild eine alternative Darstellung mit einer etwas allgemeineren Beschreibung der auszuführenden Anweisungen. Im Normalfall würde man in einem Flussdiagramm oder Struktogramm nämlich nicht 1:1 den Programmcode einsetzen, sondern vielmehr eine vereinfachte Beschreibung nutzen. Das reicht in aller Regel völlig aus (insbesondere für den Zweck der Darstellung eines Algorithmus – welcher dann noch weitgehend unabhängig der effektiv verwendeten Programmiersprache ist).
Flussdiagramm und Struktogramm mit bedingte Anweisungen
Wir ergänzen jetzt unser Programm um einen Block mit bedingten Anweisungen. Das Programm soll auf den Bildschirm «Das freut mich. Mir geht es auch gut» schreiben, falls der Benutzer «gut» eingegeben hat.
from turtle import *
zustand = textinput("Zustand", "Wie geht es dir heute?")
penup()
hideturtle()
if zustand == "gut":
write("Das freut mich. ", move=True)
write("Mir geht es auch gut!")
goto(0, -20)
write("Ende")
exitonclick()
Ergänzt wurden also die Zeilen 7-9. Übersetzen wir als erstes unser Programm in ein Flussdiagramm:
Flussdiagramme sind einfach verständlich. Man braucht nur den Pfeilen zu folgen. Speziell bei unserer Darstellung ist, dass die Kopfzeile unserer Bedingung (Zeile 7 im Programm) nicht in eine gewöhnlichen Box, sondern in eine Raute (gekipptes Viereck) geschrieben wird. Das hat den Vorteil, dass man relativ einfach 2 davon abgehende Pfeile zeichnen kann. Wie bereits erklärt kann unsere Bedingung entweder wahr (True) oder falsch (False) sein. Der nach rechts gehende Pfeil zeichnet den Weg, falls die Bedingung falsch ist. Der direkt nach unten gehende Pfeil steht für den Fall, dass die Bedingung wahr ist (der Benutzer hat «gut» eingegeben).
Wir können unser Programm auch in einem Struktogramm abbilden. Da es jedoch im Struktogramm keine Pfeile gibt, benötigen wir eine leicht andere Darstellungsweise. Das Struktogramm nutzt ein sogenanntes «Decision Symbol». Im Wesentlichen packt man einfach den ganzen bedingten Anweisungsblock in eine «Box». Oben schreibt man die Bedingung hin (im Dreieck), anschliessend teilt sich die Box in 2 Spalten auf.
Ist die Bedingung zutreffend (wahr), so wird der linke Anweisungsblock (die linke Spalte) durchlaufen. Trifft die Bedingung nicht zu (falsch), wird der Durchlauf ohne eine weitere Anweisung fortgeführt (Austritt unten). Der linke Anweisungsblock (Bedingung ist wahr) kann natürlich aus einer oder auch mehreren Anweisungen bestehen. Im Beispiel sind es 2 Anweisungen. Die grüne Markierung im Bild dient hier lediglich zur Hilfestellung. Normalerweise werden Struktogramme ohne spezielle Farbmarkierungen dargestellt.
Ein erweitertes Beispiel
Wie erläutert können bedingte Anweisungen an einer beliebiger Stelle und beliebig oft im Programm vorkommen. Zur letzten Veranschaulichung des Struktogramms und des Flussdiagramms innerhalb dieses Blogbeitrags wollen wir unser Programm um einen zweiten Block erweitern
from turtle import *
zustand = textinput("Zustand", "Wie geht es dir heute?")
penup()
hideturtle()
if zustand == "gut":
write("Das freut mich. ", move=True)
write("Mir geht es auch gut!")
if zustand == "schlecht":
write("Tut mir aber leid.")
goto(0, -20)
write("Ende")
exitonclick()
Übersetzen wir das Programm, so ergeben sich folgende 2 Diagramme:
- Skizziere nun für die Aufgaben 1 & 2 jeweils ein Flussdiagramm bzw. ein Struktogramm
Übungsaufgaben
Nachfolgend findest du ausgewählte Übungsaufgaben.
Aufgabe 1: Sesam öffne dich
Erstelle ein Programm, welches den User zur Eingabe eines Passworts auffordert. Nutze hierzu die textinput() Anweisung. Du kannst den Titel und die Frage frei wählen. Entspricht die Eingabe der Zeichenfolge «Sesam öffne dich», so erfolgt die Ausgabe «Das Passwort ist korrekt»
Ergänze das Programm weiter. Beispielsweise soll der Computer dein Haus oder eine andere schöne Figur aus den ersten Lektionen zeichnen, sofern das Passwort korrekt ist.
Hinweis: Beachte die Details: Am Ende der Kopfzeile einen Doppelpunkt, bedingte Anweisungen gleich viel einrücken.
Aufgabe 2: Figur nach Wunsch
Unser Programm fragt als erstes den Benutzer, was gezeichnet werden soll. Anschliessend wird noch die Grösse der Figur abgefragt. Hat der Benutzer «Viereck» eingegeben, so wird ein Viereck in der gewünschten Grösse gezeichnet. Hat er «Kreis» eingegeben, so wird ein Kreis in der gewünschten Grösse gezeichnet.
Hinweis: Schreibe einfach 2x einen bedingte Anweisungsblock. Ein if Anweisung (mit zugehörigem Rumpf) für das Viereck, und anschliessend eine if Anweisung (mit zugehörigem Rumpf) für den Kreis.
Aufgabe 3: ausgefüllte Figur
Unser Programm fragt als erstes den Benutzer, ob die nachfolgende Figur ausgefüllt werden soll. Anschliessend wird ein Kreis gezeichnet. Hat der Benutzer «ja» eingegeben, so wird der Kreis gelb ausgefüllt.
Hinweis: Die 2 Anweisungen begin_fill() und end_fill() sollen nur ausgeführt werden, wenn der Kreis ausgefüllt werden muss.
Aufgabe 4: Zuweisung oder Vergleich
Bei welchen der rechts abgebildeten Ausdrücken handelt es sich um eine Zuweisung, bei welchen um einen Vergleich.
| a = 5 |
| a == 7 |
| 5 == 7 |
| c = «Haus» |
| c == «Baum» |
| «c» == «Baum» |
Aufgabe 5: Datentypen
Gegeben sind folgende Werte:
a = 5
b = 7
c = «Baum»
d = «5»
Gib an, ob die rechts stehenden 9 Vergleiche jeweils zulässig/ nicht zulässig und falls zulässig wahr bzw. falsch sind. Falls sie nicht zulässig sind, begründe weshalb dies so ist.
if Bedingung :
| a == b |
| a == 7 |
| b == 7 |
| c == «Haus» |
| c == «Baum» |
| c == «baum» |
| c == Sesam |
| b == c |
| d == c |
Aufgabe 6: Datentypen mit Umwandlung
Gegeben sind folgende Werte:
a = 5.2
b = 7
c = «aa»
d = «55»
Gib an, ob die rechts stehenden 9 Vergleiche jeweils zulässig/ nicht zulässig und falls zulässig wahr bzw. falsch sind. Falls sie nicht zulässig sind, begründe weshalb dies so ist.
| a == 7.8934 |
| a == 7 |
| b == a + 1.80 |
| a == int(d) |
| int(d) == b |
| float(b) == d |
| str(a) == d |
| str(b) == c |
| 2*str(int(a)) == d |
Lösungen zu den Übungsaufgaben
Lösung zur Aufgabe 1: Sesam öffne dich
Nachfolgend findest du das Programmbeispiel:
from turtle import *
passwort = textinput("Access", "Bitte Passwort eingeben")
if passwort == "Sesam öffne dich":
write("Das Passwort ist korrekt")
exitonclick()
Hinweis: Beachte insbesondere das Vergleichszeichen ==, den Doppelpunkt am Ende der Kopfzeile sowie die eingerückte bedingte Anweisung.
Zusatzaufgabe Struktogramm & Flussdiagramm
Nachfolgend findest du das Struktogramm (links) und das Flussdiagramm (rechts) zum Programm. Wir haben zur Illustration in jede Box den Code 1:1 eingetragen.
Lösung zur Aufgabe 2: Figur nach Wunsch
Nachfolgend findest du das Programmbeispiel:
from turtle import *
fig = textinput("Figur", "Was soll gezeichnet werden")
g = numinput("Grösse", "Welche Grösse")
if fig == "Viereck":
forward(g)
right(90)
forward(g)
right(90)
forward(g)
home()
if fig == "Kreis":
circle(g)
exitonclick()
Hinweis: Gehören mehrere Anweisungen zum Rumpf einer if- Anweisung, so sind diese immer genau gleich viel eingerückt (siehe Zeilen 7-12). Selbstverständlich kann man für jeden Block selber definieren, wie viel man die Anweisungen einrücken möchte. Die nachfolgende Lösung funktioniert in diesem Sinne ebenfalls. Man sollte sich jedoch angewöhnen, möglichst immer gleich viel einzurücken.
from turtle import *
fig = textinput("Figur", "Was soll gezeichnet werden")
g = numinput("Grösse", "Welche Grösse")
if fig == "Viereck":
forward(g)
right(90)
forward(g)
right(90)
forward(g)
home()
if fig == "Kreis":
circle(g)
exitonclick()
Zusatzaufgabe Struktogramm & Flussdiagramm
Im nachfolgenden Struktogramm (links) und das Flussdiagramm (rechts) zum Programm haben wir anstelle des Codes «allgemeine» Begriffe verwendet. Wie erwähnt zeichnet man Struktogramme und Flussdiagramme in der Regel nicht mit einer 1:1 Wiedergabe der Anweisungen. Vielmehr sollen sie das allgemeine Prinzip bzw. die allgemeine Problemlösung (den sog. Algorithmus) darstellen. Entwickler, Designer, Forscher etc. skizzieren ihre Idee im Struktogramm, so dass spezialisierte Programmierer die Problemlösung in einer spezifischen Programmiersprache umsetzen können.
Lösung zur Aufgabe 3: ausgefüllte Figur
Nachfolgend findest du das Programmbeispiel:
from turtle import *
ausf = textinput("Grafik", "Soll der Kreis ausgefüllt werden?")
if ausf == "ja":
begin_fill()
fillcolor("yellow")
pencolor("black")
circle(100)
if ausf == "ja":
end_fill()
exitonclick()
Lösung zur Aufgabe 4: Zuweisung oder Vergleich
| a = 5 | Zuweisung der Ganzzahl 5 zur Variable (zum Namen) a |
| a == 7 | Vergleich der Variable a (des Objekts, auf welches der Name a verweist) mit der Ganzzahl 7 |
| 5 == 7 | Vergleich der Ganzzahl 5 mit der Ganzzahl 7 |
| c = «Haus» | Zuweisung der Zeichenkette «Haus» zur Variable (zum Namen) c |
| c == «Baum» | Vergleich der Variable c (des Objekts, auf welches der Name c verweist) mit der Zeichenkette «Baum» |
| «c» == «Baum» | Vergleich der Zeichenketten «c» und «Baum» |
Lösung zur Aufgabe 5: Datentypen
Gegeben ist:
| a = 5 | Zuweisung der Ganzzahl 5 | Datentyp: int |
| b = 7 | Zuweisung der Ganzzahl 7 | Datentyp: int |
| c = «Baum» | Zuweisung der Zeichenkette «Baum» | Datentyp: str |
| d = «5» | Zuweisung der Zeichenkette «5» | Datentyp: str |
Gesuchte Vergleiche mit Kommentaren:
| a == b | zulässig Wert: False |
5 ist kleiner als 7 |
| a == 7 | zulässig Wert: False |
a ist 5, deshalb falsch. |
| b == 7 | zulässig Wert: True |
b ist 7, deshalb wahr. |
| c == «Haus» | zulässig Wert: False |
«Baum» ist nicht gleich «Haus» |
| c == «Baum» | zulässig Wert: True |
c ist «Baum», deshalb gleich. |
| c == «baum» | zulässig Wert: False |
c ist «Baum». Beginnt mit einem grossen «B». |
| c == Sesam | #Fehler | Entweder Sesam ist eine Zeichenkette, dann fehlen hier «». Oder ein Name. Dieser wurde aber oben nicht definiert (es gab keine Zuweisung der Form Sesam = «…» |
| b == c | zulässig Wert: False |
Vergleich von einer Ganzzahl mit einer Zeichenkette ist in Python zulässig. |
| d == c | zulässig Wert: False |
d ist hier ebenfalls eine Zeichenkette (und keine Zahl!), weshalb der Vergleich möglich ist. |
Lösung zur Aufgabe 6: Datentypen mit Umwandlung
Gegeben ist:
| a = 5.2 | Zuweisung der Gleitkommazahl 5.2 zum Namen a | Datentyp: float |
| b = 7 | Zuweisung der Ganzzahl 7 zum Namen b | Datentyp: int |
| c = «7» | Zuweisung der Zeichenkette «7» zum Namen c | Datentyp: str |
| d = «55» | Zuweisung der Zeichenkette «55» zum Namen d | Datentyp: str |
Gesuchte Vergleiche mit Kommentaren:
| a == 7.8934 | False | Vergleich float mit float ist zulässig. Die 2 Gleitkommazahlen sind aber nicht identisch. |
| a == 7 | False | Vergleich float mit int ist zulässig. a ist 5.2 und nicht 7 bzw. 7.0 |
| b == a + 1.80 | True | Vergleich int mit float (5.2 + 1.80 = 7.00) ist zulässig. b ist 7 bzw. als float 7.00 |
| a == int(d) | False | Vergleich float mit int ist zulässig. Umwandlung von «55» zur Ganzzahl ergibt 55 |
| int(d) == b | True | Vergleich int mit int ist zulässig. Umwandlung von «55» zur Ganzzahl ergibt 55 und nicht 7. |
| float(b) == d | False | Vergleich von float mit str ist in Python zulässig. |
| str(a) == d | False | Vergleich von str mit str ist zulässig. Umwandlung ergibt aber «5.2» und nicht «55» |
| str(b) == c | True | Vergleich von str mit str ist zulässig. Umwandlung ergibt aber «7». Identisch zu «7» |
| 2*str(int(a)) == d | True | Vergleich von str mit str ist zulässig. |
Comments