K103: bedingte Anweisungen

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:

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:

  1. 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.
  2. 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»:

  1. 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:

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.

Wir können zur Veranschaulichung auch noch Zeile 8 einrücken. Das Programm sieht dann wie folgt aus:
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)
Ergänzende Informationen für fortgeschrittene Kursteilnehmer:

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:

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

Ergänzende Informationen für fortgeschrittene Kursteilnehmer:

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()

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:

Ü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