Python - Konzepte imperativer Programmierung

1. Python-Konzepte imperativer Programmierung Klaus Becker 2009

2. Python

3. Teil 0 Vorbemerkungen zu Python

4. Entwicklungsgeschichte Die Sprache wurde Anfang der 1990er Jahre von Guido van Rossum am Centrum voor Wiskunde en Informatica (Zentrum für Mathematik und Informatik) in Amsterdam als Nachfolger für die Programmier-Lehrsprache ABC entwickelt, ursprünglich für das verteilte Betriebssystem Amoeba. Alle bisherigen Implementierungen der Sprache übersetzen den Text eines Python-Programms transparent in einen Zwischencode, der dann von einem Interpreter ausgeführt wird. Der Name geht nicht etwa (wie das Logo vermuten ließe) auf die gleichnamige Schlangengattung Pythons zurück, sondern bezog sich ursprünglich auf die englische Komikertruppe Monty Python. In der Dokumentation finden sich daher auch einige Anspielungen auf Sketche aus dem Flying Circus. Trotzdem etablierte sich die Assoziation zur Schlange, was sich u. a. in der Programmiersprache Cobra sowie dem Python Toolkit „Boa“ äußert. Quelle: Wikipedia

5. Ziele Python wurde mit dem Ziel entworfen, möglichst einfach und übersichtlich zu sein. Dies soll durch zwei Maßnahmen erreicht werden: Zum einen kommt die Sprache mit relativ wenigen Schlüsselwörtern aus, zum anderen ist die Syntax reduziert und auf Übersichtlichkeit optimiert. Dies führt dazu, dass Python eine Sprache ist, in der man schnell, einfach und leicht programmieren kann. Sie ist daher besonders dort geeignet, wo Übersichtlichkeit und Lesbarkeit des Codes eine herausragende Rolle spielen – z. B. in der Teamarbeit, bei Beschäftigung mit dem Quelltext nach längeren Pausen oder bei Programmieranfängern. Durch die Möglichkeit, auch Programme anderer Sprachen als Modul einzubetten, werden viele Nischen in der Programmierung abgedeckt. Bei Bedarf lassen sich so beispielsweise zeitkritische Teile durch maschinennah in C programmierte Routinen ersetzen, oder Python kann als Skriptsprache eines anderen Programms dienen (Beispiele: OpenOffice.org, Blender, Maya, PyMOL, SPSS und GIMP). Python ist eine Multiparadigmensprache. Das heißt, es zwingt den Programmierer nicht zu einem einzigen bestimmten Programmierparadigma, sondern erlaubt es, das für die jeweilige Aufgabe am besten geeignete Paradigma zu wählen. Objektorientierte und strukturierte Programmierung werden vollständig unterstützt, weiterhin gibt es Spracheigenschaften für funktionale und aspektorientierte Programmierung. Quelle: Wikipedia

6. Philosophie von Python # Schön ist besser als hässlich. # Explizit ist besser als implizit. # Einfach ist besser als kompliziert. # Kompliziert ist besser als undurchschaubar. # Flach ist besser als verschachtelt. # Spärlich ist besser als beschränkt. # Lesbarkeit zählt. # Spezialfälle sind nicht spezial genug, als dass sie die Regeln sprengen dürften. # Fehler sollten nie schweigend verlaufen. # Außer man hat sie explizit zum Schweigen gebracht. # Es sollten einen --- und bevorzugt genau einen --- offensichtlichen Weg geben, es zu tun. # Wenn die Implementierung schwer zu erklären ist, ist es eine schlechte Idee. # Wenn die Implementierung einfach zu erklären ist, könnte es eine gute Idee sein. # ... Quelle: http://www.python-kurs.eu/index.php

7. Interne Abläufe Der Quelltext eines Python Programms wird mit einem Texteditor geschrieben (z.B. Idle oder Pyscripter). Der Python-Compiler erzeugt einen (maschinenunabhängigen) Byte-Code. Der Compiler entscheidet selbst, ob der Byte-Code nur als Zwischenprodukt im Arbeitsspeicher erzeugt wird, oder ob er auch als .pyc-Datei gespeichert wird. Compiler Der Python-Interpreter führt den vom Compiler erzeugten Byte-Code aus. Derselbe Byte-Code kann auf verschiedenen Plattformen ausgeführt werden, sofern diese einen Python-Interpreter zur Verfügung stellen. Interpreter

