View
116
Download
7
Category
Preview:
Citation preview
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
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.
# 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
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
# 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
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# 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
Aufgabe (vgl. 1.6.7.1):
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
Aufgabe (vgl. 1.6.8.7):
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.
Aufgabe (vgl. 1.6.8.7):
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
# Testa = 2print(a)a = d(a)print(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?
65 Experimente mit Variablen
def d(x): y = x + x return y
# Testa = 2print(a)a = d(a)print(a)
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?
66 Experimente mit Variablen
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
# Testa = 2print(a)d()print(a)
def d(): global a a = a + a
# Testa = 2print(a)d()print(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.['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', ...]
[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.
79 Liste als sequentieller Datentyp
['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
80 Liste als sequentieller Datentyp
['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
81 Liste als sequentieller Datentyp
['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• ...
100 Python als Programmiersprache
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
101 Python als Programmiersprache
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'
102 Python als Programmiersprache
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.
Recommended