Kontrollstrukturen

Modul: Programmierung B-PRG
Grundlagen der Programmierung 1 – Teil 1 – V6
Kontrollstrukturen
Prof. Dr. Detlef Krömker
Professur für Graphische Datenverarbeitung
Institut für Informatik
Fachbereich Informatik und Mathematik (12)
Hier wird Wissen Wirklichkeit
Rückblick
Text – Strings – Characters
verschiedene Kodierungen: von ASCII bis Unicode
Kodierung vs. Schriftgestaltung
2
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
1
Unser heutiges Lernziel
‣
Verzweigung, Iteration (und Rekursion am Freitag) sind als
grundlegende mathematische und informatische Lösungsmethoden zu
erfassen und deren Realisierungen in Programmiersprachen sind
kennen zu lernen.
‣
Hierzu gehören insbesondere die verschiedenen Ausprägungen von
Schleifen (zur Iteration)
3
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Übersicht
Verzweigungen
Prinzipien
Graphische Repräsentationen
Iterative Grundstrukturen
Prinzipien
Schleifen: Realisierungsformen der Iteration
Kontrollstrukturen in Python
if – else – elif
for und while
break – continue - else
4
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
2
Kontrollstrukturen
Verzweigungen bilden zusammen mit den Schleifen die
Kontrollstrukturen moderner Programmiersprachen.
In allen imperativen und objektorientierten Sprachen sind sie in
unterschiedlichen Ausprägungen vorhanden.
Leistungsfähige Schleifenkonstrukte zusammen mit
Unterprogrammmethoden sind essentielle Konstituenten der
strukturierten Programmierung (dritte ProgrammiersprachenGeneration) aber auch der Objektorientierten Programmierung.
5
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Verzweigungen
‣
Eine Wertabhängige Fallunterscheidung ist sowohl in der Mathematik als auch
in der Informatik elementar für jede Art von Algorithmen.
‣
Aufgrund einer Bedingung wird der Programmfluss (die Abfolge der Ausführung
der Befehle) verzweigt. Wir unterscheiden die einfache (bedingte)
Verzweigung die den Programmfluss in zwei Pfade auftrennt und eine
mehrfache Verzweigung.
‣
Realisiert ist dies in den meisten Programmiersprachen sehr ähnlich, ungefähr
folgendermaßen:
if <Bedingung>
then <Aktionsfolge>
else <AlternativeAktionsfolge>
endif
6
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
3
Die mehrfache Verzweigung (Prinzip)
case <aVariable>
aValue1: <AktionsfolgeA>
aValue2: <AktikonsfolgeB>...
otherwise: <Aktionsfolge>
endcase
7
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Graphische Repräsentationen
Zur Darstellung von Programmstrukturen wurden schon sehr früh
graphische Repräsentationen (visuelle Sprachen) eingesetzt, die
später auch genormt wurden:
‣
Programmablaufpläne (und Datenflusspläne) nach DIN 66001
‣
Nassi-Schneidermann Diagramme nach DIN 66261
‣
Jackson-Diagramme
‣
UML Diagramme (hier allein 14 verschiedene Diagrammarten)
8
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
4
Programmablaufplan
ist ein Ablaufdiagramm für ein Computerprogramm, das auch als
Flussdiagramm (engl. flowchart) oder Programmstrukturplan
bezeichnet wird. Das Konzept der Programmablaufpläne stammt aus
den 1960er-Jahren.
9
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Nassi-Shneiderman-Diagramm
‣
Ein Nassi-Shneiderman-Diagramm (auch Struktogramme genannt)
ist ein Software-Entwurfshilfsmittel (auch Methode) für die strukturierte
Programmierung. Es ist genormt nach DIN 66261. Benannt wurde es
nach seinen Vätern Ike Nassi und Ben Shneiderman
‣
Die Methode zerlegt ein Gesamtproblem, das man mit dem
gewünschten Algorithmus lösen will, in immer kleinere Teilprobleme
‣
bis schließlich nur noch elementare Grundstrukturen wie Sequenzen
und Kontrollstrukturen zur Lösung des Problems übrig bleiben.
‣
Die beiden Autoren konnten mit ihren Diagrammen nachweisen, dass
in keinem Algorithmus ein unbedingter Sprung (GOTO) benötigt wird
10
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
5
Verzweigung: einfach-einseitig
Ablaufplan
Pseudocode
if <Bedingung>
then <Block 1>
endif
wahr
Nassi-Shneiderman
?
Bedingung
wahr
falsch
Block 1
Block 1
Bedingung = ?
11
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Zweifach- und Mehrfach-Verzweigungen
Ablaufplan
Pseudocode
if <Bedingung>
then <Block 1>
else <Block 2>
endif
case <Variable>Wert 1:
<B1>Wert 2:
<B2>...otherwise:
<Bn>endcase
12
Programmieren 1 – Teil 1 – V6
WS 2005/2006
wahr
Bedingung
Nassi-Shneiderman
falsch
wahr
Bedingung
Block 1
Variable =
Wert 1
B1
falsch
Block 2
Block 1
Wert 2
B2
Prof. Dr. Detlef Krömker
sonst
Bn
Wert1
1
B1
Wert2
B2
Block 2
Variable =
Bn
Hier wird Wissen Wirklichkeit
6
Kritik Programmablaufpläne
‣
schon bei mittelgroßen Algorithmen schnell unübersichtlich
‣
zur Verwendung von expliziten Sprunganweisungen (GOTO's)
verführen und damit die Produktion von "Spaghetti-Code" fördern und
wahr
?
falsch
Block 1
A
13
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
B
Hier wird Wissen Wirklichkeit
Programmablaufpläne: Kritik und Nutzung
‣
gut strukturierter Programmcode (ggf. als Pseudocode oder in einer
Skriptsprache wie Python) ist genauso übersichtlich (oder übersichtlicher!)
‣
Korrigiert man einen Fehler in einem Programm müsste dieses natürlich
im Ablaufplan „nachgezogen“ werden
‣
Programmablaufpläne werden heute in der Softwareentwicklung kaum
noch eingesetzt.
‣
Sie erleben allerdings in etwas modifizierter Form eine Renaissance in
Multimedia-Entwicklungsprozessen
‣
sind gut geeignet, elementare Strukturen der Programmierung zu
verdeutlichen.
14
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
7
Nassi-Shneiderman Diagramme
hatten ihre Blütezeit in den 1980er-Jahren, als die strukturierte
prozedurale Programmierung die Technik der Wahl war.
Mit dem Aufkommen objektorientierter Programmiersprachen in den
1990er Jahren verloren beide Methoden an Bedeutung, weil sie die
erweiterten Möglichkeiten, die diese Sprachen bieten, nicht adäquat
abbilden können.
Nassi-Shneidermann Diagramme „wachsen“ (verfeinern sich nach innen)
Variante: Jackson-Diagramm: wächst nach unten und außen
15
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Heute: UML-Diagramme
Unified Modeling Language (1997)
von der Object Management Group (OMG) entwickelt und standardisierte
Beschreibungssprache, um Strukturen und Abläufe in
Objektorientierten Softwaresystemen darzustellen
UML ist de-Facto-Norm für "technische Zeichnungen" von Programmen
und Abläufen.
standardisiert auch das Datenformat, in dem diese „Zeichnung“ abgelegt
wird (sog. XMI, eine XML-Variante)
16
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
8
UML 2.0
Strukturdiagramme
‣ Klassendiagramm (engl. class diagram)
‣ Objektdiagramm (engl. object diagram)
‣ Komponentendiagramm (engl. component diagram)
‣ Kompositionsstrukturdiagramm (auch: Montagediagramm, engl.
composite structure diagram)
‣ Verteilungsdiagramm (engl. deployment diagram)
‣ Paketdiagramm (engl. package diagram)
17
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
UML 2.0
Verhaltensdiagramme
‣ Anwendungsfalldiagramm (auch: Nutzfalldiagramm, use case diagram)
‣ Zustandsdiagramm (engl. statechart)
‣ Aktivitätsdiagramm (engl. activity diagram)
‣ Sequenzdiagramm und Sequenzdiagramm (engl. sequence diagram)
‣ Interaktionsübersichtsdiagramm (engl. interaction overview diagram)
‣ Kommunikationsdiagramm (engl. communication diagram)
‣ Zeitverlaufsdiagramm (engl. timing diagram)
Kollaborationsdiagramme (nicht zu verwechseln mit den gleichnamigen
Diagrammen in UML 1.x, die in UML 2.0 Kommunikationsdiagramme
heißen).
18
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
9
Realisierung in Programmiersprachen
In (fast) allen modernen Programmiersprachen werden
Verzweigungsstrukturen durch
if … then … else realisiert.
Unterschiede finden sich allenfalls in Details der Syntax, z.B. der Art der
Klammerung der Anweisungsblöcke.
Größere Unterschiede in Syntax und Semantik finden wir allerdings bei
Mehrfachverzweigungen:
‣ CASE …
‣ SWITCH … oder
‣ if … then … elif … elif …else.
19
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Realisierung in Python
if – else – elif
if expression:
suite
elif expression:
suite
elif expression:
suite
...
else:
suite
indent
4 Blanks (Leerzeichen) oder
1 Tab(ulator) besser nicht verwenden
„expression“ ist hierbei ein Ausdruck, der sich zu einem booleschen Wert
auswerten lässt,
„suite“ kennzeichnet eine beliebige Anweisungsfolge.
20
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
10
Syntax
if – else – elif
if_stmt
::=
"if" expression ":" suite
( "elif" expression ":" suite )*
["else" ":" suite]
suite ::= stmt_list NEWLINE | NEWLINE INDENT
statement+ DEDENT
statement
::= stateliest NEWLINE | compound_stmt
stmt_list
::= simple_stmt (";" simple_stmt)* [";"]
21
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Beispiel
a = 3
b = 2
if a < b:
pass
elif a == b:
a = a + 1
else: a = a - 1
print a
>>> ================================ RESTART =================
>>>
2
22
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
11
Iterative Grundstrukturen (1)
Die Iteration (von lateinisch iterare, "wiederholen"; engl. iteration) ist ein
grundlegender Lösungsansatz sowohl in der Mathematik als auch der
Informatik mit zwei verschiedenen Ausprägungen:
1. Iteration (in Mathematik und Informatik) ist eine Methode, sich der
Lösung eines Rechenproblems schrittweise, aber zielgerichtet
anzunähern. Sie besteht in der wiederholten Anwendung desselben
Rechenverfahrens.
Meistens iteriert man mit Rückkopplung: Die Ergebnisse eines
Iterationsschrittes (oder alle bisher erzielten Ergebnisse) werden als
Ausgangswerte des jeweils nächsten Schrittes genommen - bis das
Ergebnis zufrieden stellt.
23
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Iteration (Fortsetzung)
‣
Dazu muss man sicher sein (beweisen!), dass die Iterationsfolge
konvergiert und dass der Grenzwert mit der gesuchten Lösung
übereinstimmt.
‣
Die Geschwindigkeit der Konvergenz ist ein Maß dafür, wie brauchbar
die Iterationsmethode ist.
‣
Grundsätzlich wird ein iteratives Lösungsverfahren dann eingesetzt,
wenn das Ergebnis nicht geschlossen berechenbar ist (zum Beispiel
Gleichungen mit transzendenten Funktionen: sin x + cos x = x,
Bestimmung der Nullstellen ab dem Polynomgrad 5, etc.).
‣
Häufig ist eine gute Näherung schon befriedigend.
24
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
12
Ein klassisches Beispiel, die Regula Falsi:
Nullstellen (Wurzeln) eines Polynoms finden:
1. Schritt: Durch schätzen oder probieren ermittelt man ein Intervall (x1, x2)
wo eine Nullstelle von y = f(x) ungefähr liegen könnte, z.B. dadurch,
dass f(x1)>0, f(x2)<0
2. Einen besseren Wert x3 berechnen wir mit der Regula Falsi, die als
Näherung ein gerades Kurvenstück annimmt:
x3 = x 2 + f ( x 2 ) ⋅
x2 − x1
f ( x2 ) − f ( x1 )
3., 4. … i. … Diesen 2. Schritt wiederholen wir jeweils mit xi, und xi-1, bis
uns das Ergebnis „genau genug“ ist.
25
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Iterative Grundstrukturen (2)
2. In der Informatik wird auch von Iteration gesprochen, wenn ein
schrittweiser Zugriff auf Einzelelemente eines zusammengesetzten
Datentyps (Sammlungen), z.B. einen String, erfolgt.
Z.B wird wiederholt auf einen String mit veränderten Indexwert
zugegriffen: in einem Sting “otto“ sollen alle Kleinbuchstaben durch
Großbuchstaben ersetzt werden: “OTTO“.
Eine besondere Bedeutung hat dieses Vorgehen bei Sammlungen (engl.
collections) bei Strukturen wie Felder (engl. arrays), Listen, SchlüsselWert-Paaren (engl. Maps, Hashes, Dictionaries) oder Mengen (engl.
Sets), die wir allerdings detailliert erst in der übernächsten Vorlesung
kennen lernen werden.
26
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
13
Schleifen: Realisierungsformen der Iteration
In Programmiersprachen werden iterative Lösungen beider Art durch
Schleifen realisiert:
Eine Schleife ist eine Kontrollstruktur in imperativen
Programmiersprachen.
Sie wiederholt einen Teil des Codes – den so genannten Schleifenrumpf
oder Schleifenkörper – so lange, bis eine Abbruchbedingung eintritt.
Schleifen, die ihre Abbruchbedingung niemals erreichen oder Schleifen,
die keine Abbruchbedingungen haben, nennen wir Endlosschleifen.
27
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Endlosschleife
kann nur von „außen“ unterbrochen werden durch
ein Zurücksetzen (engl. reset), durch eine Unterbrechung (engl.
interrupt),
durch Ausnahmen (engl. exeptions),
Abschalten des Gerätes oder ähnliches.
Oft, aber nicht immer, ist eine Endlosschleife ein Programmierfehler, weil
das Programm nicht normal beendet werden kann.
Ist die Aufgabe des Programms jedoch z.B. eine Überwachung und
Reaktion auf einen externen (gemeldet durch einen Interrupt) oder
internen Fehlerzustand (gemeldet durch eine Exception), so kann
dieses Verhalten ggf. gewollt sein! Grundsätzlich aber VORSICHT!
28
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
14
Schleifenarten
‣
die kopfgesteuerte oder vorprüfende Schleife, bei der erst die
Abbruchbedingung geprüft wird, bevor der Schleifenrumpf durchlaufen
wird (meist durch das Schlüsselwort WHILE (= solange-bis) angezeigt.
‣
die fußgesteuerte oder nachprüfende Schleife, bei der nach dem
Durchlauf des Schleifenrumpfes die Abbruchbedingung überprüft wird,
z.B. durch ein Konstrukt REPEAT-UNTIL (= wiederholen-bis).
‣
die Zählschleife, eine Sonderform der kopfgesteuerten Schleife, meist
als FOR (= für ) -Schleife implementiert.
29
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Schleifen: Realisierungsformen der Iteration (1)
Schleifenart
vorprüfend
Ablaufplan
falsch
while (B) do
Block
Nassi-Shneidermann
B
B
wahr
Block
Block
nachprüfend
Block
repeat Block
until (B)
Block
falsch
wahr
B
30
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
B
Hier wird Wissen Wirklichkeit
15
Schleifen: Realisierungsformen der Iteration (2)
Schleifenart
Ablaufplan
Zählschleife
for(C=1;B;C++)do
Block
Nassi-Shneidermann
C=1
C=1
B
falsch
B
Block
wahr
C++
C++
Block
31
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Schleifen in Programmiersprachen
Bis auf die rein funktionalen Programmiersprachen (diese brauchen keine
Schleifen) realisieren alle modernen Programmiersprachen eine
Auswahl der hier dargestellten Grundstrukturen.
Sie unterscheiden sich in den benutzten Schlüsselwörtern, der Art der
Klammerung der Programmblöcke ((), {}, begin ... end, etc.) und des
Typs der Laufvariablen sowie deren „Inkrementierung“.
Mit Python werden wir hier eine sehr leistungsfähige Variante kennen
lernen.
32
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
16
Historische Notiz
Noch in den 60er-Jahren waren Sprunganweisungen (GOTO Sprungziel)
in Programmen üblich, was bei größeren Programmen nahezu zur
Unwartbarkeit führte, da sie schnell kaum noch überschaubar wurden
Das GOTO Sprungziel ist eine direkte Abbildung des Maschinenbefehls
JUMP Sprungziel – lediglich musste das Sprungziel jetzt keine
Programmadresse mehr sein, sondern konnte symbolisch als Zahl
oder Name angegeben werden.
33
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Historische Notiz (2)
Schon im Mai 1966 publizierten Böhm und Jacopini einen Artikel, in dem
sie zeigten, dass jedes Programm, das GOTO-Anweisungen enthält, in
ein GOTO -freies Programm umgeschrieben werden kann, das nur mit
Verzweigung (IF <Bedingung> THEN ... ELSE ... ) und einer Schleife
(WHILE <Bedingung> DO xxx) arbeitet (gegebenenfalls unter
Zuhilfenahme von etwas Kodeduplikation und der Einführung von
booleschen Variablen (true/false))
Im März 1968 veröffentlichte Edsger W. Dijkstra seinen legendären
Aufsatz „Go To Statement Considered Harmful“ (Dieser Aufsatz ist
das READING dieser Woche!)
34
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
17
Ein Beispiel für so genannten Spaghetti-Code
mit GOTO-Anweisungen:
GOTO 40
20 UmgeheDasProblem
GOTO 70
40 if (Durcheinander < TötlicheDosis) then GOTO 60
GOTO 20
60 RetteJungfrau
70
...
IF ((Durcheinander < TötlicheDosis)
THEN RetteJungfrau
ELSE UmgeheDasProblem
35
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Kontrollstrukturen in Python
for- und while-Anweisungen sind implementiert.
while_stmt
::=
"while" expression ":" suite
["else" ":" suite]
for_stmt
::=
"for" target list "in" expression_list ":" suite
["else" ":" suite]
target_list
::=
target ("," target)* [","]
target ::=
identifier
| "(" target_list ")"
| "[" target_list "]"
| attributeref
| subscription
| slicing
expression_list
::=
expression ( "," expression )* [","]
36
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
18
Anmerkung
target darf alles sein darf, was links von einem Zuweisungsoperator
stehen darf, also
‣
‣
37
einfache Variablen,
Tupel (x,y,z), etc.
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Die Mächtigkeit der Python for-Schleife
rührt daher, dass die Sequenz S durch einen beliebigen Sequenzdatentyp
(insbesondere dann macht die for-Schleife Sinn) repräsentiert wird,
also entweder
ein String,
eine Liste,
ein Tupel oder
eine Menge (set).
Man kann als expression also eine beliebige Variable eines solchen Typs
angeben, dann wird über alle Elemente iteriert.
38
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
19
Die Mächtigkeit der Python for-Schleife (2)
Es können aber auch Teilbereiche angegeben werden, durch Indizierung
oder wichtiger durch Teilbereichsbildung (Slicing), die
zusammenhängende Bereiche einer Sequenz extrahiert: Die
Bereichsgrenzen sind mit 0 und der Sequenzlänge vorbelegt:
‣
S[1:3] geht von Index 1 bis ausschließlich 3 (also 2)
‣
S[1:] geht vom Index 1 bis zum Ende
‣
S[:-1] nimmt alles bis auf das letzte Element (negative Indizes zählen
vom Ende)
39
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Die Mächtigkeit der Python for-Schleife (3)
Erweiterte Teilbereichsbildung S[i:j:k]
‣
S[::2] ergibt jedes zweite Element der Sequenz S von 0 bis zum Ende
‣
S[::-1] ergibt die Umkehrung der Sequenz
‣
S[4:1:-1] holt Elemente von rechts nach links ab Postion 4 (inklusive)
bis Position 1 (exklusive) ab.
40
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
20
Beispiele
>>> for x in "Ein Text":
print x
>>> for x in "Ein Text"[::-1]:
print x
E
i
n
t
x
e
T
T
e
x
t
41
n
i
E
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
In Zusammenhang mit Listen
Im Zusammenhang mit Listen sind gerade für for-Schleifen sogenannte
‣ Generator Ausdrücke (und List-Comprehension-Ausdrücke)
und die eingebaute Funktion
‣
range ([start,]stop [,step]
interessant. range liefert eine Liste von aufeinander folgenden Integern
zwischen start und stop.
Mit nur einem Parameter (stop) ergeben sich die Zahlen 0...stop-1. step ist
optional und ist die Schrittweite
42
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
21
Um eine Schleife (while oder for) ohne Erreichen der Bedingung zu
beenden, verwendet man die
break-Anweisung.
Um in die nächste Schleifeniteration zu springen (wobei der Rest des
Schleifenrumpfes übersprungen wird) verwendet man die
continue-Anweisung.
Beispiele siehe Skript
43
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Zusammenfassung
‣
Verzweigung, Iteration sind als grundlegende mathematische und
informatische Lösungsmethoden vorgestellt worden
‣
Realisierungen in Python
44
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
22
Fragen und (hoffentlich) Antworten
45
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
Ausblick
Funktionen – Prozeduren - Methoden
Danke für Ihre Aufmerksamkeit
46
Programmieren 1 – Teil 1 – V6
WS 2005/2006
Prof. Dr. Detlef Krömker
Hier wird Wissen Wirklichkeit
23