8. Gängige Python-Versionen http://www.python.org/download/ http://portablepython.com/releases/

9. Entwicklungsumgebung Idle

10. Entwicklungsumgebung PyScripter

11. Literatur • Bücher: • Johannes Ernesti, Peter Kaiser: Python 3. Das umfassende Handbuch. Galileo Computing 2009. (Preis: 40 €) • Michael Weigend: Objektorientierte Programmierung mit Python. mitp 2008. (Preis: 40 €) • Michael Weigend: Python Ge-Packt. mitp 2006. (Preis: 16 €) • Thomas Theis: Einstieg in Python 3. Galileo Computing 2009. (Preis: 25 €) • Gregor Lingl: Python für Kids. bhv 2008. (Preis: 20 €) • ...

12. Materialien • Internet: • Python Official Websitehttp://www.python.org/ • Python-Tutorium von Guido van Rossum: http://starship.python.net/crew/gherman/publications/tut-de/tut-de-21.pdfhttp://starship.python.net/crew/gherman/publications/tut-de/online/tut/ • offenes eBook von von Peter Kaiser und Johannes Ernesti (Python 2.5):http://openbook.galileocomputing.de/python/?GalileoSession=10541258A3Vg6VBUX8A • PythonWiki: http://wiki.python.de/ • Python-Kurs von W.Spiegel: http://www.wspiegel.de/pykurs/pykurs.htm • Python, Programmieren macht Spaß : http://www.thomas-guettler.de/vortraege/python/einfuehrung.html • BICS: http://schule.de/bics/inf2/programmiersprachen/python/ • Unterrichtsmaterialien von Klaus Merkert:http://www.hsg-kl.de/faecher/inf/python/index.php • Unterrichtsmaterialien aufwww.inf-schule.de

13. Teil 1 Variablen

14. Mäusepopulation • Modellannahmen: • Unterteilung in drei Alterklassen: junge Mäuse, erwachsene Mäuse und alte Mäuse. • In jedem Schritt erfolgt ein Wechsel der Altersklasse: Junge Mäuse werden erwachsen, erwachsene werden alt (und alte Mäuse leider nicht mehr jung). • Nur ein bestimmter Anteil (siehe Diagramm) erreicht die nächste Altersstufe. • Im Diagramm sind zusätzlich die Geburtenraten eingetragen. Wir gehen davon aus, dass jede erwachsene Maus (im Durchschnitt) vier junge Mäuse erzeugt und dass jede alte Maus (im Durchschnitt) zwei junge Mäuse erzeugt.

15. Aufgabe >>> jung = 6 >>> erwachsen = 9 >>> alt = 12 >>> jung 6 >>> erwachsen 9 >>> alt 12 >>> alt = erwachsen // 3 >>> erwachsen = jung // 2 >>> jung = erwachsen*4 + alt*2 >>> jung 18 >>> erwachsen 3 >>> alt 3 >>> Schritt 0 1 2 3 4 5 ... jung 6 60 = 4*9+2*12 erwachsen 9 3 = 6/2 alt 12 3 = 9/3 Python-Dialog Ist im gezeigten Python-Dialog alles ok?. Berechne die Populationswerte (ohne / mit Python).

16. Was ist eine Variable? Variablen dienen in der Informatik dazu, Daten zu verwalten. Eine Variable ist ein Name, der mit einer Speicherzelle verknüpft ist. Mit der Variable kann man auf den in der zugehörigen Speicherzelle abgelegten Datenwert zugreifen. "Behältersemantik" Speicherzelle mit Datenwert Name Variablen dienen in der Informatik dazu, Daten zu verwalten. Eine Variable ist ein Name, der (in der Regel) mit einem Datenobjekt verknüpft ist. "Zeigersemantik" Name Zeiger Datenobjekt Variablen dienen in der Informatik dazu, Daten zu verwalten. Eine Variable ist ein Name, der (in der Regel) mit einem Wert verknüpft ist. "Wertsemantik" {jung -> 6; erwachsen -> 9; alt -> 12} Datenwert Name

