Python - Konzepte imperativer Programmierung Klaus Becker 2009

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

Compiler

Interpreter

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.

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.

8 Gängige Python-Versionen

http://portablepython.com/releases/

http://www.python.org/download/

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 Website

http://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

Berechne die Populationswerte (ohne / mit Python).

>>> jung = 6>>> erwachsen = 9>>> alt = 12>>> jung6>>> erwachsen9>>> alt12>>> alt = erwachsen // 3>>> erwachsen = jung // 2>>> jung = erwachsen*4 + alt*2>>> jung18>>> erwachsen3>>> alt3>>>

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

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.

Name

Speicherzelle mit Datenwert

Variablen dienen in der Informatik dazu, Daten zu verwalten. Eine Variable ist ein Name, der (in der Regel) mit einem Datenobjekt verknüpft ist.

Name

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.

Name Datenwert

Zeiger

{jung -> 6; erwachsen -> 9; alt -> 12}

"Behältersemantik"

"Zeigersemantik"

"Wertsemantik"

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.

Name

Datenobjekt

Zeiger

"Zeigersemantik"

>>> id(2)505300136>>> type(2)<class 'int'>>>> 22

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. >>> id(2)

505300136>>> zahl = 2>>> id(zahl)505300136>>> type(zahl)<class 'int'>>>> zahl2

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.

18 Zuweisungen in Python

Eine Veränderung eines Variablenwerts kann mit Hilfe einer Zuweisung erfolgen.

>>> a = 2>>> id(a)505300136>>> b = a>>> id(b)505300136

>>> a = "Test">>> b = "Test">>> id(a)27764768>>> id(b)27757280

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

Beachte: Auch wenn zwei Variablen denselben Wert haben, müssen sie nicht auf dasselbe Datenobjekt verweisen.

19 Mehrfachzuweisungen

Variablentupel

>>> (jung, erwachsen, alt) = (6, 9, 12)>>> jung6>>> erwachsen9>>> alt12>>> (jung, erwachsen, alt) = (erwachsen*4+alt*2, jung//2, erwachsen//3)>>> (jung, erwachsen, alt)(60, 3, 3)

Python erlaubt Zuweisungen der Gestalt [variablentupel] = [termtupel].

Termtupel

20 Übungen

Teste interaktiv die folgenden Zuweisungssequenzen mit Hilfe von Python-Dialogen:

x = 5y = 9(x, y) = (y, x)

a = 5b = 9a = a - bb = a + ba = b - a

21 Teil 2

Datentypen

22 Python als Taschenrechner

>>> 365 * 17 + 2126417>>> (42 - 67) * 21-525>>> 14 // 43>>> 14 / 43.5>>> 14 % 42>>> 2.4 * 6.315.119999999999999>>> 2**5003273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376

>>> 1 + 12>>> 1 + 1.02.0>>> 1.0 + 1.02.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) + 1Traceback (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

>>> 1 + 12>>> 1 + 1.02.0>>> 1.0 + 1.02.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) + 1TypeError: can only concatenate tuple (not "int") to tuple>>> 1 + "1"TypeError: unsupported operand type(s) for +: 'int' and 'str'

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.

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

>>> 22

Datentyp: ganze Zahl int

>>> 2.02.0

>>> TrueTrue

>>> 'Hallo!''Hallo!'

>>> ('Hans', 'Meier', 34, 'Koblenz')('Hans', 'Meier', 34, 'Koblenz')

>>> [1, 2, 3, 4, 5][1, 2, 3, 4, 5]

Datentyp: Dezimalzahl

float

Datentyp: Wahrheitswert

bool

Datentyp: Zeichenkette

string

Datentyp: Tupel tuple

Datentyp: Liste list

... ...

>>> "Hallo!"'Hallo!'

25 Numerische Datentypen in Python

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

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:

26 Typumwandlungen in Python

>>> 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]

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.

27 Teil 3

Programme

28 Body-Mass-Index

>>> gewicht = 60.0>>> groesse = 1.7>>> bmi = gewicht / (groesse * groesse)>>> bmi20.761245674740486>>>

# Eingabegewicht = float(input("Gewicht in kg: "))groesse = float(input("Größe in m: "))# Verarbeitungbmi = gewicht / (groesse * groesse)# Ausgabeprint("BMI:", bmi)

>>> Gewicht in kg: 75Größe in m: 1.80BMI: 23.1481481481

interaktive Ausführung Programmausführung

Programm in Datei

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.5Normalgewicht 18.5 - 25Übergewicht ab 25

Beachte aber, dass die hier vorgenommene Einschätzung umstritten ist, da sie Alter, Geschlecht, Statur usw. eines Menschen nicht berücksichtigt.

29 Programm

# Eingabegewicht = float(input("Gewicht in kg: "))groesse = float(input("Größe in m: "))# Verarbeitungbmi = gewicht / (groesse * groesse)# Ausgabeprint("BMI:", bmi)

Quelltext

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.

30 EVA-Prinzip

# Eingabegewicht = float(input("Gewicht in kg: "))groesse = float(input("Größe in m: "))

# Verarbeitungbmi = gewicht / (groesse * groesse)

# Ausgabeprint("BMI:", bmi)

Eingabe

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.

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


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.

# Eingabejahr = int(input("Jahr: "))# Verarbeitungif jahr % 4 == 0: if jahr % 100 == 0: if jahr % 400 == 0: schaltjahr = True else: ...# Ausgabeif schaltjahr == True: print(jahr, "ist ein Schaltjahr.")...

35 Fallunterscheidung

Eine Fallunterscheidung dient dazu, alternative Abläufe bzw. Fallunterscheidungen zu beschreiben.

if [Bedingung]: [Anweisungssequenz]else: [Anweisungssequenz]

zweiseitige Fallunterscheidun

g

einseitige Fallunterscheidun

g

if [Bedingung]: [Anweisungssequenz]

Doppelpunkt

if konto < 0: print("Der Kontostand ist negativ!") print("Bitte die Schulden begleichen!")else: print("Alles ok!")

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!"

Einrückung

Schlüsselwort

36 Mehrfachfallunterscheidung

Eine Fallunterscheidung dient dazu, alternative Abläufe bzw. Fallunterscheidungen zu beschreiben.

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 zahl > 0: print "Die Zahl ist positiv!"elif zahl < 0: print "Die Zahl ist negativ!"else: print "Die Zahl ist gleich Null!"

