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 können 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 ermöglicht 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 können Punkte, Linien, Kreise, Rechtecke etc. gemalt werden.

Die Koordinaten der Eckpunkte der Leinwand können verändert werden . . .

stddraw – Einführung 1.5.37




p0, 0q

p1, 1q

x-Achse

y-A

chse

‚p0.5, 0.3q

Jeder Punkt auf der Leinwand hat Koordinaten px , yq mit Standard 0 ď x , y ď 1.Es können Punkte, Linien, Kreise, Rechtecke etc. gemalt werden.

Die Koordinaten der Eckpunkte der Leinwand können verändert werden . . .





p´2.5, 3.2q

p2, 5q

x-Achse

y-A

chse

‚p0.25, 3.74q

Jeder Punkt auf der Leinwand hat Koordinaten px , yq mit Standard 0 ď x , y ď 1.Es können Punkte, Linien, Kreise, Rechtecke etc. gemalt werden.Die Koordinaten der Eckpunkte der Leinwand können verändert 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 müssen 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, y1qstddraw.point(x, y) male einen Punkt an px , yqstddraw.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 – Einführung 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


Änderung von StandardwertenLeinwandgröße, Skalierung der Achsen, Stiftdicke, Stiftfarbe

Leinwandgröße:

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

(Default für w (Breite) und h (Höhe) 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 – Einführung 1.5.40

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

# dreieck-bunt.py

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

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

# Verändere 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) # ändere 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) # ändere die Stiftfarbe

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


stddraw.setPenColor(stddraw.RED) # ändere die Stiftfarbe

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


stddraw.setPenColor(stddraw.CYAN) # ändere 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 für unterschiedliche”Punktarten“ arbeiten (Höchst-, 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.


Grundsätzliche Alternativen für”Lies alle Punkte von standard input,

und male sie auf die Leinwand“

(A) Male jeden Punkt direkt nach dem Einlesen.

für jede Eingabezeile (Zeile “̂Punkt):bestimme den entsprechenden Punktmale ihn

(B) zuerst: lies alle Punkte einund speichere sie

danach: male jeden Punkt

für jede Eingabezeile (Zeile “̂Punkt):speichere den entsprechenden Punkt

für 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 schöne Kurve gibt,

Ablauf des Programms:

lies alle Punkte ein

für 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 Längen 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 über die y-Achse in Höhe i

stddraw.text(xmin-5, i, str(i)) # schreibe i links neben die y-Achse in Höhe 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 für n Argumente im Intervall l ď x ď r berechnet werden sollen,haben die Argumente Abstand l´rn´1 und sind l , l `1 ¨

r´ln´1 , l `2 ¨

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

r ´ ln ´ 1

loooooooooomoooooooooon

“r

.

§ die Argument-Wert-Paare px , f pxqq berechnen und§ die Funktionswerte aufeinanderfolgender Argumente durch eine Linie verbinden.

Man beachte, dass stets nur eine Näherung berechnet wird,deren Qualität von der Anzahl der berechneten Funktionswerte abhängt.

stddraw – Graph einer Funktion darstellen 1.5.50

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

# functiongraph.py (so ähnlich 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 für die x-Werte und die y-Werte des Graph der Funktion f.

n = int(sys.argv[1])

x_werte = []

y_werte = []

# Berechne für n x-Werte, die gleichmäßig über das Intervall -pi/2..pi/2 verteilt sind,

# jeweils den zugehörigen 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 zugehörigen y-Wert in y_werte.

# Am Ende gilt f(x_werte[i])==y_werte[i] für 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 können auch gefüllt gemalt werden mittelsstddraw.filledCircle(x,y,r), stddraw.filledSquare(x,y,r),

stddraw.filledPolygon(x,y).

stddraw.filledPolygon(x, y) male ein ausgefülltes 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 Höhe h

stddraw.filledRectangle(x,y, w,h) male ein gefülltes 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)

Lösche die Leinwand:

stddraw.clear(c) lösche die Leinwand und färbe 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 können 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 ähnliche Bilder, so sieht es aus, als ob sich etwas bewegt.

stddraw – bewegte Bilder 1.5.58

Aufgabe: Lasse eine Kugel quer über 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 wählen,

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 für 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 über 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 Stück weitergerollt ist.

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

while x_pos

python3 kugel-1.py 20 0.13

python3 kugel-1.py 20 0.18

(Wir können 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)über die Diagonale in die obere rechte Ecke der Leinwand rollen (Punkt p1, 1q).

Von dort soll sie wieder zurückrollen usw.

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

dann wird das Vorzeichen von abstand verändert.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 Stück 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 ändere ihre Richtung (um 180 Grad).

if x_pos>=1.0 or x_pos

Aufgabe: lasse die Kugel an den Seiten der Leinwand abprallen

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

”Einfallswinkel“Ausfallswinkel“) und rollt weiter.

Wir müssen jetzt die Änderung der x-Koordinate und die Änderung der y -Koordinate der Kugeltrennen.

Wenn die Kugel an den linken oder rechten Rand stößt,dann ändert sich das Vorzeichen der Änderung der x-Koordinate.

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

dann ändert sich das Vorzeichen der Änderung 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 geändert.

while True:

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

if x_pos>=1.0 or x_pos=1.0 or y_pos

Zusammenfassungstandard draw

Wir haben gesehen, wie Bilder aus einfachen Elementen

(Punkte, Striche, Kreise, Rechtecke, Schrift)

gestaltet und angezeigt werden können.

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) enthält in Zeilen zusammengehörige Daten, die als Stringsdargestellt und durch Kommas (o.ä.) getrennt sind.

Bsp.: Datei airports.csv mit Namen, Breiten- und Längengrad etc. von Flughäfen.

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 können 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 Einträge 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 Flughäfen zu malen.

Deren Koordinaten haben wir ja bereits.

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

§ In der ersten Zeile der Ausgabe müssen die Werte x0, y0, x1, y1 für 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 (Längengrad) 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 für plotfilter.py .

# Zuerst werden die Bereiche für die x- und y-Koordinaten ausgegeben.

# Die x-Koordinaten sind die Längengrade (-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 Längengrad.

import stdio, string

# Ausgabe der Bereiche für 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

Elemente des ProgrammierensGrundlegende Daten-TypenVerzweigungen und SchleifenArraysEin- und AusgabeAbschluss-Beispiel: Page Rank

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

Documents

Algorithmische Mathematikrichter/WS19/am1/skript.pdf · Algorithmische Mathematik ThomasRichter∗ 27.Januar2020 ∗Institut für Analysis und Numerik, Universität Magdeburg.Raum

Algorithmische Semantik und Modellgenerierungjdellert/talks/jdellert-2012-07-07.pdf · Algorithmische Semantik Modellgenerierung Linguistisch motivierte Heuristiken Die Standard-Toolchain

Algorithmische Skelette

Systematischer Katalog. Bd.1. Bibliothek der Graphischen ......BIBLIOTHEK der Graphischen Lehr-und Versuchsanstalt in Wien VII. Systematischer Katalog von Dr. Robert Zahlbrecht Mit

Kapitel 6 - Algorithmische Paradigmen · 2019. 7. 17. · DBS Kapitel 6 - Algorithmische Paradigmen Backtracking Divide and Conquer. Sweeplinetechnik. Heuristiken. Greedy Algorithmen

Digitale Öffentlichkeit - Wie algorithmische Prozesse den ... · Digitale Öffentlichkeit Wie algorithmische Prozesse den gesellschaftlichen Diskurs beeinflussen - Arbeitspapier

Vorwortdna.fernuni-hagen.de/Lehre-offen/Kurse/1663/Leseprobe.pdf · Hamilton, Kanada, Forschung über algorithmische Geometrie. 1983 Promotion über algorithmische Geometrie an der

Fortgeschrittene algorithmische Bioinformatik Thema: Profile HMMs ein Vortrag von Gunar Maiwald

Proportional Symbol Maps Vorlesung Algorithmische Kartogra e · Benjamin Niedermann Vorlesung Algorithmische Kartogra e Proportional Symbol Maps 2 Statistische Visualisierung in Karten

Algorithmische Bioinformatik: Grundlagen der molekularen ...genomeinformatics.uni-due.de/.../2016/04/Grundlagen-Biologie.pdf · Algorithmische Bioinformatik: Grundlagen der molekularen

Algorithmische Probleme der Verkehrssimulation...Institut für Verkehrssystemtechnik > Technologien aus Luft- und Raumfahrt für Straße und Schiene Algorithmische Problene der Verkehrssimulation

VL Algorithmische BioInformatik (19710) WS2013/2014 Woche 16 - Mittwoch

Algorithmische Bioinformatik I&II · Vorwort Dieses Skript entsteht parallel zu den Vorlesungen Algorithmische Bioinformatik I und II, die im Sommersemester 12 sowie im Wintersemester

Algorithmische Geometrie - uni-leipzig.de

Benjamin Niedermann Ubung Algorithmische Geometrie€¦ · Benjamin Niedermann Ubung Algorithmische Geometrie Der Satz von Thales a Satz 2: Alle Dreiecke aus den Endpunkten des Kreisdurchmessers

Eine algorithmische Einführung mit Java...Wilhelm Burger ·Mark James Burge Digitale Bildverarbeitung Eine algorithmische Einführung mit Java 3., überarbeitete und ergänzte Auﬂage

Profibus DP/V0 - Janitza Profibus Profile in der graphischen Programmierung Die Profibus Funktionsbausteine in der graphischen Programmierung sind ab der GridVis 1.6.0 und der Firmware

Algorithmische Mathematik 1 - Voxelmaster...Algorithmische Mathematik 1“ im Wintersemester 2004/05 das Mit-schreiben und Mitdenken in der Vorlesung erleichtern. Das Skriptum enthalt¨

Modul: Algorithmische Geometire Von: Elisabeth Lehmann 12INB-P

Algorithmische Mathematik II - wt.iam.uni-bonn.de · Dieses Skript fasst den Inhalt der von mir im Sommersemester 2010 an der Universit at Bonn gehaltenen Vorlesung Algorithmische

Mathematik · Analysis I Lineare Algebra I Algorithmische Mathematik I 1. Analysis II Lineare Algebra II Algorithmische Mathematik II Seminar 2. Einführende Vorlesung I Vorlesung

Algorithmische Botanik durch Lindenmayer Systeme in Blender · Algorithmische Botanik durch Lindenmayer Systeme in Blender Diskussion von Lindenmayer Systemen und Möglicher Vorteile

Algorithmische Grundstrukturen IFB 2002 Klaus Becker

Ausgabe 117 08.06.2011 „Der Rote Seehas“ · ungsantrag Peter SIMONS folgend - "eine ange-messene Berücksichtigung dieser funktionalen geo-graphischen Einheiten in den nationalen

Mathematische Methoden der graphischen Datenverarbeitung

Dualität in der graphischen Statik - math.uni-wuppertal.descholz/preprints/Graph-Statik.pdfDualität in der graphischen Statik Erhard Scholz∗ Inhaltsverzeichnis Vorbemerkungen 2

Algorithmische Skelette Michael Bruland Michael Hüllbrock Münster, den 12.06.03

VL Algorithmische BioInformatik (19710)

New Algorithmische Spieltheorie (ADM III) · 2013. 6. 7. · Algorithmische Spieltheorie (ADM III) Britta Peis TU Berlin ... Mathematik, Informatik und Wirtschafts-und Sozialwissenschaften

Algorithmische Bioinformatik I/II · 2003-05-14 · Vorwort Dieses Skript entstand parallel zu den Vorlesungen Algorithmische Bioinformatik I und Algorithmische Bioinformatik II,

Lehrheft OpenGL - mttcs. · PDF file5 Einfache 3D-Ausgabe ... OpenGL ist eine Bibliothek zur Programmierung von zwei- und dreidimensionalen graphischen Anwendungen

Algorithmische Graphentheorie im Unterricht unter ...elpub.bib.uni-wuppertal.de/.../Derivate-346/d070202.pdf1 Algorithmische Graphentheorie im Unterricht unter Verwendung objektorientierter

Algorithmische Bioinformatik

Eine Einführung in die Algorithmische Informationstheorie · Eine Einführung in die Algorithmische Informationstheorie Kurt-Ulrich Witt Publisher: Dean Prof. Dr. Wolfgang Heiden

Algorithmische Grafik