17. Variablen in Python Variablen dienen in der Informatik dazu, Daten zu verwalten. Eine Variable ist ein Name, der (in der Regel) mit einem Datenobjekt verknüpft ist. "Zeigersemantik" Name Zeiger Datenobjekt Jedes Datenobjekt in Python hat eine Identitätsnummer, einen Typ und einen Wert. Die Identitätsnummer ist die Adresse des Objekts im Speicher. Sie ist also eine Zahl, mit der man ein Datenobjekt eindeutig identifizieren kann. Eine Variable ist ein Name, der (in der Regel) mit einem Datenobjekt verknüpft ist. Die Verknüpfung wird durch einen Verweis (Referenz) auf die Speicheradresse des Datenobjekts hergestellt. >>> id(2) 505300136 >>> zahl = 2 >>> id(zahl) 505300136 >>> type(zahl) <class 'int'> >>> zahl 2 >>> id(2) 505300136 >>> type(2) <class 'int'> >>> 2 2

18. Zuweisungen in Python Eine Veränderung eines Variablenwerts kann mit Hilfe einer Zuweisung erfolgen. Erst wird der Wert des Terms (auf der rechten Seite der Zuweisung) mit Hilfe des aktuellen Variablenzustands ermittelt. Dann wird ein Datenobjekt mit diesem Wert an die Variable (auf der linken Seite der Zuweisung) gebunden. Dieses Datenobjekt kann ein bereits existierendes Datenobjekt sein oder ein neu erzeugtes. Python entscheidet nach internen Strategien, welche Version günstiger ist. Je nach Programmablaufsituation können gleiche Zuweisungen durchaus zu unterschiedlichen Datenobjektkonstellationen führen. Entscheidend ist nur, dass der Variablen ein Datenobjekt zugeordnet wird, das den gewünschten Datenwert hat. [variable] = [term] Struktur Auswertung >>> a = "Test" >>> b = "Test" >>> id(a) 27764768 >>> id(b) 27757280 Beachte: Auch wenn zwei Variablen denselben Wert haben, müssen sie nicht auf dasselbe Datenobjekt verweisen. >>> a = 2 >>> id(a) 505300136 >>> b = a >>> id(b) 505300136