if [Bedingung]: [Anweisungssequenz]elif [Bedingung]: [Anweisungssequenz]elif [Bedingung]: [Anweisungssequenz]...else: [Anweisungssequenz]

Doppelpunkt

Einrückung

Schlüsselwort

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


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

# Initialisierungkapital = float(input("Kapital: "))zinssatz = float(input("Zinssatz: "))jahr = 0# Iterierungwhile jahr < 10: zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen jahr = jahr + 1# Ausgabeprint("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.

0

200

400

600

800

1000

1200

1400

1600

1800

2000

1 3 5 7 9 11 13 15 17 19 21

41 Wiederholung

Eine Wiederholung dient dazu, wiederholte Abläufe zu beschreiben. Sie ist aus einer Bedingung und einer (eventuell einelementigen) Anweisungssequenz aufgebaut.

# Initialisierungkapital = float(input("Kapital: "))zinssatz = float(input("Zinssatz: "))jahr = 0# Iterierungwhile jahr < 10: zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen jahr = jahr + 1# Ausgabeprint("Kapital nach 10 Jahren: ", kapital)

while [Bedingung]: [Anweisungssequenz]

Doppelpunkt

Einrückung

Schlüsselwort

Semantik

Struktur

42 wiederhole ... bis ...

Eine Wiederholung dient dazu, wiederholte Abläufe zu beschreiben. Sie ist aus einer Bedingung und einer (eventuell einelementigen) Anweisungssequenz aufgebaut.

# Initialisierungkapital = float(input("Kapital: "))zinssatz = float(input("Zinssatz: "))beginn = int(input("Beginn: "))ende = int(input("Ende: "))jahr = beginn# Iterierungwhile True: jahr = jahr + 1 zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen if jahr == ende: break# Ausgabeprint("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

# Initialisierungkapital = float(input("Kapital: "))zinssatz = float(input("Zinssatz: "))# Iterierungfor jahr in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]: zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen# Ausgabeprint("Kapital nach 10 Jahren: ", kapital)

# Initialisierungkapital = float(input("Kapital: "))zinssatz = float(input("Zinssatz: "))# Iterierungfor jahr in range(10): zinsen = kapital * (zinssatz/100) kapital = kapital + zinsen# Ausgabeprint("Kapital nach 10 Jahren: ", kapital)

for [Element] in [iterierbares Objekt]: [Anweisungssequenz]

Doppelpunkt

Einrückung

Schlüsselwort

Liste erzeugt Iterator

44 for-Anweisung in Python

for [Element] in [iterierbares Objekt]: [Anweisungssequenz]

Doppelpunkt

Einrückung

Schlüsselwort

for element in ["Heute", "ist", "ein", "Mittwoch", "."]: print(element)

for zeichen in "Informatik": print(zeichen)

for komponente in ("Petra", "Schmidt", 18): print(komponente)

Liste als iterierbares Objekt

Zeichenkette als iterierbares Objekt

Tupel als iterierbares Objekt

45 Zählschleifen in Python

for i in range(5): print(i)

01234

for i in range(2, 5): print(i)

234

for i in range(1, 5, 2): print(i)

13

for i in range(5, 1, -1): print(i)

5432

46 Übungen


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


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# Verarbeitungw1 = randint(1, 6)w2 = randint(1, 6)w3 = randint(1, 6)versuche = 0while not ((w1 == w2) and (w1 == w3)): w1 = randint(1, 6) w2 = randint(1, 6) w3 = randint(1, 6) versuche = versuche + 1# Ausgabeprint(versuche)

from random import randint# Verarbeitungw1 = randint(1, 6)w2 = randint(1, 6)w3 = randint(1, 6)versuche = 0while (w1 != w2) or (w1 != w3): w1 = randint(1, 6) w2 = randint(1, 6) w3 = randint(1, 6) versuche = versuche + 1# Ausgabeprint(versuche)

Aufgabe:Was leisten die Programme?

50 Komplexe Bedingungen

Eine Bedingung wird aus elementaren Bedingungen und logischen Operatoren aufgebaut.

el. Bedingung

while (w1 != w2) or (w1 != w3): ...

el. Bedingung

logischer Operator

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 TrueOperator Bedeutung Bsp. Ergebnisnot nicht not True Falseand und True and False Falseor oder True or False True

logische Operatoren

Vergleichsoperatoren

51 Übungen

Aufgabe (vgl. 1.6.7.5):

Was leistet das folgende Programm. Versuche es erst einmal durch Analyse des Quelltextes herauszufinden. Überprüfe deine Vermutung, indem du das Programm testest.genug = Falserichtig = Truezahl = 1while richtig and (not genug): print("Noch eine Quadratzahl?") antwort = input("Antwort (j/n): ") if antwort == "j": print(zahl, " * ", zahl) ergebnis = int(input("Ergebnis:")) if ergebnis != zahl * zahl: richtig = False print("falsch!") else: print("richtig!") zahl = zahl + 1 else: genug = True

52 Übungen


Entwickle ein Programm, mit dem man bestimmen kann, wie viele Versuche man benötigt, bis man einen 3er-Pasch erhält.

53 Teil 7

Unterprogramme

54 halb so alt

# InitialisierungdatumGeburt = (21, 1, 1992)datumHeute = (5, 7, 2009)# Verarbeitunganzahl = 0datum = datumGeburtwhile datum != datumHeute: (tag, monat, jahr) = datum if monat in [1, 3, 5, 7, 8, 10, 12]: maxtage = 31 elif monat in [4, 6, 9, 11]: maxtage = 30 elif (jahr % 400 == 0) or \ ((jahr % 4 == 0) and not (jahr % 100 == 0)): maxtage = 29 else: maxtage = 28 if tag < maxtage: tag = tag + 1 elif monat < 12:

...

... tag = 1 monat = monat + 1 else: tag = 1 monat = 1 jahr = jahr + 1 datum = (tag, monat, jahr) anzahl = anzahl + 1halbeanzahl = anzahl // 2datum = datumGeburtzaehler = 0while zaehler < halbeanzahl: (tag, monat, jahr) = datum if monat in [1, 3, 5, 7, 8, 10, 12]: maxtage = 31 elif monat in [4, 6, 9, 11]: maxtage = 30 elif (jahr % 400 == 0) or \ ((jahr % 4 == 0) and not (jahr % 100 == 0)): maxtage = 29...

