algorithmische grundlagen einführung in das programmieren ... · 1.5.3 graphische ausgabe mit...

Vorlesung 06

1. Elemente des Programmierens

1.2 Grundlegende Daten-Typen

1.3 Verzweigungen und Schleifen

1.4 Arrays

1.5 Ein- und Ausgabestandard output

standard input

standard drawing

1.6 Abschluss-Beispiel: Page Rank

1.5.35

1.5.3 Graphische Ausgabe mit stddraw

Das Modul stddraw.py bietet einfache Mittel zur graphischen Ausgabe.

Damit konnen z.B. Graphiken gemalt oder bewegte Bilder dargestellt werden.

python3 filter-DWD.py 15 < Jena-Wetterdaten.txt | \

python3 jahres-mittel.py | \

python3 kjahres-mittel.py 30 | \

python3 male-kurve-mit-achsen.py 1830 2022 0 20

python3 kugel-3.py 2 0.05 0.095

1.5.36

Graphische Ausgabe mit dem Modul stddraw (standard drawing)

Das Modul stddraw ermoglicht das Malen auf eine”abstrakte“ Leinwand aus Punkten

(Standardgroße 512ˆ 512 Pixel).

p0, 0q

p1, 1q

x-Achse

y-A

chse

‚

Jeder Punkt auf der Leinwand hat Koordinaten px , yq mit Standard 0 ď x , y ď 1.

Es konnen Punkte, Linien, Kreise, Rechtecke etc. gemalt werden.

Die Koordinaten der Eckpunkte der Leinwand konnen verandert werden . . .

stddraw – Einfuhrung 1.5.37




p0, 0q

p1, 1q

x-Achse

y-A

chse

‚

p0.5, 0.3q


Es konnen Punkte, Linien, Kreise, Rechtecke etc. gemalt werden.

Die Koordinaten der Eckpunkte der Leinwand konnen verandert werden . . .





p´2.5, 3.2q

p2, 5q

x-Achse

y-A

chse

‚

p0.25, 3.74q


Es konnen Punkte, Linien, Kreise, Rechtecke etc. gemalt werden.Die Koordinaten der Eckpunkte der Leinwand konnen verandert werden . . .


Zeichne ein Dreieck

Aufgabe:Zeichne ein Dreieck mit den Eckpunkten p0, 0q, p1, 0q, und p0.5,