19. Mehrfachzuweisungen Python erlaubt Zuweisungen der Gestalt [variablentupel] = [termtupel]. >>> (jung, erwachsen, alt) = (6, 9, 12) >>> jung 6 >>> erwachsen 9 >>> alt 12 >>> (jung, erwachsen, alt) = (erwachsen*4+alt*2, jung//2, erwachsen//3) >>> (jung, erwachsen, alt) (60, 3, 3) Variablentupel Termtupel

20. Übungen Teste interaktiv die folgenden Zuweisungssequenzen mit Hilfe von Python-Dialogen: a = 5 b = 9 a = a - b b = a + b a = b - a x = 5 y = 9 (x, y) = (y, x)

21. Teil 2 Datentypen

22. Python als Taschenrechner >>> 365 * 17 + 212 6417 >>> (42 - 67) * 21 -525 >>> 14 // 4 3 >>> 14 / 4 3.5 >>> 14 % 4 2 >>> 2.4 * 6.3 15.119999999999999 >>> 2**500 3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376 >>> 1 + 1 2 >>> 1 + 1.0 2.0 >>> 1.0 + 1.0 2.0 >>> "1" + "1" '11' >>> 1,0 + 1,0 (1, 1, 0) >>> (1, 0) + (1, 0) (1, 0, 1, 0) >>> 1,0 + 1 (1, 1) >>> (1, 0) + 1 Traceback (most recent call last): File ... TypeError: can only concatenate tuple (not "int") to tuple >>> 1 + "1" Traceback (most recent call last): File ... TypeError: unsupported operand type(s) for +: 'int' and 'str' Alles klar?

23. Datentyp Zu verarbeitende Daten können von ganz unterschiedlichem Typ sein, z. B. Zahlen, mit denen man rechnen kann, oder Zeichenketten, die man hintereinanderhängen kann. Ein Datentyp beschreibt eine Menge von Datenobjekten, die alle die gleiche Struktur haben und mit denen die gleichen Operationen ausgeführt werden können. >>> 1 + 1 2 >>> 1 + 1.0 2.0 >>> 1.0 + 1.0 2.0 >>> "1" + "1" '11' >>> 1,0 + 1,0 (1, 1, 0) >>> (1, 0) + (1, 0) (1, 0, 1, 0) >>> 1,0 + 1 (1, 1) >>> (1, 0) + 1 TypeError: can only concatenate tuple (not "int") to tuple >>> 1 + "1" TypeError: unsupported operand type(s) for +: 'int' and 'str' >>> type(1) <class 'int'> >>> type(1.0) <class 'float'> >>> type("1") <class 'str'> >>> type(1,0) Traceback (most recent call last): File ... TypeError: type() takes 1 or 3 arguments >>> type((1,0)) <class 'tuple'> >>> <type 'tuple'>

24. Datentypen in Python >>> 2 2 Datentyp: ganze Zahl int >>> 2.0 2.0 Datentyp: Dezimalzahl float Datentyp: Wahrheitswert bool >>> True True >>> "Hallo!" 'Hallo!' Datentyp: Zeichenkette string >>> 'Hallo!' 'Hallo!' >>> ('Hans', 'Meier', 34, 'Koblenz') ('Hans', 'Meier', 34, 'Koblenz') Datentyp: Tupel tuple Datentyp: Liste list >>> [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] ... ...

25. Numerische Datentypen in Python Numerische Datentypen sind in Pythen Datentypen, die Rechenoperationen zur Verarbeitung der Daten vorsehen. Zu diesen Datentypen gehören int, float und auch bool. Beachte, dass die Wahrheitswerte False und True in vielerlei Hinsicht wie die Zahlen 0 und 1 behandelt werden. Für numerische Datentypen sind folgende Rechenoperationen definiert: Operator Bedeutung Rechenausdruck Ergebnis + Addition 1+1 2 - Subtraktion 4-2 2 * Multiplikation 3*4 12 // ganzzahlige Division 14//3 4 % Rest b. ganzzahliger Division 14%3 2 / Gleitkommazahldivision 3/4 0.75 ** Potenz 2**3 8 + positives Vorzeichen +1 1 - negatives Vorzeichen -1 -1

26. Typumwandlungen in Python Häufig benötigt man Operatoren, mit denen man aus einem Datenobjekt ein entsprechendes mit einem anderen Datentyp erzeugen kann. Der folgende Python-Dialog zeigt einige Möglichkeiten auf. >>> int("3") 3 >>> float("3") 3.0 >>> int(3.0) 3 >>> int(3.5) 3 >>> float(3) 3.0 >>> str(3) '3' >>> list("[1, 2, 3]") ['[', '1', ',', ' ', '2', ',', ' ', '3', ']'] >>> eval("[1, 2, 3]") [1, 2, 3]

27. Teil 3 Programme

28. Body-Mass-Index Der Body-Mass-Index (kurz: BMI) ist eine Zahl, mit der man abschätzen kann, ob man Unter-, Normal oder Übergewicht hat. Gewicht (in kg) BMI = ------------------ Größe * Größe (in m) Kategorie BMI [kg/m2] Untergewicht bis 18.5 Normalgewicht 18.5 - 25 Übergewicht ab 25 # Eingabe gewicht = float(input("Gewicht in kg: ")) groesse = float(input("Größe in m: ")) # Verarbeitung bmi = gewicht / (groesse * groesse) # Ausgabe print("BMI:", bmi) Beachte aber, dass die hier vorgenommene Einschätzung umstritten ist, da sie Alter, Geschlecht, Statur usw. eines Menschen nicht berücksichtigt. Programm in Datei >>> gewicht = 60.0 >>> groesse = 1.7 >>> bmi = gewicht / (groesse * groesse) >>> bmi 20.761245674740486 >>> >>> Gewicht in kg: 75 Größe in m: 1.80 BMI: 23.1481481481 interaktive Ausführung Programmausführung

29. Programm Ein (Python-) Programm ist eine Folge von (Python-) Anweisungen und Kommentaren. Der Programmtext wird auch Quelltext genannt. • Jede Anweisung wird (in der Regel) im Quelltext in eine neue Zeile geschrieben. • Die Verständlichkeit eines Programms wird durch sogenannte sprechende Bezeichner deutlich erhöht. Ein sprechende Bezeichner ist ein Name (z. B. für eine Variable), der die Bedeutung des bezeichneten Gegenstands möglichst gut wiedergibt. • Kommentare dienen dazu, die Bedeutung von Programmteilen zu erläutern. Kommentare werden eigentlich nur für die Menschen ergänzt, die den Quelltext bearbeiten. Bei der Ausführung von Programmen werden sie ignoriert. • In einem Programm dürfen Umlaute oder andere Sonderzeichen vorkommen, da standardmäßig eine UTF-8-Kodierung für Unicode-Zeichen benutzt wird. # Eingabe gewicht = float(input("Gewicht in kg: ")) groesse = float(input("Größe in m: ")) # Verarbeitung bmi = gewicht / (groesse * groesse) # Ausgabe print("BMI:", bmi) Quelltext

30. EVA-Prinzip Viele Programme lassen sich wie im folgenden Beispiel nach dem EVA-Prinzip strukturieren. EVA steht hier für Eingabe - Verarbeitung - Ausgabe. Auf einen Eingabeteil folgt ein Verarbeitungsteil und schließlich ein Ausgabeteil. # Eingabe gewicht = float(input("Gewicht in kg: ")) groesse = float(input("Größe in m: ")) # Verarbeitung bmi = gewicht / (groesse * groesse) # Ausgabe print("BMI:", bmi) Eingabe Verarbeitung Ausgabe Eingaben in Python: Der input-Operator gibt zunächst den Aufforderungstext aus, wartet dann, bis der Benutzer seine Eingabe mit der Return-Taste abgeschlossen hat und liefert diese Eingabe als Zeichenkette vom Typ str zurück. Ausgaben in Pythen: Die print-Anweisung gibt alle übergebenen Werte der Reihe nach (in einer Zeile) auf dem Bildschirm aus.

31. Übungen Aufgabe (siehe 1.6.3.7): Der optimale Puls bei Ausdauersportarten hängt vom Alter ab. Er lässt sich mit der Formel P = 165 - 0.75*A bestimmen. Schreibe ein Programm, das folgenden Dialog ermöglicht: Alter: 18 optimaler Puls: 151.5

32. Übungen Aufgabe (siehe 1.6.3.7): In der Fahrschule lernt man folgende Faustformeln zur Berechnung von Anhaltewegen: Reaktionsweg (in Metern) = (Geschwindigkeit (in km/h) geteilt durch 10) mal 3 Bremsweg (in Metern) = (Geschwindigkeit (in km/h) geteilt durch 10) mal (Geschwindigkeit (in km/h) geteilt durch 10) Anhalteweg (in Metern) = Reaktionsweg plus Bremsweg Entwickle ein Programm, mit dem man den Anhalteweg für eine beliebige eingegebene Geschwindigkeit bestimmen kann.

33. Teil 4 Entscheidungen

34. Schaltjahre Aufgabe: Ergänze das bereits angefangene Programm. Achte genau auf Doppelpunkte und Einrückungen. # Eingabe jahr = int(input("Jahr: ")) # Verarbeitung if jahr % 4 == 0: if jahr % 100 == 0: if jahr % 400 == 0: schaltjahr = True else: ... # Ausgabe if schaltjahr == True: print(jahr, "ist ein Schaltjahr.") ...

35. Fallunterscheidung Eine Fallunterscheidung dient dazu, alternative Abläufe bzw. Fallunterscheidungen zu beschreiben. zweiseitige Fallunterscheidung einseitige Fallunterscheidung Doppelpunkt Schlüsselwort if [Bedingung]: [Anweisungssequenz] else: [Anweisungssequenz] if [Bedingung]: [Anweisungssequenz] Einrückung if konto < 0: print "Der Kontostand ist negativ!" print "Du hast Schulden!" if konto > 0: print "Der Kontostand ist positiv!" print "Eine Auszahlung ist möglich!" if konto < 0: print("Der Kontostand ist negativ!") print("Bitte die Schulden begleichen!") else: print("Alles ok!")

36. Mehrfachfallunterscheidung Eine Fallunterscheidung dient dazu, alternative Abläufe bzw. Fallunterscheidungen zu beschreiben. if zahl > 0: print "Die Zahl ist positiv!" elif zahl < 0: print "Die Zahl ist negativ!" else: print "Die Zahl ist gleich Null!" if konto > 0: print "Der Kontostand ist positiv!" else: if konto < 0: print "Der Kontostand ist negativ!" else: print "Der Kontostand ist gleich Null!" if [Bedingung]: [Anweisungssequenz] elif [Bedingung]: [Anweisungssequenz] elif [Bedingung]: [Anweisungssequenz] ... else: [Anweisungssequenz] Schlüsselwort Doppelpunkt Einrückung

37. Übungen Aufgabe: Der Body-Mass-Index (kurz: BMI) ist eine Zahl, die darüber Auskunft gibt, ob man Normalgewicht hat. Sie berechnet sich so: Gewicht in kg geteilt durch das Quadrat der Körpergröße in m!. Wenn man also 1.80 m groß ist und ein Gewicht von 75 kg hat, dann erhält man einen BMI von etwa 23. Wenn die so berechnete Zahl zwischen 18.5 und 26 liegt, dann hat man Normalgewicht. Wenn sie kleiner als 18.5 / größer als 26 ist, dann hat man Untergewicht / Übergewicht. Ergänze das Programm zur Berechnung des BMI um eine adäquate Rückmeldung.

38. Übungen Aufgabe (siehe 1.6.4.5): Mit Hilfe der Variablen a, b und c werden drei Zahlen verwaltet. Mit Hilfe eines Programms soll entschieden werden, ob die drei Zahlen verschieden sind. Entwickle erst ein geeignetes Struktogramm und anschließend ein hierzu passendes Programm.

39. Teil 5 Wiederholungen

40. Ein Blick in die Zukunft # Initialisierung kapital = float(input("Kapital: ")) zinssatz = float(input("Zinssatz: ")) jahr = 0 # Iterierung while jahr < 10: zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen jahr = jahr + 1 # Ausgabe print("Kapital nach 10 Jahren: ", kapital) "Legen Sie ihr Geld zinsgünstig bei unserer Bank an. Nach einigen Jahren können Sie sich dann ihr Traum... leisten." • Aufgaben: • Ändere das Programm so ab, dass folgende Aufgaben erledigt werden: • In jedem Berechnungsschritt sollen die aktuell berechneten Werte ausgegeben werden. • Der Benutzer kann selbst eingeben, wie viele Schritte simuliert werden sollen. • Der Benutzer kann einen bestimmten Zielbetrag eingeben, bis zu der die Kapitalverzinsung durchgeführt werden soll. Ausgegeben werden soll, wie viele Jahre hierzu benötigt werden.

41. Wiederholung Eine Wiederholung dient dazu, wiederholte Abläufe zu beschreiben. Sie ist aus einer Bedingung und einer (eventuell einelementigen) Anweisungssequenz aufgebaut. # Initialisierung kapital = float(input("Kapital: ")) zinssatz = float(input("Zinssatz: ")) jahr = 0 # Iterierung while jahr < 10: zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen jahr = jahr + 1 # Ausgabe print("Kapital nach 10 Jahren: ", kapital) Struktur Semantik Schlüsselwort Doppelpunkt while [Bedingung]: [Anweisungssequenz] Einrückung

42. wiederhole ... bis ... Eine Wiederholung dient dazu, wiederholte Abläufe zu beschreiben. Sie ist aus einer Bedingung und einer (eventuell einelementigen) Anweisungssequenz aufgebaut. # Initialisierung kapital = float(input("Kapital: ")) zinssatz = float(input("Zinssatz: ")) beginn = int(input("Beginn: ")) ende = int(input("Ende: ")) jahr = beginn # Iterierung while True: jahr = jahr + 1 zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen if jahr == ende: break # Ausgabe print("Jahr: ", jahr) print("neues Kapital: ", kapital) Mit break und continue kann man sehr flexibel Wiederholungen modellieren.Im Unterricht reicht in der Regel die Solange-Schleife.

43. for-Anweisung in Python # Initialisierung kapital = float(input("Kapital: ")) zinssatz = float(input("Zinssatz: ")) # Iterierung for jahr in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]: zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen # Ausgabe print("Kapital nach 10 Jahren: ", kapital) # Initialisierung kapital = float(input("Kapital: ")) zinssatz = float(input("Zinssatz: ")) # Iterierung for jahr in range(10): zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen # Ausgabe print("Kapital nach 10 Jahren: ", kapital) Liste erzeugt Iterator Doppelpunkt Schlüsselwort for [Element] in [iterierbares Objekt]: [Anweisungssequenz] Einrückung

44. for-Anweisung in Python Doppelpunkt Schlüsselwort for [Element] in [iterierbares Objekt]: [Anweisungssequenz] Einrückung for element in ["Heute", "ist", "ein", "Mittwoch", "."]: print(element) Liste als iterierbares Objekt for zeichen in "Informatik": print(zeichen) Zeichenkette als iterierbares Objekt for komponente in ("Petra", "Schmidt", 18): print(komponente) Tupel als iterierbares Objekt

45. Zählschleifen in Python for i in range(5): print(i) for i in range(2, 5): print(i) 0 1 2 3 4 2 3 4 for i in range(1, 5, 2): print(i) for i in range(5, 1, -1): print(i) 1 3 5 4 3 2

46. Übungen Aufgabe (siehe 1.6.4.5): Was leistet der folgende Algorithmus? Implementiere den Algorithmus in Python und versuche mit Hilfe von Tests herauszufinden, was er leistet. # EingabeEingabe: x, y # natürliche Zahlen größer 1 # VerarbeitungSOLANGE y > 0: h = x % y # Rest bei der ganzzahligen Division x = y y = h # AusgabeAusgabe: x Aufgabe: Entwickle ein Algorithmus / Programm, mit dem man die Anzahl der Teiler einer eingegebenen natürlichen Zahl bestimmen kann.

47. Übungen Aufgabe (siehe 1.6.5.5): Was leisten die folgenden for-Anweisungen? Stell zunächst jeweils eine Vermutung auf. Teste anschließend, ob die Vermutung stimmt. for i in [1, 2, 3]: print("Hallo") for i in [1, 2, 3]: print(i*i) for i in range(3): print(i) for i in range(3, 7): print(i) for c in ["a", "b", "c"]: print(c)

48. Teil 6 Bedingungen

49. Würfeln mit dem Computer from random import randint # Verarbeitung w1 = randint(1, 6) w2 = randint(1, 6) w3 = randint(1, 6) versuche = 0 while not ((w1 == w2) and (w1 == w3)): w1 = randint(1, 6) w2 = randint(1, 6) w3 = randint(1, 6) versuche = versuche + 1 # Ausgabe print(versuche) from random import randint # Verarbeitung w1 = randint(1, 6) w2 = randint(1, 6) w3 = randint(1, 6) versuche = 0 while (w1 != w2) or (w1 != w3): w1 = randint(1, 6) w2 = randint(1, 6) w3 = randint(1, 6) versuche = versuche + 1 # Ausgabe print(versuche) Aufgabe: Was leisten die Programme?

50. Komplexe Bedingungen Eine Bedingung wird aus elementaren Bedingungen und logischen Operatoren aufgebaut. while (w1 != w2) or (w1 != w3): ... logischer Operator el. Bedingung el. Bedingung Operator Bedeutung Bsp. Ergebnis < kleiner 2 < 1 False > größer 4 > 2 True <= kleiner oder gleich 3 <= 3 True >= größer oder gleich 3 >= 4 False == gleich 4 == 3 False != ungleich 2 != 3 True Vergleichsoperatoren Operator Bedeutung Bsp. Ergebnis not nicht not True False and und True and False False or oder True or False True logische Operatoren