guter Stil?

55 halb so alt

def schaltjahr(jahr): return (jahr % 400 == 0) or ((jahr % 4 == 0) and not (jahr % 100 == 0))

def naechstesDatum(datum): (tag, monat, jahr) = datum if tag < anzahlTageImMonat(monat, jahr): tag = tag + 1 elif monat < 12: tag = 1 monat = monat + 1 else: tag = 1 monat = 1 jahr = jahr + 1 return (tag, monat, jahr)...

def anzahlTageImMonat(monat, jahr): if monat in [1, 3, 5, 7, 8, 10, 12]: anzahl = 31 elif monat in [4, 6, 9, 11]: anzahl = 30 elif schaltjahr(jahr): anzahl = 29 else: anzahl = 28 return anzahl

def anzahlTageZwischenDatum(datum1, datum2): anzahl = 0 datum = datum1 while datum != datum2: datum = naechstesDatum(datum) anzahl = anzahl + 1 return anzahl

Unterprogramme

56 halb so alt

def anzahlTageZwischenDatum(datum1, datum2): anzahl = 0 datum = datum1 while datum != datum2: datum = naechstesDatum(datum) anzahl = anzahl + 1 return anzahldef neuesdatum(datum1, anzahlTage): anzahl = 0 datum = datum1 while anzahl < anzahlTage: datum = naechstesDatum(datum) anzahl = anzahl + 1 return datum

datumGeburt = (21, 1, 1992)datumHeute = (5, 7, 2009)anzahlTage = anzahlTageZwischenDatum(datumGeburt, datumHeute)halbeAnzahlTage = anzahlTage // 2datumHalbzeit = datum(datumGeburt, halbeAnzahlTage)print(anzahlTage)print(datumHalbzeit)

Unterprogramme

Hauptprogramm

57 Unterprogramme

Unterprogramme sind eigenständige Programmeinheiten. Sie werden innerhalb von Programmen benutzt, um Teilaufgaben zu implementieren.

def anzahlTageZwischenDatum(datum1, datum2): anzahl = 0 ... return anzahldef neuesDatum(datum1, anzahlTage): anzahl = 0 datum = datum1 while anzahl < anzahlTage: datum = naechstesDatum(datum) anzahl = anzahl + 1 return datum

datumGeburt = (21, 1, 1992)datumHeute = (5, 7, 2009)anzahlTage = anzahlTageZwischenDatum(datumGeburt, datumHeute)halbeAnzahlTage = anzahlTage // 2datumHalbzeit = datum(datumGeburt, halbeAnzahlTage)print(anzahlTage)print(datumHalbzeit)

Strukturierung des Quelltextes

Vermeidung von Codeduplizierung

58 Funktionen

Eine Funktion ist eine Unterprogrammeinheit, die übergebene Daten verarbeitet und den berechneten Funktionswert als Ergebnis zurückgibt. Die Verarbeitung wird über eine Funktionsdefinition (man sagt oft auch Funktionsdeklaration) festgelegt. Aktiviert wird eine Verarbeitung durch einen Funktionsaufruf.

def anzahlTageImMonat(monat, jahr): if monat in [1, 3, 5, 7, 8, 10, 12]: anzahl = 31 elif monat in [4, 6, 9, 11]: anzahl = 30 elif schaltjahr(jahr): anzahl = 29 else: anzahl = 28 return anzahl

Funktionsaufruf

Funktionsdefinition

anzahlTageImMonat(2, 2012)

Doppelpunkt

Einrückung

Schlüsselwort

Funktionsname(Parameter)

59 Parameter

Parameter sind Platzhalter, mit deren Hilfe man Daten zur Laufzeit an Funktionen übergeben kann.

def anzahlTageImMonat(monat, jahr): if monat in [1, 3, 5, 7, 8, 10, 12]: anzahl = 31 elif .... ... return anzahl

formale Parameter

anzahlTageImMonat(2, 2012)

aktuelle Parameter

Funktionsaufruf

Funktionsdefinition

60 Komplexe Rückgaben

def ausgabeDaten(dGeburt, dAktuell, dHalbzeit): print("Geburtsdatum:", dGeburt) print("aktuelles Datum:", dAktuell) print("halb-so-alt-Datum:", dHalbzeit)

def initialisierungDaten(): datum1 = (21, 1, 1992) datum2 = (5, 7, 2009) return (datum1, datum2)

# Initialisierung(datumGeburt, datumHeute) = initialisierungDaten()# VerarbeitunganzahlTage = anzahlTageZwischenDatum(datumGeburt, datumHeute)halbeAnzahlTage = anzahlTage // 2datumHalbzeit = neuesDatum(datumGeburt, halbeAnzahlTage)# AusgabeausgabeDaten(datumGeburt, datumHeute, datumHalbzeit)

komplexe Rückgabe

Sollen mehrere Daten zurückgegeben werden, so nutzt man eine Datenstruktur (z.B. Tupel), um eine Dateneinheit zu bilden.

61 Prozeduren

Eine Prozedur ist eine Verarbeitungseinheit, die kein Ergebnis zurückliefert.

def ausgabeDaten(dGeburt, dAktuell, dHalbzeit): print("Geburtsdatum:", dGeburt) print("aktuelles Datum:", dAktuell) print("halb-so-alt-Datum:", dHalbzeit)

def initialisierungDaten(): datum1 = (21, 1, 1992) datum2 = (5, 7, 2009) return (datum1, datum2)

# Initialisierung(datumGeburt, datumHeute) = initialisierungDaten()# VerarbeitunganzahlTage = anzahlTageZwischenDatum(datumGeburt, datumHeute)halbeAnzahlTage = anzahlTage // 2datumHalbzeit = neuesDatum(datumGeburt, halbeAnzahlTage)# AusgabeausgabeDaten(datumGeburt, datumHeute, datumHalbzeit)

keine Rückgabe

62 Übungen


Entwickle eine Funktion mit folgender Eigenschaft:

* Die Funktion bestimmt die ganzzahlige Wurzel zu einer vorgegebenen natürlichen Zahl. Z. B. gibt sie den Wert 2 zurück, wenn man 5 als Eingabe wählt.

* Die Funktion bestimmt die nächst größere Primzahl zu einer vorgegebenen natürlichen Zahl. Z. B. gibt sie 7 zurück, wenn man 5 als Eingabe wählt.


