Modul: Programmierung B-PRG Grundlagen der … · 2 3 Programmieren 1 – Teil 1 – V6 Prof. Dr....

1

Hier wird Wissen Wirklichkeit

Modul: Programmierung B-PRGGrundlagen der Programmierung 1 – Teil 1 – V6

Kontrollstrukturen

Prof. Dr. Detlef KrömkerProfessur für Graphische DatenverarbeitungInstitut für InformatikFachbereich Informatik und Mathematik (12)

Prof. Dr. Detlef Krömker2 Hier wird Wissen WirklichkeitProgrammieren 1 – Teil 1 – V6WS 2005/2006

Rückblick

Text – Strings – Characters

verschiedene Kodierungen: von ASCII bis Unicode

Kodierung vs. Schriftgestaltung

2


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)


Übersicht

VerzweigungenPrinzipienGraphische Repräsentationen

Iterative GrundstrukturenPrinzipienSchleifen: Realisierungsformen der Iteration

Kontrollstrukturen in Pythonif – else – eliffor und whilebreak – continue - else

3


Kontrollstrukturen

Verzweigungen bilden zusammen mit den Schleifen die Kontrollstrukturen moderner Programmiersprachen.

In allen imperativen und objektorientierten Sprachen sind sie inunterschiedlichen Ausprägungen vorhanden.

Leistungsfähige Schleifenkonstrukte zusammen mit Unterprogrammmethoden sind essentielle Konstituenten der strukturierten Programmierung (dritte Programmiersprachen-Generation) aber auch der Objektorientierten Programmierung.


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

4


Die mehrfache Verzweigung (Prinzip)

case <aVariable>aValue1: <AktionsfolgeA>aValue2: <AktikonsfolgeB>...otherwise: <Aktionsfolge>endcase


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)

5


Programmablaufplan

ist ein Ablaufdiagramm für ein Computerprogramm, das auch als Flussdiagramm (engl. flowchart) oder Programmstrukturplanbezeichnet wird. Das Konzept der Programmablaufpläne stammt aus den 1960er-Jahren.


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, dassin keinem Algorithmus ein unbedingter Sprung (GOTO) benötigt wird

6


Verzweigung: einfach-einseitig

if <Bedingung>then <Block 1>endif

Nassi-ShneidermanAblaufplanPseudocode

?

Block 1

wahr

falsch

Bedingung = ?

Bedingungwahr

Block 1


Zweifach- und Mehrfach-Verzweigungen

case <Variable>Wert 1: <B1>Wert 2: <B2>...otherwise: <Bn>endcase

if <Bedingung>then <Block 1>else <Block 2>endif

Nassi-ShneidermanAblaufplanPseudocode

Bedingung

Block 1

wahr falsch

Block 2

Bedingungwahr falsch

Block 1 Block 2

Variable =

B1 BnB2

Wert 1 Wert 2 sonst

Variable =

B1 BnB2

Wert1 1

Wert2

7


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

?

Block 1

wahr

falsch

A B


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.

8


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


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)

9


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)


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

10


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.


Realisierung in Pythonif – else – elif

if expression:suite

elif expression:suite

elif expression:suite

...else:

suite

„expression“ ist hierbei ein Ausdruck, der sich zu einem booleschen Wert auswerten lässt,

„suite“ kennzeichnet eine beliebige Anweisungsfolge.

indent

4 Blanks (Leerzeichen) oder1 Tab(ulator) besser nicht verwenden

11


Syntaxif – else – elif

if_stmt ::= "if" expression ":" suite( "elif" expression ":" suite )*["else" ":" suite]

suite ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT

statement ::= stateliest NEWLINE | compound_stmtstmt_list ::= simple_stmt (";" simple_stmt)* [";"]


Beispiel

a = 3b = 2if a < b:

passelif a == b:

a = a + 1else: a = a - 1print a

>>> ================================ RESTART =================>>> 2

12


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 zielgerichtetanzunä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.


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.

13


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:

3., 4. … i. … Diesen 2. Schritt wiederholen wir jeweils mit xi, und xi-1, bis uns das Ergebnis „genau genug“ ist.

)()()(

12

12223 xfxf

xxxfxx−−

⋅+=


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üssel-Wert-Paaren (engl. Maps, Hashes, Dictionaries) oder Mengen (engl. Sets), die wir allerdings detailliert erst in der übernächsten Vorlesung kennen lernen werden.

14


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 Schleifenrumpfoder Schleifenkörper – so lange, bis eine Abbruchbedingung eintritt.

Schleifen, die ihre Abbruchbedingung niemals erreichen oder Schleifen, die keine Abbruchbedingungen haben, nennen wir Endlosschleifen.


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!

15


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.


Schleifen: Realisierungsformen der Iteration (1)

nachprüfend

repeat Block until (B)

vorprüfend

while (B) doBlock

Nassi-ShneidermannAblaufplanSchleifenart

B

Block

wahr

falsch B

Block

B

Block

wahrfalschB

Block

16


Schleifen: Realisierungsformen der Iteration (2)

Zählschleifefor(C=1;B;C++)do

Block

Nassi-ShneidermannAblaufplanSchleifenart

B

Block

wahr

falsch

C=1

C++

B

Block

C=1

C++


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.

17


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.


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

18


Ein Beispiel für so genannten Spaghetti-Code

mit GOTO-Anweisungen:

GOTO 4020 UmgeheDasProblem

GOTO 7040 if (Durcheinander < TötlicheDosis) then GOTO 60

GOTO 2060 RetteJungfrau70 ...

IF ((Durcheinander < TötlicheDosis)THEN RetteJungfrauELSE UmgeheDasProblem


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 )* [","]

19


Anmerkung

target darf alles sein darf, was links von einem Zuweisungsoperator stehen darf, also

‣ einfache Variablen, ‣ Tupel (x,y,z), etc.


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.

20


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)


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.

21


Beispiele

>>> for x in "Ein Text":print x

Ein

Text

>>> for x in "Ein Text"[::-1]:print x

txeT

niE


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

22


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


Zusammenfassung

‣ Verzweigung, Iteration sind als grundlegende mathematische und informatische Lösungsmethoden vorgestellt worden

‣ Realisierungen in Python

23


Fragen und (hoffentlich) Antworten


Ausblick

Danke für Ihre Aufmerksamkeit

Funktionen – Prozeduren - Methoden

Modul: Programmierung B-PRG Grundlagen der … · 2 3 Programmieren 1 – Teil 1 – V6 Prof. Dr....

Documents

Transcript of Modul: Programmierung B-PRG Grundlagen der … · 2 3 Programmieren 1 – Teil 1 – V6 Prof. Dr....