Algorithmische Grundlagen - Sommersemester 2016 – VL04

Algorithmische Grundlagen
Sommersemester 2016 – VL04
Martin Mundhenk
Uni Jena, Institut für Informatik
25. April 2016
1.4 Ein- und Ausgabe
Die bisher benutzten Programme konnten Eingaben von der
Kommandozeile lesen und Ausgaben auf dem Bildschirm ausgeben.
Eingabe von der Kommandozeile
§
können über das Array sys.argv[] benutzt werden
§
sind stets vom Typ string und müssen mittels Funktionen wie
int() oder float() zum passenden Typ konvertiert werden.
Ausgaben auf dem Bildschirm
§
können mit den Funktionen stdio.write() und stdio.writeln()
gemacht werden
§
sind stets vom Typ string
§
bilden den Datenstrom standard output.
Standard output
Ausgabe auf standard output:
stdio.write(x)
schreibe String x auf standard output
stdio.writeln(x)
schreibe String x und einen Zeilenumbruch auf standard output
(wenn x weggelassen wird, wird nur ein Zeilenumbruch geschrieben)
stdio.writef(fmt, arg1, arg2, ...)
schreibe die Argumente arg1, arg2, ... auf standard output
entsprechend der Formatierung durch fmt
1.4.2
# wuerfele.py
#
# Das Programm liest eine Zahl n von der Kommandozeile
# und gibt n Würfe mit einem Würfel aus.
import stdio, sys, random
n = int(sys.argv[1])
for i in range(n):
stdio.writeln(random.randrange(1,7))
#------------------------------------------------------------------# python wuerfele.py 7
# 4
# 4
# 1
# 2
# 4
# 6
# 1
#
# python wuerfele.py 100000 > wuerfelergebnisse.txt
#
Man kann das Programm beliebig viele Werte ausgeben lassen (Datenstrom).
Standard output kann auch in eine Datei umgeleitet werden.
1.4.3
# fmt-1.py
import stdio, math
n = 1000
r = math.sqrt(n)
# gib int n und float r aus
stdio.writef('Die Wurzel von %d ist %f .\n', n, r)
# gib int n mit 5 Zeichen und float r mit 10 Zeichen aus
stdio.writef('Die Wurzel von %5d ist %10f .\n', n, r)
# gib int n mit 5 Zeichen unf float r mit 8 Zeichen und 3 Nachkommastellen aus
stdio.writef('Die Wurzel von %5d ist %8.3f .\n', n, r)
# wie zuvor, aber r wird linksbündig ausgegeben
stdio.writef('Die Wurzel von %5d ist %-8.3f .\n', n, r)
# wenn die angegebene Zahl der Zeichen zu klein ist, wird das ignoriert
stdio.writef('Die Wurzel von %2d ist %2.3f .\n', n, r)
#---------------------------------------------------# python fmt-1.py
# Die Wurzel von 1000 ist 31.622777 .
# Die Wurzel von 1000 ist 31.622777 .
# Die Wurzel von 1000 ist
31.623 .
# Die Wurzel von 1000 ist 31.623
.
# Die Wurzel von 1000 ist 31.623 .
1.4.4
# fmt-2.py
# Würfele 100000-mal mit zwei Würfeln; zähle, wie oft
# welche Summe gewürfelt wurde und gib die relative Häufigkeit zur Summe 2 aus.
import stdio, stdarray, random
wurfsumme = stdarray.create1D(13,0)
for i in range(100000):
wurf1 = random.randrange(1,7)
wurf2 = random.randrange(1,7)
wurfsumme[wurf1+wurf2] += 1
fmt = 'Summe %2d wurde %5d-mal gewuerfelt (Faktor %4.2f).\n'
for i in range(2,len(wurfsumme)):
stdio.writef(fmt, i, wurfsumme[i], float(wurfsumme[i])/wurfsumme[2])
#-----------------------------------------------------------------------------------------# python fmt-2.py
Summe 2 wurde 2855-mal gewuerfelt (Faktor 1.00).
Summe 3 wurde 5588-mal gewuerfelt (Faktor 1.96).
Summe 4 wurde 8283-mal gewuerfelt (Faktor 2.90).
Summe 5 wurde 11166-mal gewuerfelt (Faktor 3.91).
Summe 6 wurde 13870-mal gewuerfelt (Faktor 4.86).
Summe 7 wurde 16608-mal gewuerfelt (Faktor 5.82).
Summe 8 wurde 13708-mal gewuerfelt (Faktor 4.80).
Summe 9 wurde 11126-mal gewuerfelt (Faktor 3.90).
Summe 10 wurde 8424-mal gewuerfelt (Faktor 2.95).
Summe 11 wurde 5514-mal gewuerfelt (Faktor 1.93).
Summe 12 wurde 2858-mal gewuerfelt (Faktor 1.00).
1.4.5
Standard input
Standard input ist ein Datenstrom für Daten,
die von einem Programm als Eingabe gelesen werden.
Der Datenstrom wird als Folge von Token aufgefasst,
die durch Leerzeichen (Zeilenumbrüche, Tabs etc.) getrennt sind.
Zum Lesen von Token gibt es die folgenden Funktionen.
stdio.isEmpty()
liefert True, falls der Eingabestrom beendet ist, sonst False
stdio.readInt()
liest ein Token, konvertiert es zu int und gibt es zurück
stdio.readFloat()
liest ein Token, konvertiert es zu float und gibt es zurück
stdio.readBool()
liest ein Token, konvertiert es zu bool und gibt es zurück
stdio.readString()
liest ein Token und gibt es zurück
1.4.6
#
#
#
#
ein-aus.py
Von der Kommandozeile wird n eingelesen.
Anschließend wird die Eingabe von n int-Werten erwartet.
Der Durchschnitt der Werte wird ausgegeben.
import stdio, sys
# Die Anzahl der zu lesenden Werte wird von der Kommandozeile gelesen
n = int(sys.argv[1])
summe = 0
for i in range(n):
stdio.write('Bitte geben Sie Wert ' + str(i+1) + ' von ' + str(n) + ' ein: ')
summe += stdio.readInt()
stdio.writef('Der Durchschnitt ist %.2f.\n', float(summe)/n)
#--------------------------------------------------------------------------------#
#
#
#
#
#
#
python ein-aus.py 5
Bitte geben Sie Wert
Bitte geben Sie Wert
Bitte geben Sie Wert
Bitte geben Sie Wert
Bitte geben Sie Wert
Der Durchschnitt ist
1 von
2 von
3 von
4 von
5 von
18.80
5
5
5
5
5
ein:
ein:
ein:
ein:
ein:
12
20
22
28
12
# python ein-aus.py 5
# Bitte geben Sie Wert 1 von 5 ein:
# Bitte geben Sie Wert 2 von 5 ein:
geben Sie Wert 3 von 5 ein: Bitte
Wert 4 von 5 ein: 40 23
# Bitte geben Sie Wert 5 von 5 ein:
Durchschnitt ist 24.60.
10 20 30
Bitte
geben Sie
Der
1.4.7
#
#
#
#
ein-aus-2.py
Es werden float-Werte eingelesen, bis die Eingabe beendet wird
(an der Konsole mit <Strg-d>, sonst mit Dateiende).
Der Durchschnitt der Werte wird ausgegeben.
import stdio, sys
n = 0
summe = 0
while not stdio.isEmpty():
summe += stdio.readFloat()
n += 1
stdio.writef('\nEs wurden %d Werte eingegeben.\n', n)
stdio.writef('Der Durchschnitt ist %.2f.\n', summe/n)
#-----------------------------------------------------------------------------# python ein-aus-2.py
# 12
# 13
# 15 89
# 56
#
# Es wurden 5 Werte eingegeben.
# Der Durchschnitt ist 37.00.
1.4.8
Bisher haben wir den Datenstrom standard input an der Konsole erzeugt.
Die Eingabeumleitung erlaubt auch das Lesen einer Datei.
#
#
#
#
ein-aus-2.py
Es werden float-Werte eingelesen, bis die Eingabe beendet wird.
(an der Konsole mit <Strg-d>, sonst mit Dateiende).
Der Durchschnitt der Werte wird ausgegeben.
import stdio, sys
n = 0
summe = 0
while not stdio.isEmpty():
summe += stdio.readFloat()
n += 1
stdio.writef('\nEs wurden %d Werte eingegeben.\n', n)
stdio.writef('Der Durchschnitt ist %.2f.\n', summe/n)
#-----------------------------------------------------------------------------# python ein-aus-2.py < Jena-hoechsttemp.txt
#
# Es wurden 9497 Werte eingegeben.
# Der Durchschnitt ist 15.11.
Funktionen zum Lesen des ganzen (restlichen) Eingabestroms auf einen Schlag“:
”
stdio.readAllInts()
liest alle Token und gibt sie als Array von int zurück
stdio.readAllFloats()
liest alle Token und gibt sie als Array von float zurück
stdio.readAllBools()
liest alle Token und gibt sie als Array von bool zurück
stdio.readAllStrings()
liest alle Token und gibt sie als Array von string zurück
stdio.readAllLines()
liest alle Zeilen und gibt sie als Array von string zurück
stdio.readAll()
liest den Rest von standard input und gibt ihn als string zurück
1.4.10
# durchschnitt.py
# Es werden float-Werte von standard input eingelesen.
# Der Durchschnitt der Werte wird ausgegeben.
import stdio, sys
summe = 0.0
eingabe = stdio.readAllFloats()
for v in eingabe:
summe += v
stdio.writeln(float(summe)/len(eingabe))
#----------------------------------------------------------# python durchschnitt.py < Jena-hoechsttemps.txt
# 15.1101821628
#
# python durchschnitt.py
# 1 3 5
8
# 23
# 45
#
# 14.1666666667
1.4.11
Funktionen zum Lesen ganzer Zeilen von standard input:
stdio.hasNextLine()
hat standard input noch eine weitere Zeile?
stdio.readLine()
liest die nächste Zeile und gibt sie (als string) zurück
stdio.readAllLines()
liest alle Zeilen und gibt sie als Array von string zurück
1.4.12
(Direktes) Verarbeiten einer csv-Datei
Eine csv-Datei (comma separated values) enthält in Zeilen zusammengehörige Daten,
die als Strings dargestellt 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
2,"Madang","Madang","Papua New Guinea","MAG","AYMD",-5.207083,145.7887,20,10,"U","Pacific/Port_Mor
3,"Mount Hagen","Mount Hagen","Papua New Guinea","HGU","AYMH",-5.826789,144.295861,5388,10,"U","Pa
4,"Nadzab","Nadzab","Papua New Guinea","LAE","AYNZ",-6.569828,146.726242,239,10,"U","Pacific/Port_
5,"Port Moresby Jacksons Intl","Port Moresby","Papua New Guinea","POM","AYPY",-9.443383,147.22005,
6,"Wewak Intl","Wewak","Papua New Guinea","WWK","AYWK",-3.583828,143.669186,19,10,"U","Pacific/Por
Wir wollen nun die Koordinaten jedes Flughafens ausgeben.
Dazu können wir jede Zeile in ein Array aufteilen, dessen Elemente die durch Kommas
getrennten Stellen der 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"']
1.4.13
# 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
# ...
1.4.14
Eine csv-Datei vom DWD mit den in Jena gemessenen Tageshöchsttemperaturen.
Element;Messstation;Datum;Wert;Einheit;Geo-Breite (Grad);Geo-Länge (Grad);Höhe (m);Sensorhöhe (m);
Erstellungsdatum;Copyright;
Lufttemperatur Tagesmaximum;Jena (Sternwarte);1990-01-01;1,5;Grad C;50,925;11,583;155;keine
Daten vorhanden;2016-04-22;© Deutscher Wetterdienst 2016;
Lufttemperatur Tagesmaximum;Jena (Sternwarte);1990-01-02;1,4;Grad C;50,925;11,583;155;keine Daten
Lufttemperatur Tagesmaximum;Jena (Sternwarte);1990-01-03;0,4;Grad C;50,925;11,583;155;keine Daten
Lufttemperatur Tagesmaximum;Jena (Sternwarte);1990-01-04;2,2;Grad C;50,925;11,583;155;keine Daten
Lufttemperatur Tagesmaximum;Jena (Sternwarte);1990-01-05;1,2;Grad C;50,925;11,583;155;keine Daten
Lufttemperatur Tagesmaximum;Jena (Sternwarte);1990-01-06;1,5;Grad C;50,925;11,583;155;keine Daten
...
Lufttemperatur
Lufttemperatur
Lufttemperatur
Lufttemperatur
Lufttemperatur
Tagesmaximum;Jena
Tagesmaximum;Jena
Tagesmaximum;Jena
Tagesmaximum;Jena
Tagesmaximum;Jena
(Sternwarte);2015-12-28;9,5;Grad
(Sternwarte);2015-12-29;8,7;Grad
(Sternwarte);2015-12-30;6,3;Grad
(Sternwarte);2015-12-31;3,8;Grad
(Sternwarte);2016-01-01;2,7;Grad
C;50,925;11,583;155;keine
C;50,925;11,583;155;keine
C;50,925;11,583;155;keine
C;50,925;11,583;155;keine
C;50,925;11,583;155;keine
Daten
Daten
Daten
Daten
Daten
1.4.15
# temperaturen-aus-csv.py
# Es werden die Zeilen einer csv-Datei vom DWD eingelesen.
# Der Eintrag an Stelle 3 wird ausgegeben.
import stdio, string
# In der ersten Zeil der csv-Datei stehen andere Informationen.
stdio.readLine()
while stdio.hasNextLine():
line = stdio.readLine()
temperatur = string.split(line,';')[3]
# Da in der csv-Datei die Temperaturen mit Komma (2,3) statt Punkt (2.3)
# stehen, muss das Komma durch einen Punkt ersetzt werden.
temperatur = string.replace(temperatur, ',', '.')
stdio.writef('%4s\n', temperatur)
#--------------------------------------------------------------# python temperaturen-aus-csv.py < Jena_Temperaturen.csv
#
# 1.5
# 1.4
# 0.4
# 2.2
# 1.2
# ...
#
# python temperaturen-aus-csv.py < Jena_Temperaturen.csv > JT.txt
#
1.4.16
# tage-ueber-30.py
# Als Eingabe wird Jena-hoechsttemps.txt erwartet.
#
Dort steht der Reihe nach für jeden Tag vom 1.1.1990 bis 1.1.2016
#
die Tageshoechsttemperatur, die an der Sternwarte Jena gemessen wurde.
# Es wird für jedes Jahr ausgegeben, an wievielen Tagen es über 30 Grad warm war.
import stdio, sys, stdarray
temperaturen = stdio.readAllFloats()
# Zähle die Anzahl der Tage pro Jahr mit Temperaturen über 30 Grad
for jahr in range(26):
if (jahr+2)%4 == 0: schalttag = 1
else: schalttag = 0
jahreslaenge = 365 + schalttag
anz_warme_tage = 0
for d in range(jahr*365 + (jahr+2)/4, jahr*365 + (jahr+2)/4 + jahreslaenge) :
if temperaturen[d] >= 30: anz_warme_tage += 1
stdio.writeln(anz_warme_tage)
#------------------------------------------------------------------------------------------------# python tage-ueber-30.py < JT.txt > Tage-ueber-30-pro-Jahr.txt
#
1.4.17
Piping
Die Ausgabe eines Programms kann direkt als Eingabe für ein anderes
Programm verwendet werden.
# python wuerfele.py 10000 | durchschnitt.py
3.5197
# ( python temperaturen-aus-csv.py < Jena Temperaturen.csv ) |
python tage-ueber-30.py > Tage-ueber-30-pro-Jahr.txt
1.4.18
Zusammenfassung
standard input und standard output
Wir haben gesehen, wie Daten
§
von der Konsole eingelesen und
auf der Konsole ausgegeben werden können
§
aus Dateien eingelesen und in Dateien geschrieben werden können
(Eingabeumleitung < und Ausgabeumleitung >)
§
als Ausgabe eines Programms weitergereicht und als Eingabe eines
anderen Programms benutzt werden können
(Piping |).
Graphische Ausgabe mit standard drawing
Das Modul stddraw erlaubt das Malen von Punkten, Strichen, Kreisen,
Rechtecken etc.
# Es wird ein Strich gemalt.
import stddraw
# die x- und y-Kooordinate des ersten Punktes
x1 = 0.2
y1 = 0.3
# die x- und y-Kooordinate des zweiten Punktes
x2 = 0.9
y2 = 0.9
# male eine Linie vom ersten zum zweiten Punkt
stddraw.line(x1, y1, x2, y2)
# zeige das gemalte Bild
stddraw.show()
1.4.20
Graphische Ausgabe mit standard drawing
Das Modul stddraw erlaubt das Malen von Punkten, Strichen, Kreisen,
Rechtecken etc.
# Es wird ein Strich gemalt.
import stddraw
# die x- und y-Kooordinate des ersten Punktes
x1 = 0.2
y1 = 0.3
# die x- und y-Kooordinate des zweiten Punktes
x2 = 0.9
y2 = 0.9
px2, y 2q
px1, y 1q
# male eine Linie vom ersten zum zweiten Punkt
stddraw.line(x1, y1, x2, y2)
# zeige das gemalte Bild
stddraw.show()
1.4.20
stddraw.line(x0, y0, x1, y0)
male eine Linie von px0, y 0q zu px1, y 1q
stddraw.point(x, y)
male einen Punkt an px, y q
stddraw.show()
zeige das Bild im standard-drawing-Fenster
(und warte, bis es vom Nutzer geschlossen wird)
stddraw.setPenRadius(r)
setze die Stiftdicke auf r
(Default-Wert von r ist 0.005)
stddraw.Xscale(x0, x1)
setze den Bereich der x-Werte auf x0 ď x ď x1
(Default ist x0 “ 0 und x1 “ 1)
stddraw.Yscale(x0, x1)
setze den Bereich der y -Werte auf y 0 ď y ď y 1
(Default ist y 0 “ 0 und y 1 “ 1)
stddraw.setCanvasSize(w, h)
setze die Bildgröße auf w -mal-h Pixel
(Default für w und h ist 512)
# Male das Haus vom Nikolaus. Es hat fünf Ecken: ul (unten links), ur,
# ol, or, gi (Giebel), die jeweils mit x- und y-Koordinate
# angegeben werden.
import stddraw
ul_x = 0
ul_y = 0
ur_x = 1
ur_y = 0
ol_x = 0
ol_y = 1
or_x = 1
or_y = 1
gi_x = float(ol_x + or_x)/2
gi_y = ol_y + 0.5
stddraw.setXscale(-0.5,1.5)
stddraw.setYscale(-0.5,2)
stddraw.line(ul_x,ul_y,ur_x,ur_y)
stddraw.line(ul_x,ul_y,ol_x,ol_y)
stddraw.line(or_x,or_y,ol_x,ol_y)
stddraw.line(or_x,or_y,ur_x,ur_y)
stddraw.line(or_x,or_y,gi_x,gi_y)
stddraw.line(ol_x,ol_y,gi_x,gi_y)
stddraw.show()
1.4.22
#----------------------------------------------------------------------# 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
y0
x1
y1
=
=
=
=
stdio.readFloat()
stdio.readFloat()
stdio.readFloat()
stdio.readFloat()
stddraw.setXscale(x0, x1)
stddraw.setYscale(y0, y1)
# Read and plot the points.
stddraw.setPenRadius(0.002)
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
...
1.4.23
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, y 0, x1, y 1 für die Bereiche
der x-Werte (x0 ď x ď x1) und die Bereiche der y -Werte (y 0 ď y ď y 1) stehen.
§
In den darauffolgenden Zeilen folgen x-Koordinate (Längengrad) und
y -Koordinate (Breitengrad) jedes Flughafens.
#----------------------------------------------------------------------# 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
#
1.4.25
Zeichnen des Graphs einer Funktion
Zum Zeichnen des Graphs einer Funktion f pxq im Bereich l ď x ď r
§
muss man festlegen, wieviele Funktionswerte man im Bereich
l ď x ď r berechnen will
(das Intervall l . . . r wird in gleichmäßige Abschnitte unterteilt),
§
die Argument-Wert-Paare px, f pxqq berechnen und
§
die Funktionswerte benachbarter 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.
1.4.26
#
#
#
#
#
#
#
#
functiongraph.py (aus dem Buch)
Der Graph der Funktion f(x) = sin(4x)+sin(20x) wird im Intervall 0..pi gezeichnet.
Zuerst wird von der Kommandozeile die Sampling-Dichte (die
Anzahl der zu zeichnenden Punkte) eingelesen.
Anschließend werden die Punkte berechnet - die x-Koordinate
des i-ten Punkts wird in x[i] gespeichert und die
y-Koordinate in y[i]. Anschließend werden Linien zwischen
benachbarten Punkten gezeichnet.
import math, sys, stdarray, stdio, stddraw
n = int(sys.argv[1])
x = stdarray.create1D(n+1,0.0)
y = stdarray.create1D(n+1,0.0)
python functiongraph.py 20
for i in range(n+1):
x[i] = math.pi * i/n
y[i] = math.sin(4.0*x[i]) + math.sin(20.0*x[i])
stddraw.setXscale(0, math.pi)
stddraw.setYscale(-2.0, +2.0)
for i in range(n):
stddraw.line(x[i], y[i], x[i+1], y[i+1])
python functiongraph.py 200
stddraw.show()
Darstellung der Anzahl der warmen Tage in Jena
Wir haben bereits das Programm tage-ueber-30.py, mit dem wir die
Anzahl der warmen Tage pro Jahr in Jena von 1990 bis 2015 ausgeben.
Wir wollen nun das Ergebnis graphisch darstellen:
als Kurve und
als Säulendiagramm.
1.4.28
# temperatur-kurve.py
# Als Eingabe wird für jedes Jahr von 1990 bis 2015 eine Zahl gelesen.
# Die Zahlen werden als Funktionsgraph dargestellt.
import stdio, stddraw
# lies die Werte für jedes Jahr
werte = stdio.readAllInts()
stddraw.setXscale(-2, 26)
stddraw.setYscale(-2, max(werte)+2)
stddraw.setPenRadius(0.002)
# male ein Koordinatensystem
stddraw.setPenColor(stddraw.BLUE)
stddraw.line(0,0,26,0)
stddraw.line(0,0,0,max(werte)+0.5)
# beschrifte die Achsen des Koordinatensystems
for i in range(max(werte)/10 + 1):
stddraw.text(-0.5, i*10, str(i*10))
for i in range(6): stddraw.text(i*5, -0.7, str(1990 + 5*i))
# male die Kurve
stddraw.setPenColor(stddraw.BLACK)
for i in range(len(werte)-1):
stddraw.line(i, werte[i], i+1, werte[i+1])
stddraw.show()
#------------------------------------------------------------# ( python temperaturen-aus-csv.py < Jena_Temperaturen.csv ) |
#
python tage-ueber-30.py | python temperatur-kurve.py
# temperatur-kurve.py
# Als Eingabe wird für jedes Jahr von 1990 bis 2015 eine Zahl gelesen.
# Die Zahlen werden als Funktionsgraph dargestellt.
import stdio, stddraw
# lies die Werte für jedes Jahr
werte = stdio.readAllInts()
stddraw.setXscale(-2, 26)
stddraw.setYscale(-2, max(werte)+2)
stddraw.setPenRadius(0.002)
# male ein Koordinatensystem
stddraw.setPenColor(stddraw.BLUE)
stddraw.line(0,0,26,0)
stddraw.line(0,0,0,max(werte)+0.5)
# beschrifte die Achsen des Koordinatensystems
for i in range(max(werte)/10 + 1):
stddraw.text(-0.5, i*10, str(i*10))
for i in range(6): stddraw.text(i*5, -0.7, str(1990 + 5*i))
# male die Kurve
stddraw.setPenColor(stddraw.BLACK)
for i in range(len(werte)-1):
stddraw.line(i, werte[i], i+1, werte[i+1])
stddraw.show()
#------------------------------------------------------------# ( python temperaturen-aus-csv.py < Jena_Temperaturen.csv ) |
#
python tage-ueber-30.py | python temperatur-kurve.py
# temperatur-kurve.py
# Als Eingabe wird für jedes Jahr von 1990 bis 2015 eine Zahl gelesen.
# Die Zahlen werden als Funktionsgraph dargestellt.
import stdio, stddraw
# lies die Werte für jedes Jahr
werte = stdio.readAllInts()
stddraw.setXscale(-2, 26)
stddraw.setYscale(-2, max(werte)+2)
stddraw.setPenRadius(0.002)
# male ein Koordinatensystem
stddraw.setPenColor(stddraw.BLUE)
stddraw.line(0,0,26,0)
stddraw.line(0,0,0,max(werte)+0.5)
# beschrifte die Achsen des Koordinatensystems
for i in range(max(werte)/10 + 1):
stddraw.text(-0.5, i*10, str(i*10))
for i in range(6): stddraw.text(i*5, -0.7, str(1990 + 5*i))
# male die Kurve
stddraw.setPenColor(stddraw.BLACK)
for i in range(len(werte)-1):
stddraw.line(i, werte[i], i+1, werte[i+1])
stddraw.show()
#------------------------------------------------------------# ( python temperaturen-aus-csv.py < Jena_Temperaturen.csv ) |
#
python tage-ueber-30.py | python temperatur-kurve.py
Weitere Funktionen zum Malen von Kreisen etc.
stddraw.circle(x, y, r) male einen Kreis
mit Mittelpunkt px, y q 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()
1.4.30
Weitere Funktionen zum Malen von Kreisen etc.
stddraw.circle(x, y, r) male einen Kreis
mit Mittelpunkt px, y q 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()
4
p2, 3q
1.4.30
stddraw.square(x, y, r) male ein Quadrat
mit Mittelpunkt px, y q und Radius r
import stddraw
x = 2
y = 3
r = 4
stddraw.setXscale(0, 6)
stddraw.setYscale(0, 6)
stddraw.square(x, y, r)
stddraw.show()
1.4.31
stddraw.square(x, y, r) male ein Quadrat
mit Mittelpunkt px, y q und Radius r
import stddraw
x = 2
y = 3
r = 4
stddraw.setXscale(0, 6)
stddraw.setYscale(0, 6)
stddraw.square(x, y, r)
stddraw.show()
4
4
p2, 3q
1.4.31
stddraw.polygon(x, y)
male ein Vieleck mit den Ecken
pxr0s, y r0sq, pxr1s, y r1sq, . . . (x und y sind Arrays)
import stddraw
x = [1,0,3,4,5]
y = [2,3,4,6,1]
stddraw.setXscale(0, 6)
stddraw.setYscale(0, 6)
stddraw.polygon(x,y)
stddraw.show()
stddraw.polygon(x, y)
male ein Vieleck mit den Ecken
pxr0s, y r0sq, pxr1s, y r1sq, . . . (x und y sind Arrays)
p4, 6q
import stddraw
x = [1,0,3,4,5]
y = [2,3,4,6,1]
stddraw.setXscale(0, 6)
stddraw.setYscale(0, 6)
stddraw.polygon(x,y)
stddraw.show()
p3, 4q
p0, 3q
p5, 1q
p1, 2q
Alle Formen können auch gefüllt gemalt werden mittels
stddraw.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
pxr0s, y r0sq, pxr1s, y r1sq, . . . (x und y sind Arrays)
import stddraw
x = [1,0,3,4,5]
y = [2,3,4,6,1]
stddraw.setXscale(0, 6)
stddraw.setYscale(0, 6)
stddraw.setPenColor(stddraw.BLACK)
stddraw.filledPolygon(x,y)
stddraw.show()
1.4.33
Alle Formen können auch gefüllt gemalt werden mittels
stddraw.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
pxr0s, y r0sq, pxr1s, y r1sq, . . . (x und y sind Arrays)
p4, 6q
import stddraw
p3, 4q
x = [1,0,3,4,5]
y = [2,3,4,6,1]
stddraw.setXscale(0, 6)
stddraw.setYscale(0, 6)
stddraw.setPenColor(stddraw.BLACK)
stddraw.filledPolygon(x,y)
stddraw.show()
p0, 3q
p5, 1q
p1, 2q
1.4.33
aus: Sedgewick, Wayne, Dondero: Introduction to Programming in Python – An Interdisciplinary Approach (Addison Wesley 2015)
1.4.34
Zusammenfassung
standard draw
Wir haben gesehen, wie Bilder aus einfachen Elementen (Punkte, Striche,
Kreise, Rechtecke, Schrift) gestaltet werden können.
Mit diesen Mitteln lassen sich auch Funktionen und Messwerte graphisch
ansprechend darstellen.
1.4.35