Ergänze die Delaration der Funktionen succ (für Nachfolger einer Zahl), pred (für Vorgänger einer Zahl) und add (Addition von zwei Zahlen).

Die Addition der beiden übergebenen natürlichen Zahlen soll dabei nicht mit dem vordefinierten Plus-Operator vorgenommen werden, sondern mit Hilfe der beiden Hilfsfunktionen succ und pred.

# Unterprogrammedef succ(n): ...def pred(n): ...def add(m, n): ...# Hauptprogrammzahl1 = int(input("Zahl 1: "))zahl2 = int(input("Zahl 2: "))summe = add(zahl1, zahl2)print("Summe: ", summe)

63 Teil 8

Lokale und globale Variablen

64 Experimente mit Variablen

def d(x): y = x + x return y

# Testa = 2print(a)a = d(a)print(a)

def d(a): a = a + a return a


def d(): b = a + a return b

# Testa = 2print(a)a = d()print(a)

def d(): a = a + a

# Testa = 2print(a)d()print(a)

Das Zusammenspiel von Variablen des Hauptprogramms, von Variablen von Unterprogrammen und von Parametern ist nicht so einfach. Mit Hilfe von Experimenten sollen die Zusammenhänge erschlossen werden.

Stell jeweils eine Vermutung auf, was die print-Anweisungen ausgeben. Kannst du die Ergebnisse erklären?


def d(x): y = x + x return y


def d(x): y = x + x print(locals()) return y

# Testa = 2print(a)print(globals())a = d(a)print(a)

Erweitere in den oben gezeigten Vorschlägen die Funktionsdefinition und das Testprogramm jeweils um die Aufrufe print(locals()) bzw. print(globals()). Was wird hier ausgegeben?


def d(x): print("x:", x) print("id(x):", id(x)) y = x + x print("y:", y) print("id(y):", id(y)) return y

# Testa = 2print("a:", a)print("id(a):", id(a))a = d(a)print("a:", a)print("id(a):", id(a))

Wie funktioniert die Parameterübergabe? Kann man es aus den Ausgaben der folgenden Testprogramme erschließen?

def d(a): print("a:", a) print("id(a):", id(a)) a = a + a print("a:", a) print("id(a):", id(a)) return a

# Testa = 2print("a:", a)print("id(a):", id(a))a = d(a)print("a:", a)print("id(a):", id(a))

67 lokale / globale Variable

Eine globale Variable ist (vereinfacht gesagt) eine Variable, die im Hauptprogramm eingeführt wird. Eine lokale Variable ist (vereinfacht gesagt) eine Variable, die nur innerhalb eines Unterprogramms benutzt wird. Beachte, dass die (formalen) Parameter eines Unterprogramms auch zu diesen lokalen Variablen zählen.def d(x): y = x + x print(locals()) return y

# Testa = 2print(a)print(globals())a = d(a)print(a)>>> 2{'a': 2, ...}{'y': 4, 'x': 2}4 locals(): lokaler

Namensraum

globals(): globaler Namensraum

def d(a): a = a + a print(locals()) return a

# Testa = 2print(a)print(globals())a = d(a)print(a)>>> 2{'a': 2, ...}{'a': 4}4

a = 2{a -> 2}--------------------------d(a){a -> 2, {x -> 2}} y = x + x{a -> 2, {x -> 2, y -> 4}} return y4--------------------------a = d(a){a -> 4}

a = 2{a -> 2}----------------------d(a){a -> 2, {a -> 2}} a = a + a{a -> 2, {a -> 4}} return a4-----------------------a = d(a){a -> 4}

68 lokale / globale Variable

Eine lokale Variable ist nur innerhalb des Unterprogramms, in dem sie eingeführt ist, gültig bzw. sichtbar.

Auf eine globale Variable kann man innerhalb eines Unterprogramms lesend zugreifen - sofern dort nicht eine gleichlautende Variable eingeführt ist. Wird eine Variable nicht im lokalen Namensraum gefunden, so wird sie im globalen Namensraum gesucht.def d(): b = a + a return b

# Testa = 2print(a)a = d()print(a)

Fehlermeldung

a = 2{a -> 2}--------------------------d(){a -> 2} b = a + a{a -> 2, {b -> 4}} return b4--------------------------a = d(){a -> 4}

def d(): a = a + a


def d(): global a a = a + a


Seiteneffekt

69 Parameterübergabe

def d(x): print("x:", x) print("id(x):", id(x)) y = x + x print("y:", y) print("id(y):", id(y)) return y# Testa = 2print("a:", a)print("id(a):", id(a))a = d(a)print("a:", a)print("id(a):", id(a))a: 2id(a): 505300136x: 2id(x): 505300136y: 4id(y): 505300168a: 4id(a): 505300168

70 Übungen

Aufgabe:

Erkläre die Ergebnisse des unten gezeigten Programms mit Hilfe geeigneter Diagramme.

def d(a): a = a + a print(locals()) return a

# Testa = 2print(a)print(globals())a = d(a)print(a)

71 Teil 9

Listen

72 Lotto

# Version 1tipp1 = 1tipp2 = 12tipp3 = 21tipp4 = 31tipp5 = 37tipp6 = 46ziehung1 = 1ziehung2 = 21ziehung3 = 25ziehung4 = 40ziehung5 = 44ziehung6 = 45

# Version 2tipp = [1, 12, 21, 31, 37, 46]ziehung = [1, 21, 25, 40, 44, 45]

# Version 3tipp = [ \ True , False, False, False, False, False, False, \ False, False, False, False, True , False, False, \ False, False, False, False, False, False, True , \ False, False, False, False, False, False, False, \ False, False, True , False, False, False, False, \ False, True , False, False, False, False, False, \ False, False, False, True , False, False, False, \ ]ziehung = [ \ True , False, False, False, False, False, False, \ False, False, False, False, False, False, False, \ False, False, False, False, False, False, True , \ False, False, False, True , False, False, False, \ False, False, False, False, False, False, False, \ False, False, False, False, True , False, False, \ False, True , True , False, False, False, False, \ ]

einzelne Zahlen

Liste mit Zahlen

Liste mit Wahrheitswerten

73 LottoBearbeiten Sie die Aufgaben des Abschnitts 1.6.10.2:

Aufgabe 1: Zugriff auf Listenelemente

Aufgabe 2/3: Verarbeitung von Listen

Aufgabe 4: Analyse von Programmen

Aufgabe 5: Ergänzung von Programmen

Aufgabe 6: Entwicklung eines Programms

Bei Bedarf können Sie sich in den folgenden Abschnitten über Listen und ihre Verarbeitung informieren.

74 Lösungen - AufgabenAufgabe 2/3: Anzahl der Richtigen

# Version 3tipp = [ \ True , False, False, False, False, False, False, \ False, False, False, False, True , False, False, \ False, False, False, False, False, False, True , \ False, False, False, False, False, False, False, \ False, False, True , False, False, False, False, \ False, True , False, False, False, False, False, \ False, False, False, True , False, False, False, \ ]ziehung = [ \ True , False, False, False, False, False, False, \ ... False, True , True , False, False, False, False, \ ]# Anzahl der Richtigenrichtige = 0for i in range(49): if (tipp[i] == True) and (ziehung[i] == True): richtige = richtige + 1print(richtige)

# Version 2tipp = [1, 12, 21, 31, 37, 46]ziehung = [1, 21, 25, 40, 44, 45]# Anzahl der Richtigenrichtige = 0for t in tipp: for z in ziehung: if t == z: richtige = richtige + 1print(richtige)

75 Lösungen - AufgabenAufgabe 4/5: Erzeugung der Lottoziehung

# Version 3from random import *ziehung = []for i in range(49): ziehung = ziehung + [False]for i in range(6): zahl = randint(1, 49) ziehung[zahl-1] = Truefor i in range(49): if ziehung[i] == True: print(i+1)

# Version 2from random import *ziehung = []for i in range(6): zahl = randint(1, 49) ziehung = ziehung + [zahl]print(ziehung)

# Version 3from random import *ziehung = []for i in range(49): ziehung = ziehung + [False]for i in range(6): ok = False while not ok: zahl = randint(1, 49) if ziehung[zahl-1] == False: ok = True ziehung[zahl-1] = Truefor i in range(49): if ziehung[i] == True: print(i+1)

76 Lösungen - AufgabenAufgabe 6: Wiederholte Lottoziehungen

from random import *def tipp(): t = [ \ True , False, False, False, ... ... False, False, False, True , ... ] return tdef ziehung(): z = [] for i in range(49): z = z + [False] for i in range(6): ok = False while not ok: zahl = randint(1, 49) if z[zahl-1] == False: ok = True z[zahl-1] = True return z

def richtige(z, t): r = 0 for i in range(49): if (t[i] == True) and (z[i] == True): r = r + 1 return rdef simulation(n): t = tipp() haeufigkeiten = [0, 0, 0, 0, 0, 0, 0] i = 0 while i < n: z = ziehung() r = richtige(z, t) haeufigkeiten[r] = haeufigkeiten[r] + 1 i = i + 1 return haeufigkeitendef ausgabe(h): for i in range(7): print(i, " Richtige: ", h[i])

# Testhaeufigkeiten = simulation(10000)ausgabe(haeufigkeiten)

77 Liste

Eine Liste ist eine endliche Folge von Elementen, bei der man neue Elemente hinzufügen und vorhandene Elemente entfernen kann.

BrotButterJoghurtSchokoladeMehlEier...

Äpfel Zur Darstellung von Listen verwenden wir - wie in Python - eckige Klammern.

Alle Elemente einer Liste werden mit Kommata getrennt.

Eine besondere Liste ist die leere Liste. Sie enthält keine Elemente.

Die Elemente einer Liste können (in unserer Darstellung hier) von beliebigem - also auch unterschiedlichem - Typ sein.

Eine Liste kann selbst wieder Listen als Elemente haben. Listen können also geschachtelt werden.['[email protected]', '[email protected]', '[email protected]', ...]

[1, 12, 21, 31, 37, 46]

[]

[1, 21, 25, 40, 44, 45, ("Zusatzzahl", 3), ("Superzahl", 5)]

[[1, 12, 21, 31, 37, 46], [3, 8, 10, 30, 31, 49], [5, 12, 20, 22, 29, 40]]

78 Liste als sequentieller Datentyp

[10, 15, 21, 33, 37, 40]

0 1 2 3 4 5

Element

Index

>>> L = [10, 15, 21, 33, 37, 40]>>> L[0]10>>> L[1]15

lesender Zugriff

>>> L = [10, 15, 21, 33, 37, 40]>>> L[10, 15, 21, 33, 37, 40]>>> L[4] = 36>>> L[10, 15, 21, 33, 36, 40]

schreibender Zugriff

Während ein lesender Zugriff auf jedes Element der Sequenz bei allen sequentiellen Datenobjekten möglich ist, ist ein schreibender Zugriff nur bei veränderbaren Datenobjekten (wie Listen) möglich.

Sequentielle Datenobjekte sind in Python zusammengesetzte Datenobjekte, die aus einer Folge von (gleichartigen oder auch verschiedenen) Datenobjekten bestehen. Die Elemente eines solchen sequentiellen Datenobjekts sind durchnummeriert Die Nummerierung beginnt dabei mit 0. Die Nummer wird auch Index genannt.


['g', 't', 'e', 'c', 's', 'k', 'p']

0 1 2 3 4 5

Element

Index

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']>>> L[0:2]['g', 't']>>> L[2:5]['e', 'c', 's']>>> L[1:5]['t', 'e', 'c', 's']>>> L[3:3][]

Teillisten

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']>>> L[2:]['e', 'c', 's', 'k', 'p']>>> L[:2]['g', 't']>>> L[:]['g', 't', 'e', 'c', 's', 'k', 'p']

Ein Zugriff auf eine Teilliste ist möglich: Wenn L eine Liste bezeichnet, dann beschreibt der Ausdruck L[i:j] die Liste, die alle Elemente der Ausgangsliste L mit den Nummern von i bis j-1 enthält. Beachte, dass diese Teilliste auch leer sein kann.

6

Teillisten


['g', 't', 'e', 'c', 's', 'k', 'p']

0 1 2 3 4 5

Element

Index

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']>>> M = ['a', 'g', 't']>>> L + M['g', 't', 'e', 'c', 's', 'k', 'p', 'a', 'g', 't']>>> L + ['u']['g', 't', 'e', 'c', 's', 'k', 'p', 'u']>>> [] + M['a', 'g', 't']