?3.0{2q,

und zeichne einen Punkt in die Mitte des Dreiecks.

Wir mussen also die Linienvon p0, 0q nach p1, 0q,von p1, 0q nach p0.5,

?3.0{2q, und

von p0.5,?

3.0{2q nach p0, 0qund einen Punkt p0.5,

?3.0{6q zeichnen und das gemalte Bild anzeigen.

Das geht mit folgenden stddraw-Funktionen.

stddraw.line(x0, y0, x1, y1) male eine Linie von px0, y0q zu px1, y1q

stddraw.point(x, y) male einen Punkt an px , yq

stddraw.show(t) zeige das Bild im standard-drawing-Fenster und

warte t Millisekunden;

falls t weggelassen wird, dann

warte, bis das Fenster vom Nutzer geschlossen wirdstddraw – Einfuhrung 1.5.38

#--------------------------------------------------------------------

# dreieck.py

#--------------------------------------------------------------------

# Zeichne mit stddraw ein Dreieck mit den Eckpunkten (0,0), (1,0)

# und (0.5, sqrt(3.0)/2), und einen Punkt in die Mitte des Dreiecks.

#--------------------------------------------------------------------

import math

import stddraw

t = math.sqrt(3.0)/2

# Male eine Linie von (0,0) nach (1,0).

stddraw.line(0, 0, 1, 0)

# Male eine Linie von (0,0) nach (0.5,t).

stddraw.line(0.0, 0.0, 0.5, t)

# Male eine Linie von (0.5,t) nach (1,0).

stddraw.line(0.5, t, 1, 0)

# Male einen Punkt an (0.5, t/3).

stddraw.point(0.5, t/3)

# Zeige das Bild an.

stddraw.show()

#--------------------------------------------------------------------

# python3 dreieck.py

$ python3 dreieck.py


Anderung von StandardwertenLeinwandgroße, Skalierung der Achsen, Stiftdicke, Stiftfarbe

Leinwandgroße:

stddraw.setCanvasSize(w, h) setze die Leinwandgroße auf w -mal-h Pixel

(Default fur w (Breite) und h (Hohe) ist 512)

Skalierung der Achsen:

stddraw.setXscale(x0, x1) setze den Bereich der x-Koordinaten auf x0 ď x ď x1

(Default ist x0 “ 0 und x1 “ 1)

stddraw.setYscale(y0, y1) setze den Bereich der y -Koordinaten auf y0 ď y ď y1

(Default ist y0 “ 0 und y1 “ 1)

Stiftdicke und -farbe:

stddraw.setPenRadius(r) setze die Stiftdicke auf r

(Default-Wert von r ist 0.005)

stddraw.setPenColor(c) setzt die Farbe des Stiftes auf c; c kann z.B. stddraw.BLUE sein

mit Farben BLACK, BLUE, CYAN, DARK GRAY, GRAY, GREEN, LIGHT GRAY, MAGENTA, ORANGE, PINK, RED, WHITE, YELLOWstddraw – Einfuhrung 1.5.40

#--------------------------------------------------------------------------------------------------

# dreieck-bunt.py

#--------------------------------------------------------------------------------------------------

# Zeichne das Dreieck mit dem Punkt wie in dreieck.py.

# Verandere die Standardparameter Leinwandgroße, Skalierung der Achsen, Stiftdicke und Stiftfarbe.

#--------------------------------------------------------------------------------------------------

import math, stddraw

# Setze die Leinwandgroße und die Skalierung der Achsen.

stddraw.setCanvasSize(800,800) # Leinwandgroße

stddraw.setXscale(-0.3,1.3) # Skalierung der x-Achse

stddraw.setYscale(-0.3,1.3) # Skalierung der y-Achse

stddraw.setPenRadius(0.01) # andere die Stiftdicke

stddraw.line(0, 0, 1, 0) # male die Linie von (0,0) nach (1,0)

t = math.sqrt(3.0)/2

stddraw.setPenColor(stddraw.BLUE) # andere die Stiftfarbe

stddraw.line(0, 0, 0.5, t) # male die Linie von (0,0) nach (0.5,t)


stddraw.setPenColor(stddraw.RED) # andere die Stiftfarbe

stddraw.line(0.5, t, 1, 0) # male die Linie von (0.5,t) nach (1,0)


stddraw.setPenColor(stddraw.CYAN) # andere die Stiftfarbe

stddraw.point(0.5, t/3) # male einen Punkt an (0.5, t/3)

stddraw.show() # zeige das Bild an

$ python3 dreieck-bunt.py


Graphische Darstellung der Jenaer Jahresdurchschnittstemperaturen (Teil 1)

python3 filter-DWD.py 15 < Jena-Wetterdaten.txt | python3 jahres-mittel.py

liefert Ausgabe

1824 13.50

1825 13.38

1826 13.27

1827 12.92

1828 13.07

1829 10.47

...

stddraw – Messwerte als Punkte darstellen 1.5.42


python3 filter-DWD.py 15 < Jena-Wetterdaten.txt | python3 jahres-mittel.py

liefert Ausgabe

1824 13.50

1825 13.38

1826 13.27

1827 12.92

1828 13.07

1829 10.47

...

Aufgabe: Wir fassen jede Zeile als x- und y -Wert eines Punktes aufund wollen alle diese Punkte zeichnen.

Die x-Koordinaten sind im Bereich 1824 . . . 2018,

und die y -Koordinaten sind im Bereich 0 . . . 20.



Aufgabe: Wir fassen jede Zeile als x- und y -Wert eines Punktes aufund wollen alle diese Punkte zeichnen.

Die x-Koordinaten sind im Bereich 1824 . . . 2018,und die y -Koordinaten sind im Bereich 0 . . . 20.

Das Programm soll fur unterschiedliche”Punktarten“ arbeiten (Hochst-, Tiefsttemperatur, . . . )

Ablauf des Programms:

Lies den Bereich der x- und y -Koordinaten von der Kommandozeile.Lies alle Punkte von standard input,

male sie auf die Leinwandund zeige die Leinwand an.


Grundsatzliche Alternativen fur”Lies alle Punkte von standard input,

und male sie auf die Leinwand“

(A) Male jeden Punkt direkt nach dem Einlesen.

fur jede Eingabezeile (Zeile “Punkt):bestimme den entsprechenden Punktmale ihn

(B) zuerst: lies alle Punkte einund speichere sie

danach: male jeden Punkt

fur jede Eingabezeile (Zeile “Punkt):speichere den entsprechenden Punkt

fur jeden gespeicherten Punkt:male ihn






for zeile in sys.stdin:

punkt = str.split(zeile, ' ')

x_wert = float(punkt[0])

y_wert = float(punkt[1])

stddraw.point(x_wert,y_wert)














stddraw.point(x_wert,y_wert)





xwerte = []

ywerte = []



xwerte += [ float(punkt[0]) ]

ywerte += [ float(punkt[1]) ]

# Der i-te Punkt ist (xwerte[i],ywerte[i]).

for i in range(len(xwerte)):

stddraw.point(xwerte[i],ywerte[i])stddraw – Messwerte als Punkte darstellen 1.5.43

#-----------------------------------------------------------------------------------------

# male-punkte.py

#-----------------------------------------------------------------------------------------

# Lies x0, x1, y0 und y1 von der Kommandozeile. Lies Wertepaare x,y von standard input

# und male sie als Punkte auf eine Leinwand mit x-Achse x0..x1 und y-Achse y0..y1.

#-----------------------------------------------------------------------------------------

import sys, stddraw

# Richte die Achsen der Leinwand ein und bereite den Stift vor.

stddraw.setXscale(float(sys.argv[1]), float(sys.argv[2]))

stddraw.setYscale(float(sys.argv[3]), float(sys.argv[4]))

stddraw.setPenRadius(0.01)

# Standard input liefert zeilenweise x- und y-Werte von Punkten.

# Jeder dieser Punkte wird gemalt, die Leinwand wird angezeigt,

# und anschließend wird ein bisschen gewartet.





stddraw.point(x_wert, y_wert)

stddraw.show(30)

stddraw.show()

#-----------------------------------------------------------------------------------------# python3 filter-DWD.py 15 < Jena-Wetterdaten.txt | python3 jahres-mittel.py | python3 male-punkte.py 1820 2020 -1 20

#

# python3 filter-DWD.py 16 < Jena-Wetterdaten.txt | python3 jahres-mittel.py | python3 male-punkte.py 1820 2020 -8 12


#-----------------------------------------------------------------------------------------

# male-punkte.py

#-----------------------------------------------------------------------------------------

# Lies x0, x1, y0 und y1 von der Kommandozeile. Lies Wertepaare x,y von standard input

# und male sie als Punkte auf eine Leinwand mit x-Achse x0..x1 und y-Achse y0..y1.

#-----------------------------------------------------------------------------------------

import sys, stddraw

# Richte die Achsen der Leinwand ein und bereite den Stift vor.




# Standard input liefert zeilenweise x- und y-Werte von Punkten.

# Jeder dieser Punkte wird gemalt, die Leinwand wird angezeigt,

# und anschließend wird ein bisschen gewartet.





stddraw.point(x_wert, y_wert)

stddraw.show(30)

stddraw.show()

#-----------------------------------------------------------------------------------------# python3 filter-DWD.py 15 < Jena-Wetterdaten.txt | python3 jahres-mittel.py | \

# python3 kjahres-mittel.py 9 | python3 male-punkte.py 1820 2020 -1 20

#

# python3 filter-DWD.py 16 < Jena-Wetterdaten.txt | python3 jahres-mittel.py | \

# python3 kjahres-mittel.py 9 | python3 male-punkte.py 1820 2020 -8 12stddraw – Messwerte als Punkte darstellen 1.5.44


Nun wollen wir noch aufeinanderfolgende Punkte mit einem Strich verbinden,

damit es eine schone Kurve gibt,

Ablauf des Programms:

lies alle Punkte ein

fur alle aufeinanderfolgenden Punkte:

male einen Strich mit ihnen als Endpunkte

und danach werden wir noch Achsen mit Skalen malen.

stddraw – Messwerte als Kurve darstellen 1.5.45

#----------------------------------------------------------------------------------------------------------

# male-kurve.py

#----------------------------------------------------------------------------------------------------------

# Lies x0, x1, y0 und y1 von der Kommandozeile. Lies Wertepaare x,y von standard input und male sie

# als mit Strichen verbundene Punkte auf eine Leinwand mit x-Achse x0..x1 und y-Achse y0..y1.

#----------------------------------------------------------------------------------------------------------

import sys, stddraw

# Bereite die Leinwand und den Stift vor.

# Die Skalenbereiche der Achsen werden von der Kommandozeile gelesen.




# Wir lesen zuerst alle Punkte von standard input und schreiben

# alle x-Werte in ein Array x[], und alle y-Werte in ein Array y[].

# Dann ist (x[i],y[i]) jeweils ein Punkt.

xwerte = []

ywerte = []





# Wir zeichnen jeweils eine Linie zwischen zwei aufeinanderfolgenden Punkten.

# Da der letzte Punkt keinen "Nachfolger" hat, ist er kein Startpunkt einer Linie.

for i in range(len(xwerte)-1):

stddraw.line( xwerte[i], ywerte[i], xwerte[i+1], ywerte[i+1] )

stddraw.show() # Zeige das Bild an.stddraw – Messwerte als Kurve darstellen 1.5.46

#----------------------------------------------------------------------------------------------------------

# male-kurve.py

#----------------------------------------------------------------------------------------------------------



#----------------------------------------------------------------------------------------------------------

import sys, stddraw









xwerte = []

ywerte = []









stddraw.show() # Zeige das Bild an.



python3 male-kurve.py 1820 2020 -1 20


#----------------------------------------------------------------------------------------------------------

# male-kurve.py

#----------------------------------------------------------------------------------------------------------



#----------------------------------------------------------------------------------------------------------

import sys, stddraw









xwerte = []

ywerte = []









stddraw.show() # Zeige das Bild an.



python3 kjahres-durchschnitte.py 9 | \

python3 male-kurve.py 1820 2020 -1 20


Und abschließend zeichnen wir noch beschriftete Achsen dazu.


#-----------------------------------------------------------------------------------------

# male-kurve-mit-achsen.py

#-----------------------------------------------------------------------------------------

# Lies xmin, xmax, ymin und ymax von der Kommandozeile.

# Lies Wertepaare x,y von standard input

# und male sie als mit Strichen verbundene Punkte auf eine Leinwand

# mit x-Achse xmin..xmax und y-Achse ymin..ymax.

#-----------------------------------------------------------------------------------------

import sys, stddraw

# Wir lesen die Punkte von standard input.

# Wir schreiben alle x-Werte in ein Array x[], und alle y-Werte in ein Array y[].


xwerte = []

ywerte = []





# Um die Leinwand vorzubereiten,

# lesen wir von der Kommandozeile die Langen der x- und der y-Achse.

xmin = float(sys.argv[1])

xmax = float(sys.argv[2])

ymin = float(sys.argv[3])

ymax = float(sys.argv[4])

# Zum Malen der Achsen und deren Beschriftung brauchen wir an jeder Seite etwas Rand.

stddraw.setXscale(xmin-10, xmax+10)

stddraw.setYscale(ymin-2, ymax+2)


# Male die x-Achse und die y-Achse des Koordinatensystems (in blau).

stddraw.setPenColor(stddraw.BLUE)

stddraw.line(xmin,ymin, xmax,ymin)

stddraw.line(xmin,ymin, xmin,ymax)






# Beschrifte die Achsen des Koordinatensystems.

for i in range(int(ymin), int(ymax+1), int(ymax-ymin)//10): # beschrifte die y-Achse

stddraw.line(xmin-2,i, xmin+2,i) # male einen kleinen waagerechten Strich uber die y-Achse in Hohe i

stddraw.text(xmin-5, i, str(i)) # schreibe i links neben die y-Achse in Hohe i

for i in range(int(xmin), int(xmax+1), int(xmax-xmin)//10): # beschrifte die x-Achse

stddraw.line(i,ymin-0.2, i, ymin+0.2) # male einen kleinen senkrechten Strich an Stelle i der x-Achse

stddraw.text(i, ymin-1, str(i)) # schreibe i etwas unter die x-Achse an Stelle i

# Die Linien zwischen aufeinanderfolgenden (x,y)-Paaren werden gemalt.

stddraw.setPenColor(stddraw.BLACK)




stddraw.show(20)

stddraw.show()

#----------------------------------------------------------------------------------


















stddraw.show(20)

stddraw.show()

#----------------------------------------------------------------------------------


# python3 kjahres-mittel.py 9 | python3 male-kurve-mit-achsen.py 1831 2018 -1 20

#stddraw – Messwerte als Kurve darstellen 1.5.49

















stddraw.show(20)

stddraw.show()

#----------------------------------------------------------------------------------


# python3 kjahres-mittel.py 9 | python3 male-kurve-mit-achsen.py 1831 2018 -5 12

#stddraw – Messwerte als Kurve darstellen 1.5.49

Zeichnen des Graphs einer Funktion

Zum Zeichnen des Graphs einer Funktion muss das Programm die Argument-/Wert-Paare,die male-kurve.py von standard input einliest, selbst erzeugen.

Wenn der Graph der Funktion f pxq im Bereich l ď x ď r gezeichnet werden soll,

§ muss man festlegen, wieviele Funktionswerte man im Bereich l ď x ď r berechnen will(das Intervall l . . . r wird in gleichmaßige Abschnitte unterteilt),

Wenn Funktionswerte fur n Argumente im Intervall l ď x ď r berechnet werden sollen,

haben die Argumente Abstand l´rn´1 und sind l , l `1 ¨ r´l

n´1 , l `2 ¨ r´ln´1 , . . . , l ` pn ´ 1q ¨

r ´ l

n ´ 1loooooooooomoooooooooon

“r

.

§ die Argument-Wert-Paare px , f pxqq berechnen und

§ die Funktionswerte aufeinanderfolgender Argumente durch eine Linie verbinden.

Man beachte, dass stets nur eine Naherung berechnet wird,deren Qualitat von der Anzahl der berechneten Funktionswerte abhangt.

stddraw – Graph einer Funktion darstellen 1.5.50

#-----------------------------------------------------------------------------------------------------------

# functiongraph.py (so ahnlich wie im Buch)

#-----------------------------------------------------------------------------------------------------------

# Der Graph der Funktion f(x) = sin(4x)+sin(20x) wird im Intervall -pi/2..pi/2 gezeichnet.

# Von der Kommandozeile wird die Sampling-Dichte n (d.h. die Anzahl der zu berechnenden Punkte) eingelesen.

#-----------------------------------------------------------------------------------------------------------

import math, sys, stddraw

# Lies n von der Kommandozeile

# und erzeuge Arrays fur die x-Werte und die y-Werte des Graph der Funktion f.

n = int(sys.argv[1])

x_werte = []

y_werte = []

# Berechne fur n x-Werte, die gleichmaßig uber das Intervall -pi/2..pi/2 verteilt sind,

# jeweils den zugehorigen y-Wert f(x)=sin(4x)+sin(20x).

# Die x_werte sind -pi/2, -pi/2+1*pi/(n-1), -pi/2+2*pi/(n-1),..., -pi/2+(n-1)*pi/(n-1) .

# Speichere den x-Wert in x_werte[] und den zugehorigen y-Wert in y_werte.

# Am Ende gilt f(x_werte[i])==y_werte[i] fur i in range(n).

for i in range(n):

x_werte += [ -math.pi/2 + i * math.pi/(n-1) ]

y_werte += [ math.sin(4*x_werte[i]) + math.sin(20*x_werte[i]) ]

# Richte die Leinwand ein.

stddraw.setXscale(-math.pi/2, math.pi/2)

stddraw.setYscale(-2, 2)

# Male die Punkte und verbinde sie mit Strichen.

for i in range(n-1):

stddraw.line(x_werte[i], y_werte[i], x_werte[i+1], y_werte[i+1])


stddraw.show()stddraw – Graph einer Funktion darstellen 1.5.51

#-----------------------------------------------------------------------------------------------------------


#-----------------------------------------------------------------------------------------------------------



#-----------------------------------------------------------------------------------------------------------





x_werte = []

y_werte = []






for i in range(n):










stddraw.show()

python3 functiongraph.py 21



#-----------------------------------------------------------------------------------------------------------


#-----------------------------------------------------------------------------------------------------------



#-----------------------------------------------------------------------------------------------------------





x_werte = []

y_werte = []






for i in range(n):










stddraw.show()




Weitere stddraw-Funktionen: (1) Kreise malen

stddraw.circle(x, y, r) male einen Kreis

mit Mittelpunkt px , yq und Radius r

import stddraw

x = 2

y = 3

r = 4

stddraw.setXscale(0, 6)

stddraw.setYscale(0, 6)

stddraw.circle(x, y, r)

stddraw.show()

p2, 3q

4

stddraw – weitere Funktionen 1.5.52

(2) Quadrate malen

stddraw.square(x, y, r) male ein Quadrat

mit Mittelpunkt px , yq und Radius r

import stddraw

x = 2

y = 3

r = 4



stddraw.square(x, y, r)

stddraw.show()

p2, 3q

4

4


(3) Vielecke malen

stddraw.polygon(x, y) male ein Vieleck mit den Ecken

px[0], y[0]q, px[1], y[1]q, . . .

(x und y sind Arrays)

import stddraw

x = [1,0,3,4,5]

y = [2,3,4,6,1]



stddraw.polygon(x,y)

stddraw.show()

p1, 2q

p0, 3q

p3, 4q

p4, 6q

p5, 1q


(3) Vielecke malen

stddraw.polygon(x, y) male ein Vieleck mit den Ecken

px[0], y[0]q, px[1], y[1]q, . . .

(x und y sind Arrays)

import stddraw

x = [1,0,3,4,5]

y = [2,3,4,6,1]



stddraw.polygon(x,y)

stddraw.show() p1, 2q

p0, 3q

p3, 4q

p4, 6q

p5, 1q


Alle Formen konnen auch gefullt gemalt werden mittelsstddraw.filledCircle(x,y,r), stddraw.filledSquare(x,y,r),

stddraw.filledPolygon(x,y).

stddraw.filledPolygon(x, y) male ein ausgefulltes Vieleck mit den Ecken

px[0], y[0]q, px[1], y[1]q, . . . (x und y sind Arrays)

import stddraw

x = [1,0,3,4,5]

y = [2,3,4,6,1]



stddraw.setPenColor(stddraw.RED)

stddraw.filledPolygon(x,y)

stddraw.show()


Sonstige stddraw-Funktionen

Male ein Rechteck:

stddraw.rectangle(x,y, w,h) male ein Rechteck mit Punkt (x,y) unten links,

Breite w und Hohe h

stddraw.filledRectangle(x,y, w,h) male ein gefulltes Rechteck . . .

Schreibe Text:

stddraw.text(x,y, s) schreibe String s zentriert an Punkt (x,y)

stddraw.setFontSize(n) setze die Buchstabengroße auf n (Standard 12)

stddraw.setFontFamily(f) setze den Zeichensatz auf f (Standard helvetica)

Losche die Leinwand:

stddraw.clear(c) losche die Leinwand und farbe jedes Pixel mit Farbe c


import stddraw

stddraw.clear(stddraw.YELLOW)

stddraw.square(0.2, 0.8, 0.1)

stddraw.filledSquare(0.8, 0.8, 0.2)

stddraw.setPenColor(stddraw.GREEN)

xd = [0.1, 0.2, 0.3, 0.2]

yd = [0.2, 0.3, 0.2, 0.1]

stddraw.filledPolygon(xd, yd)

stddraw.setPenColor(stddraw.RED)

stddraw.filledCircle(0.8, 0.2, 0.2)

stddraw.setFontSize(20)

stddraw.text(0.8,0.8, 'großer roter Text')

stddraw.show()

Bilder konnen mittels Klick auf die rechte Maustasteoder mit stddraw.save(dateiname) gespeichert werden.

Die Dateinamenendung muss .jpg oder .png sein.


Bewegte Bilder

Zeigt man schnell hintereinander ahnliche Bilder, so sieht es aus, als ob sich etwas bewegt.

stddraw – bewegte Bilder 1.5.58

Aufgabe: Lasse eine Kugel quer uber die Leinwand rollen

Die Kugel soll von der unteren linken Ecke der Leinwand (Punkt p0, 0q)

auf der Diagonalen in die obere rechte Ecke der Leinwand rollen (Punkt p1, 1q).

Die Punkte auf der Diagonalen haben die gleiche x- und y -Koordinate.

Wir erhalten die Punkte der rollenden Kugel, indem wir einen Abstand wahlen,

den wir immer wieder zur x- und y -Koordinate der Kugel addieren,

bis die beiden Koordinaten 1 (oder großer) geworden sind.

Die Leinwand mit der Kugel an ihrer aktuellen Position wird jedesmal fur eine kleine Zeitspanne

angezeigt, wenn die Kugel ihre neue Position erhalten hat.


# kugel-1.py

#--------------------------------------------------------------------------------

# Eine Kugel rollt auf der Diagonalen von links nach rechts durch das Bild.

# Das wird als "Film" durch aufeinanderfolgende Bilder angezeigt.

# Von der Kommandozeile wird ein int zeitspanne (Anzeigezeit jedes Bildes in ms)

# und ein float abstand (beeinflusst den Abstand der Kugel von Bild zu Bild) gelesen.

#--------------------------------------------------------------------------------

import sys, stddraw

zeitspanne = int(sys.argv[1])

abstand = float(sys.argv[2])

RADIUS = 0.05 # Der Radius der Kugel.

# Die Kugel wird auf der Diagonalen uber die Leinwand bewegt.

# Der Startpunkt der Kugel ist (0,0) -- d.h. die untere linke Ecke der Leinwand.

# Der Punkt (x_pos,y_pos) ist die aktuelle Position der Kugel.

x_pos = 0.0

y_pos = 0.0

# Die Bewegung entsteht, indem aufeinanderfolgende Bilder gezeigt werden,

# bei denen die Kugel jedesmal ein kleines Stuck weitergerollt ist.

# Das wird erreicht, indem abstand zu x_pos und y_pos addiert wird.

while x_pos<1.0 and y_pos<1.0:

# Bestimme die nachste Position der Kugel.

x_pos = x_pos + abstand

y_pos = y_pos + abstand

# Losche die Leinwand, male die Kugel auf ihrer neuen Position und zeige die Leinwand an.

stddraw.filledCircle(x_pos, y_pos, RADIUS)

stddraw.show(zeitspanne)

stddraw.show()stddraw – bewegte Bilder 1.5.60

python3 kugel-1.py 20 0.13

python3 kugel-1.py 20 0.18

(Wir konnen jetzt nicht mehr richtig darstellen, was passiert . . . )


Aufgabe: lasse die Kugel hin- und herprallen

Die Kugel soll von der unteren linken Ecke der Leinwand (Punkt p0, 0q)uber die Diagonale in die obere rechte Ecke der Leinwand rollen (Punkt p1, 1q).

Von dort soll sie wieder zuruckrollen usw.

Das erreicht man wie folgt:Wenn die Kugel in einer Ecke ankommt,

dann wird das Vorzeichen von abstand verandert.Wenn abstand positiv ist, dann rollt die Kugel von links unten nach rechts oben.Wenn abstand negativ ist, dann rollt die Kugel von rechts oben nach links unten.


# kugel-2.py

#--------------------------------------------------------------------------------------

# Eine Kugel rollt auf der Diagonalen von links nach rechts hin und her durch das Bild.

# Von der Kommandozeile wird ein int zeitspanne (Anzeigezeit jedes Bildes in ms)

# und ein float abstand (beeinflusst den Abstand der Kugel von Bild zu Bild) gelesen.

#-------------------------------------------------------------------------------------

import sys, stddraw


abstand = float(sys.argv[2])

RADIUS = 0.05 # Der Radius der Kugel.

# Der Startpunkt der Kugel ist (0,0) -- d.h. die untere linke Ecke der Leinwand.

# Der Punkt (x_pos,y_pos) ist die aktuelle Position der Kugel.

x_pos = 0.0

y_pos = 0.0

# Die Bewegung entsteht, indem aufeinanderfolgende Bilder gezeigt werden,

# bei denen die Kugel jedesmal ein kleines Stuck weitergerollt ist.

# Das wird erreicht, indem abstand zu x_pos und y_pos addiert wird.

while True:

# Falls die Kugel in einer Ecke ist, dann andere ihre Richtung (um 180 Grad).

if x_pos>=1.0 or x_pos<0.0: abstand = -abstand


x_pos += abstand

y_pos += abstand


stddraw.filledCircle(x_pos, y_pos, RADIUS)


stddraw.show()

#-------------------------------------------------------------------------------

# python kugel-2.py 25 0.005 stddraw – bewegte Bilder 1.5.63

Aufgabe: lasse die Kugel an den Seiten der Leinwand abprallen

Die Kugel rollt uber die Leinwand.Wenn sie an eine Seite stoßt, dann prallt sie ab (

”Einfallswinkel“Ausfallswinkel“) und rollt weiter.

Wir mussen jetzt die Anderung der x-Koordinate und die Anderung der y -Koordinate der Kugeltrennen.

Wenn die Kugel an den linken oder rechten Rand stoßt,dann andert sich das Vorzeichen der Anderung der x-Koordinate.

Wenn die Kugel an den unteren oder oberen Rand stoßt,

dann andert sich das Vorzeichen der Anderung der y -Koordinate.


# kugel-3.py, Beispielaufruf: python3 kugel-3.py 25 0.005 0.008

#-------------------------------------------------------------------------------------------------

# Eine Kugel rollt auf der Leinwand. Wenn sie an eine Seite stoßt, prallt sie ab und rollt weiter.

# Das wird als "Film" durch aufeinanderfolgende Bilder angezeigt. Von der Kommandozeile werden

# ein int zeitspanne (Anzeigezeit jedes Bildes in ms) und zwei floats x_abstand und y_abstand

# (beeinflussen den Abstand der Kugel von Bild zu Bild) gelesen.

#-------------------------------------------------------------------------------------------------

import sys, stddraw


x_abstand = float(sys.argv[2])

y_abstand = float(sys.argv[3])

# Die Kugel liegt in der Mitte der Leinwand. Punkt (x_pos,y_pos) ist ihre aktuelle Position.

(x_pos, y_pos) = (0.5, 0.5)

# Die Bewegung entsteht, indem x_abstand zu x_pos und y_abstand zu y_pos addiert wird.

# Wenn die Kugel an eine Seite prallt, wird das Vorzeichen des entsprechenden Abstands geandert.

while True:

# Falls die Kugel an die rechte oder linke Seite prallt, dann andere ihre x-Richtung.

if x_pos>=1.0 or x_pos<=0.0: x_abstand = -x_abstand

# Falls die Kugel an die untere oder obere Seite prallt, dann andere ihre y-Richtung.

if y_pos>=1.0 or y_pos<=0.0: y_abstand = -y_abstand


x_pos = x_pos + x_abstand

y_pos = y_pos + y_abstand


stddraw.clear(stddraw.GRAY)

stddraw.filledCircle(x_pos, y_pos, 0.05)


stddraw.show()stddraw – bewegte Bilder 1.5.65

Zusammenfassungstandard draw

Wir haben gesehen, wie Bilder aus einfachen Elementen

(Punkte, Striche, Kreise, Rechtecke, Schrift)

gestaltet und angezeigt werden konnen.

Mit diesen Mitteln lassen sich z.B. Messwerte

und einfache Animationen graphisch ansprechend darstellen.

1.5.66

Weitere Beispiele

Eine csv-Datei (comma separated values) enthalt in Zeilen zusammengehorige Daten, die als Stringsdargestellt und durch Kommas (o.a.) getrennt sind.

Bsp.: Datei airports.csv mit Namen, Breiten- und Langengrad etc. von Flughafen.

1,"Goroka","Goroka","Papua New Guinea","GKA","AYGA",-6.081689,145.391881,5282,10,"U","Pacific/Port_Moresby"

2,"Madang","Madang","Papua New Guinea","MAG","AYMD",-5.207083,145.7887,20,10,"U","Pacific/Port_Moresby"

3,"Mount Hagen","Mount Hagen","Papua New Guinea","HGU","AYMH",-5.826789,144.295861,5388,10,"U","Pacific/Port_Moresby"

4,"Nadzab","Nadzab","Papua New Guinea","LAE","AYNZ",-6.569828,146.726242,239,10,"U","Pacific/Port_Moresby"

5,"Port Moresby Jacksons Intl","Port Moresby","Papua New Guinea","POM","AYPY",-9.443383,147.22005,146,10,"U","Pacific/Port_Moresby"

6,"Wewak Intl","Wewak","Papua New Guinea","WWK","AYWK",-3.583828,143.669186,19,10,"U","Pacific/Port_Moresby"

Wir wollen nun die Koordinaten jedes Flughafens ausgeben.Dazu konnen wir jede Zeile in ein Array aufteilen, dessen Elemente die durch Kommas getrennten Stellender Zeile sind.

zeile = '1,"Goroka","Goroka","Papua New Guinea","GKA","AYGA",' +

'-6.081689,145.391881,5282,10,"U","Pacific/Port_Moresby"'

array = string.split( zeile, ',' )

stdio.writeln(array)

liefert['1', '"Goroka"', '"Goroka"', '"Papua New Guinea"', '"GKA"', '"AYGA"', '-6.081689', '145.391881',

'5282', '10', '"U"', '"Pacific/Port_Moresby"']Anhang mit alten Programmen 1.5.67

# coords-aus-csv.py

# Es werden die Zeilen einer csv-Datei eingelesen.

# Die Eintrage an Stelle 6 und 7 werden ausgegeben.

import stdio, string

while stdio.hasNextLine():

line = stdio.readLine()

breitengrad = string.split(line,',')[6]

laengengrad = string.split(line,',')[7]

stdio.writef('%8s %8s\n', breitengrad, laengengrad)

#---------------------------------------------------------

# python coords-aus-csv.py < airports.csv

# -6.081689 145.391881

# -5.207083 145.7887

# -5.826789 144.295861

# -6.569828 146.726242

# -9.443383 147.22005

# -3.583828 143.669186

# ...

Anhang mit alten Programmen 1.5.68

#-----------------------------------------------------------------------

# plotfilter.py (aus dem Buch)

#-----------------------------------------------------------------------

import stdio

import stddraw

# Read x and y scales from standard input, and configure standard

# draw accordingly. Then read points from standard input until

# end-of-file, and plot them on standard draw.

x0 = stdio.readFloat()

y0 = stdio.readFloat()

x1 = stdio.readFloat()

y1 = stdio.readFloat()

stddraw.setXscale(x0, x1)

stddraw.setYscale(y0, y1)

# Read and plot the points.


while not stdio.isEmpty():

x = stdio.readFloat()

y = stdio.readFloat()

stddraw.point(x, y)

stddraw.show()

#----------------------------------------

# python plotfilter.py < usa.txt

Datei usa.txt:

669905.0 247205.0 1244962.0 700000.0

1097038.8890 245552.7780

1103961.1110 247133.3330

1104677.7780 247205.5560

1108586.1110 249238.8890

1109713.8890 250111.1110

...Anhang mit alten Programmen 1.5.69

Wir wollen plotfilter.py benutzen, um eine Karte mit den Flughafen zu malen.

Deren Koordinaten haben wir ja bereits.

Dazu mussen wir coords-aus-csv.py so modifizieren,dass es zu plotfiler.py passt:

§ In der ersten Zeile der Ausgabe mussen die Werte x0, y0, x1, y1 fur die Bereiche der x-Werte(x0 ď x ď x1) und die Bereiche der y -Werte (y0 ď y ď y1) stehen.

§ In den darauffolgenden Zeilen folgen x-Koordinate (Langengrad) und y -Koordinate (Breitengrad) jedesFlughafens.

Anhang mit alten Programmen 1.5.70

#-----------------------------------------------------------------------

# airports-to-plotfilter.py

#-----------------------------------------------------------------------

# Es werden die Zeilen einer csv-Datei eingelesen.

# Die Ausgabe passt als Eingabe fur plotfilter.py .

# Zuerst werden die Bereiche fur die x- und y-Koordinaten ausgegeben.

# Die x-Koordinaten sind die Langengrade (-180 ... 180) und

# die y-Koordinaten sind die Breitengrade (-90 .. 90).

# Der Eintrag an Stelle 6 der csv-Datei ist der Breitengrad,

# und der Eintrag an Stelle 7 ist der Langengrad.

import stdio, string

# Ausgabe der Bereiche fur die x- und y-Koordinaten

stdio.writeln('-180.0 -90.0 180.0 90.0')

while stdio.hasNextLine():

zeile = stdio.readLine()

xkoordinate = string.split(zeile,',')[7]

ykoordinate = string.split(zeile,',')[6]

stdio.writef('%8s %8s\n', xkoordinate, ykoordinate)

#--------------------------------------------------------------------------

# ( python airports-to-plotfilter.py < airports.csv ) | python plotfilter.py

#Anhang mit alten Programmen 1.5.71

algorithmische grundlagen einführung in das programmieren ... · 1.5.3 graphische ausgabe mit...

Documents