Konkatenation

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']>>> len(L)7>>> len([])0>>> len([1, [2, 3]])2

Da Listen dynamisch wachsen oder schrumpfen können, benötigt man häufig eine Operation zur Bestimmung der Länge der Liste. Die Länge einer Liste beschreibt dabei die Anzahl der Listenelemente. Wenn L eine Listen bezeichnet, dann beschreibt der Ausdruck len(L) die Länge der Liste.

6

Bei der Konkatenation von Listen werden diese zu einer Gesamtliste verbunden. Wenn L und M zwei Listen bezeichnen, dann beschreibt der Ausdruck L+M die Liste, die zunächst alle Elemente von L und danach alle Elemente von M enthält.

Länge


['g', 't', 'e', 'c', 's', 'k', 'p']

0 1 2 3 4 5

Element

Index

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']>>> e = 'a'>>> e in LFalse>>> e = 's'>>> e in LTrue

Konkatenation

L = ['g', 't', 'e', 'c', 's', 'k', 'p']for e in L: print(e)

Mit einer for-Anweisung der Gestalt for e in L: ...kann man alle Elemente einer Liste (Sequenz) der Reihe nach durchlaufen.

6

Mit einem Ausdruck der Gestalt e in L kann man überprüfen, ob das von e verwaltete Datenobjekt in der von L verwalteten Liste vorkommt.

Länge

82 Übungen

Bearbeiten Sie die Aufgaben des Abschnitts 1.6.10.7:

Aufgabe 1: Eine Liste durchlaufen

Aufgabe 2: Eine Liste auf eine Eigenschaft untersuchen

Aufgabe 3: Eine neue Liste aufbauen

Aufgabe 4: Eine Liste über die Elementnummern durchlaufen

83 Merkwürdiges VerhaltenIm folgenden Python-Dialog wird ein Lotto-Tipp kopiert und anschließend etwas abgeändert.Was fällt auf?

>>> tipp1 = [4, 13, 21, 33, 34, 42]>>> tipp2 = tipp1>>> tipp2[1] = 8>>> tipp2[4, 8, 21, 33, 34, 42]>>> tipp1[4, 8, 21, 33, 34, 42]>>> tipp1 = [4, 13, 21, 33, 34, 42]>>> tipp1[4, 13, 21, 33, 34, 42]>>> tipp2[4, 8, 21, 33, 34, 42]>>> tipp2[0] = 3>>> tipp2[3, 8, 21, 33, 34, 42]>>> tipp1[4, 13, 21, 33, 34, 42]

84

Verwaltung von Listen mit Variablen

Jedes Datenobjekt hat (in Python) eine Identitätsnummer, einen Typ und einen bestimmten Wert.

>>> id([4, 13, 21, 33, 34, 42])12289008>>> type([4, 13, 21, 33, 34, 42])<type 'list'>>>> [4, 13, 21, 33, 34, 42][4, 13, 21, 33, 34, 42]

Variablen dienen in der Informatik dazu, Datenobjekte zu verwalten. Variablen werden an Datenobjekte angebunden, um die betreffenden Datenobjekte verwalten zu können.Eine Variable, die ein Datenobjekt referenziert, ist eine Art Name für das betreffende Datenobjekt. Mit dem Variablennamen kann man sich die Identitätsnummer, den Typ und den Wert des referenzierten Datenobjekts verschaffen.

>>> tipp1 = [4, 13, 21, 33, 34, 42]>>> id(tipp1)12289008>>> type(tipp1)<type 'list'>>>> tipp1[4, 13, 21, 33, 34, 42]

85

Verwaltung von Listen mit Variablen

>>> tipp1 = [4, 13, 21, 33, 34, 42]>>> tipp2 = tipp1>>> tipp2[1] = 8>>> tipp2[4, 8, 21, 33, 34, 42]>>> tipp1[4, 8, 21, 33, 34, 42]>>> tipp1 = [4, 13, 21, 33, 34, 42]>>> tipp1[4, 13, 21, 33, 34, 42]>>> tipp2[4, 8, 21, 33, 34, 42]>>> tipp2[0] = 3>>> tipp2[3, 8, 21, 33, 34, 42]>>> tipp1[4, 13, 21, 33, 34, 42]

86 Listen als Objekte

>>> L = []>>> L[]>>> L.append(3)>>> L[3]>>> L.append(5)>>> L[3, 5]>>> L.insert(1, 7)>>> L[3, 7, 5]>>> L.insert(0, 5)>>> L[5, 3, 7, 5]>>> L.remove(5)>>> L[3, 7, 5]>>> L.extend([4, 2])>>> L[3, 7, 5, 4, 2]

Listen sind (in Python) Objekte vom Typ list, die Daten verwalten und die dem Benutzer Operationen zur Verarbeitung der Daten zur Verfügung stellen.

>>> L[3, 7, 5, 4, 2]>>> L.__len__()5>>> L.__getitem__(1)7>>> L.__setitem__(1, 8)>>> L[3, 8, 5, 4, 2]>>> L.__delitem__(1)>>> L[3, 5, 4, 2]>>> L.__len__()4

87 Listenverarbeitung

>>> L = [1, 2, 3]>>> L[1, 2, 3]>>> id(L)12283056>>> L = L + [4]>>> L[1, 2, 3, 4]>>> id(L)12289008>>> L = L[1:]>>> L[2, 3, 4]>>> id(L)12257720>>> L = [1, 2] + L[1:]>>> L[1, 2, 3, 4]>>> id(L)12289008

>>> L = [1, 2, 3]>>> L[1, 2, 3]>>> id(L)12283536>>> L[1] = 5>>> L[1, 5, 3]>>> id(L)12283536>>> L.remove(5)>>> L[1, 3]>>> id(L)12283536>>> L.insert(1, 2)>>> L[1, 2, 3]>>> id(L)12283536

Erzeugung neuer Listen

Veränderung einer bestehenden Listen

L = Listenkonstruktor L.Listenoperation

88 Übungen

Bearbeiten Sie die Aufgaben des Abschnitts 1.6.10.7:

Aufgabe 7: Kopieren von Listen

Aufgabe 8: Ein Listenelement durch ein anderes ersetzen

Aufgabe 9: Eine Liste umkehren

Aufgabe 10: Seiteneffekte bei der Listenverarbeitung

89 Übungen

Implementieren Sie Quicksort.

5 7 28 31 4

572 831 4

pivot

ALGORITHMUS quicksort(liste)

wenn liste mehr als 1 Element enthält:

wähle ein Pivotelement pivot aus liste(z.B. das Element in der Listenmitte)

zerlege liste wie folgt:- kleinerPivot: alle Elemente, die kleiner als pivot sind- gleichPivot: alle Elemente, die gleich pivot sind- groesserPivot: alle Elemente, die größer als pivot sind

Rückgabe: quicksort(kleinerPivot) + gleichPivot + quicksort(groesserPivot)

sonst:

Rückgabe: liste

kleinerPivot

groesserPivot

gleichPivot

90 Teil 10

Zeichenketten

91 Caesar-Veschlüsselung

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

D E F G H I J K L M N O P Q R S T U V W X Y Z A B C

Schlüssel: 3Quelltext:

SALVECAESAR

Geheimtext:VDOYHFDHVDU

PYLZFOWBNQCYBUVNCBLGYCHYAYBYCGMWBLCZNYH

NTCZYLN

VDOYHFDHVD

U

92 Verarbeitung von Zeichen

>>> zeichen = 'A'>>> zeichen'A'>>> zahl = ord(zeichen)>>> zahl65>>> neuezahl = zahl + 3>>> neuezahl68>>> neueszeichen = chr(neuezahl)>>> neueszeichen'D'

Das "Verschieben von Buchstaben" im Alphabet kann man auch von einem Rechner ausführen lassen. Der folgende Python-Dialog zeigt, wie das gehen kann

93 Verarbeitung von Zeichenketten

Das folgende Programm zeigt, wie man eine Zeichenkette durchläuft und mit den Zeichen dieser vorgegebenen Zeichenkette eine neue Zeichenkette aufbaut.

def textkopieren(text): neuertext = "#" for zeichen in text: neuertext = neuertext + zeichen neuertext = neuertext + "#" return neuertext

# Eingabeausgangstext = input("Klartext: ")# Verarbeitungneuertext = textkopieren(ausgangstext)# Ausgabeprint("Ausgangstext: ", ausgangstext)print("neuer Text: ", neuertext)

94 Übungen

Entwickle eine Funktion textcodieren, mit deren Hilfe man kurze Texte mit dem Caesar-Verfahren verschlüsseln kann. Es soll z.B. folgender Python-Dialog mit dieser Funktion möglich sein:

Schlüssel: 3Quelltext:

SALVECAESAR

Geheimtext:VDOYHFDHVDU

>>> klartext = "SALVECAESAR">>> verschiebung = 3>>> textcodieren(klartext, verschiebung)'VDOYHFDHVDU'

95 Übungen

Entwickle auch eine Funktion textdecodieren, mit deren Hilfe man kurze Texte mit dem Caesar-Verfahren entschlüsseln kann. Es soll z.B. folgender Python-Dialog mit dieser Funktion möglich sein:

Schlüssel: 3Geheimtext:VDOYHFDHVDU

Klartext:

SALVECAESAR

>>> geheimtext = "VDOYHFDHVDU">>> verschiebung = 3>>> textdecodieren(geheimtext, verschiebung)'SALVECAESAR'

96 Teil 11

Didaktik

97 Programmierstile

imperativ: Am Anfang stehen Variablen zur Verwaltung von Daten und Anweisungen zur Verarbeitung der Daten.

objektorientiert: Am Anfang stehen Objekte, die dem Nutzer Dienste zur Verfügung stellen.

funktional: Am Anfang stehen Funktionen, die aus (Übergabe-) Daten (Rückgabe-) Daten erzeugt.

• wird vielfach praktiziert, da es historisch gesehen zuerst entwickelt wurde und da es relativ einfach erscheint• wird vielfach kritisiert, da das Denken stark an maschinenellem Vorgehen orientiert ist

• wird heute oft propagiert, da Objekte das menschliche Denken prägen und Objekte in der Softwareentwicklung heute von zentraler Bedeutung sind• wird auch kritisch gesehen, da Objekte in der Regel komplex sind und ihre Gestaltung und Verwaltung schwierig ist

• wird selten praktiziert, weil es weniger bekannt ist• von Befürwortern wird herausgestellt, weil es konzeptionelles Denken schult und technische Details in den Hintergrund rückt

objektbasiert: Am Anfang stehen vordefinierte Objekte, die die Basisoperationen für imperative Programme bereitstellen.

98 imperative Programmierung

Warum mit imperativer Programmierung anfangen?

• Nutzung einfacher und durchschaubarer Systeme (jede Zeile im Programm ist interpretierbar)• Idee der Automatisierbarkeit herausstellen und Ablaufmodellierung in den Vordergrund stellen•

99 Python als Programmiersprache

Implementierungen in Python sind meist "nahe am Algorithmus"

# Eingabezahl1 = int(input("Zahl 1: "))zahl2 = int(input("Zahl 2: "))# Verarbeitungprodukt = 0while zahl1 > 0: if zahl1 % 2 == 1: produkt = produkt + zahl2 zahl1 = zahl1 // 2 zahl2 = zahl2 * 2# Ausgabeprint("Produkt: ", produkt)

• einfache Syntax• wenige Programmierkonstrukte • mächtige und flexible Programmierkonstrukte (z.B. Listen)• klare Strukturierung durch Einrückungen• ...


def pivot(liste): return liste[len(liste) // 2];

def zerlege(liste, pivot): kleinerPivot = [] gleichPivot = [] groesserPivot = [] for element in liste: if element < pivot: kleinerPivot = kleinerPivot + [element] elif element > pivot: groesserPivot = groesserPivot + [element] else: gleichPivot = gleichPivot + [element] return [kleinerPivot, gleichPivot, groesserPivot]

def quicksort(liste): if len(liste) > 1: (kleinerPivot, gleichPivot, groesserPivot) = zerlege(liste, pivot(liste)) return quicksort(kleinerPivot) + gleichPivot + quicksort(groesserPivot) else: return liste

Implementierungen in Python sind meist "nahe am Algorithmus"

ALGORITHMUS quicksort(liste)

wenn liste mehr als 1 Element enthält:

wähle ein Pivotelement pivot aus liste(z.B. das Element in der Listenmitte)

zerlege liste wie folgt:- kleinerPivot: alle Elemente, die kleiner als pivot sind- gleichPivot: alle Elemente, die gleich pivot sind- groesserPivot: alle Elemente, die größer als pivot sind

Rückgabe: quicksort(kleinerPivot) + gleichPivot + quicksort(groesserPivot)

sonst:

Rückgabe: liste


Python erlaubt interaktives und experimentelles Vorgehen und ist somit "lernerfreundlich".

• Dialoge mit dem Python-Interpreter• einfaches, direktes Austesten von Programmteilen• ...

>>> (jung, erwachsen, alt) = (6, 9, 12)>>> jung6>>> erwachsen9>>> alt12>>> (jung, erwachsen, alt) = (erwachsen*4+alt*2, jung//2, erwachsen//3)>>> (jung, erwachsen, alt)(60, 3, 3)

>>> geheimtext = "VDOYHFDHVDU">>> verschiebung = 3>>> textdecodieren(geheimtext, verschiebung)'SALVECAESAR'


Python erlaubt "Stilmix" - passend zur jeweiligen Problemlösung.

• imperativ + funktional (+ objektorientiert)• ...

def pivot(liste): return liste[len(liste) // 2];

def zerlege(liste, pivot): kleinerPivot = [] gleichPivot = [] groesserPivot = [] for element in liste: if element < pivot: kleinerPivot = kleinerPivot + [element] elif element > pivot: groesserPivot = groesserPivot + [element] else: gleichPivot = gleichPivot + [element] return [kleinerPivot, gleichPivot, groesserPivot]

def quicksort(liste): if len(liste) > 1: (kleinerPivot, gleichPivot, groesserPivot) = zerlege(liste, pivot(liste)) return quicksort(kleinerPivot) + gleichPivot + quicksort(groesserPivot) else: return liste

...

..# Test

from random import randint

def datenErzeugen(anzahl, maximum): L = [] for i in range(anzahl): L = L + [randint(0, maximum)] return L

daten = datenErzeugen(10, 10000)print(daten)print(quicksort(daten))

103 Variablenkonzept

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. (Speichersemantik - klassisch imperative Sicht)

... (in der Regel) mit einem Datenobjekt verknüpft ist. (Zeigersemantik - objektorientierte Sicht)

... (in der Regel) mit einem Wert verknüpft ist. (Wertsemantik - funktionale Sicht)

Warum Zeigersemantik?

• Die Variablen-Sichtweise soll ein mentales Modell liefern, das als Erklärungsmodell möglichst universell einsetzbar ist. Wenn man sich für Python als Implementierungssprache entschieden hat, dann sind manche Phänomene nur mit Zeigersemantik erklärbar.• Zeigersemantik orientiert sich - genauso wie Speichersemantik - an einer natürlichen Form der Verwaltung von Gegenständen: Speichersemantik: Ein Name wird mit einem Ort verknüpft. (Lokalisierung)Zeigersemantik: Ein Name wird mit einem Gegenstand verknüpft. (Identifizierung)• Zeigersemantik kann - genauso wie Speichersemantik - gut auf enaktiver und ikonischer Ebene dargestellt werden.

104 Kontrollstrukturen

Kontrollstrukturen dienen dazu, die Reihenfolge der Abarbeitung von Anweisungen (eines Algorithmus / eines Programms festzulegen.

Kontrollstrukturen benutzt man also zur Ablaufmodellierung.

Ablaufmodellierung mit Kontrollstrukturen

• Kontrollstrukturen liefern Standard-Ablaufmodelle, mit deren Hilfe man komplexe Abläufe beschreiben kann.• Programmiersprachen wie Python stellen geeignete Anweisungstypen zur Implementierung dieser Standard-Ablaufmodelle bereit.• Zur Verdeutlichung von Kontrollstrukturen (bzw. der Semantik der entsprechenden Anweisungen) eignen sich Flussdiagramme / Programmablaufpläne.• Zur Ablaufmodellierung eignen sich Struktogramme / Pseudo-Programmiersprachen, die Kontrollstrukturen als Bausteine zur Verfügung stellen.

105 Unterprogramme

Unterprogramme sind eigenständige Programmeinheiten,. Sie werden innerhalb von Programmen benutzt, um Teilaufgaben zu implementieren.

Unterprogramme benutzt man zur Modellierung funktionaler Verarbeitungssituationen.

Funktionale Abstraktion mit Unterprogrammen

• Unterprogramme dienen dazu, eine Programmeinheit mit einem bestimmten Verarbeitungsverhalten durch eine Operation / Anweisung zu ersetzen. • Hierdurch lassen sich Codeduplizierungen vermeiden und Programme besser strukturieren.• Unterprogramme haben in der Regel Schnittstellen zur Übergabe und Rückgabe von Daten. • Python stellt ein flexibles Funktionskonzept zur Implementierung von Unterprogrammen zur Verfügung.• Funktionen ordnen Übergabedaten Rückgabedaten zu. Prozeduren sind Funktionen ohne Rückgaben.• Bei der Konzeption von Unterprogrammen kommt funktionale Abstraktion ins Spiel: Das "Wie" wird in die Unterprogramm-Deklaration verlagert, bei der Verwendung von Unterprogrammen (durch Aufrufe) spielt das "Was" die entscheidende Rolle.• Bei der Verwendung von Unterprogrammen spielt Datenverwaltung eine Rolle (lokale Variablen, Parameterübergabe). Es ist hilfreich, über adäquate Erklärungsmodelle für die Datenverwaltung zu verfügen.

106 Datenstrukturen

Datenstrukturen ermöglichen es, strukturierte Daten als Einheit zu verwalten.

Standardmodelle zur Verwaltung komplexer Daten

• Datenstrukturen liefern Standardmodelle zur Verwaltung komplexer Daten.• Programmiersprachen stellen geeignete Datenstrukturen zur Implementierung dieser Standardmodelle bereit.• Python stellt als zentrale Datenstruktur die Datenstruktur Liste zur Verfügung. Diese kann vielfältig zur Datenmodellierung benutzt werden.• Achtung: Die Verwendung von Listen in Python ist sehr einfach, wenn man sich an bestimmte Regeln hält, aber auch fehleranfällig, wenn man den objektorientierten Charakter von Listen nicht beachtet.

Documents

Python - Konzepte imperativer Programmierung Klaus Becker 2009