Python

Gymnasium Kirchenfeld
Python
fts
26. Januar 2016
Dieses Werk steht unter einer Attribution-NonCommercial-ShareAlike 3.0 License
(CC BY-NC-SA).
Inhaltsverzeichnis
1 Einleitung
Höhere Programmiersprache
Python . . . . . . . . . . . .
Jython . . . . . . . . . . . .
TigerJython . . . . . . . . .
.
.
.
.
2
2
2
4
4
2 Erste Schritte
Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
5
5
6
3 Programmierkonzepte
Kommentare . . . . . . . .
Variablen . . . . . . . . .
Zahlen . . . . . . . .
Text . . . . . . . . .
Listen . . . . . . . .
Wiederholungen . . . . . .
Funktionen . . . . . . . .
Parameter . . . . . . . . .
Selektion . . . . . . . . .
Schleifen . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
7
7
8
8
8
9
10
10
11
11
4 Aufgaben
«Test»-Aufgaben Python . . . . . . . . . . . .
Aufgabe «Diagramme» . . . . . . . . . . . . .
Teilaufgabe 1 . . . . . . . . . . . . . . .
Teilaufgabe 2: Balkendiagramm . . . . .
Teilaufgabe 3: Kreisdiagramm . . . . . .
Zusatzaufgabe: Weitere Diagramm-Typen
Aufgabe «Histogramm» . . . . . . . . . . . . .
Teilaufgabe 1: Graustufenfilter . . . . . .
Teilaufgabe 2: Histogramm . . . . . . . .
Zusatzaufgabe: RGB-Histogramm . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
12
12
12
13
13
14
14
14
15
16
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5 Anhang
17
Quellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
fts
II
Abbildungsverzeichnis
fts
Dilbert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
I
1.1
1.2
Von HLL zu Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Guido van Rossum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
3
2.1
2.2
Konsolenfenster einblenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Debugger von TigerJython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
6
4.1
4.2
Frosch: Original und berechnetes Graustufenbild . . . . . . . . . . . . . . . . . . . . . . . 15
Histogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1
1 Einleitung
Das Ziel diese Kurses ist es, eine «höhere» Programmiersprache zu erlernen.
Höhere Programmiersprache
Unter einer höheren Programmiersprache verstehen wir eine Sprache, die für uns Menschen verständlich ist – sich also an unserer «normalen» Sprache orientiert. Diese Sprache muss natürlich auch für den
Computer verständlich sein. Es bestehen also ganz klar definierte Regeln (Syntax).
Ein in einer höheren Programmiersprache geschriebenes Programm muss vor dem Ausführen durch einen
Compiler oder einen Interpreter laufen. Python ist eine interpretierte höhere Programmiersprache. D.h.
der Code wird mit Hilfe eines Interpreters ausgeführt. Fehler im Code werden von diesem erst zur Laufzeit
erkannt. Im Gegensatz dazu wandelt ein Compiler ein Programm vor dem Ausführen in Maschinen-Code
(z.B. C++) oder in Byte-Code (z.B. Java) um. Erst dieser Code wird dann ausgeführt.
Abbildung 1.1: Von HLL zu Hardware
Python
Python wurde 1989 von Guido van Rossum erfunden. Im Jahr 2000 wurde die Version 2 veröffentlich. Von
nun an arbeiteten viele Programmierer am Projekt. Seit 2008 gibt es eine Version 3. Die Version 2 wird
jedoch parallel zu Python 3 weiterentwickelt.
Die Hauptmerkmale von Python sind:
•
•
•
•
fts
Leserlich und aufgeräumt
Englische Wörter statt Sonderzeichen
Wenige syntaktische Ausnahmen und Spezialfälle
Blöcke durch Einrücken des Codes
2
Einleitung
Python
Abbildung 1.2: Guido van Rossum
fts
3
Python
Einleitung
Jython
Jython ist eine Java-Implementierung der Programmiersprache Python. Pyhton-Code kann so auf jeder JavaPlattform ausgeführt werden. Zudem können so sämtliche Java-Bibliotheken in Python-Programmen importiert und genutzt werden.
• http://www.jython.org
TigerJython
• http://jython.tobiaskohn.ch
• http://www.tigerjython.ch
fts
4
2 Erste Schritte
Wir wollen uns zuerst mal mit der Programmierumgebung von TigerJython vertraut machen.
Shell
Da es sich bei Pyhton um eine interpretierte Sprache handelt, müssen die Befehle vor dem Ausführen nicht
compiliert werden. Dies erlaubt es uns Befehle «von Hand» in der sogenannten Shell (Konsolenfenster)
auszuführen.
Abbildung 2.1: Konsolenfenster einblenden
>>> 4 + 13
17
In der Shell können Befehle Zeile um Zeile eingegeben werden. Rückgabewerte und Ergebnisse werden
gleich angezeigt. Man kann aber auch mit Variablen unds Zuweisungen arbeiten:
>>> x = 4 + 13
17
>>> x
17
Programme
Im Hauptfenster kann man «richtige» Programme schreiben. Ein Programm besteht aus beliebig vielen Zeilen und wird auf Knopf-/Tastendruck ausgeführt. Programme lassen sich natürlich abspeichern und wieder
öffnen.
fts
5
Erste Schritte
Python
Debugger
Bei der Suche nach Fehlern in einem Programm ist der sogenannte Debugger von grosser Hilfe. Er lässt
sich durch Klick auf das «Käfer/Lupen»-Icon im rechten Bereich des TigerJython-Fensters einblenden.
Abbildung 2.2: Debugger von TigerJython
Mit dem Debugger kann man nun das Programm schrittweise ausführen und es werden alle momentan
bekannten Variablen und ihre Werte aufgelistet und in jedem Schritt aktualisiert. Zudem kann man Haltepunkte setzen (im Screenshot auf Zeile 4). Bei diesen Haltepunkten pausiert die Programmausführung und
man kann die Werte studieren.
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_
mitte=anhang/debugging.inc.php
fts
6
3 Programmierkonzepte
Kommentare
Jede Programmiersprache besitzt die Möglichkeit Programmcode mit Kommentaren zu versehen. Kommentare werden vom Compiler nicht beachtet, helfen uns jedoch bei der Lesbarkeit des Programmcodes.
In Pyton leitet man einen Kommentar mit dem Hashtag # ein. Was hinter dem Hashtag steht (bis zum
Zeilenende) gilt als Kommentar.
Neben einzeiligen Kommentar bietet Python die Möglichkeit eines Kommentar-Blocks der sich über mehrere Zeilen erstreckt. Der Kommentar-Block wird am Anfang und am Ende durch drei doppelte Anführungszeichen " abgegrenzt und dient z.B. als Information über das Programm und dessen Autor ganz zu Beginn
eines Dokumentes.
""" helloturtle.py
Zeichnet einen Strich mit der Turtle auf den Bildschirm
12.1.2016, S. Forster
"""
from gturtle import *
# die Turtle-Library laden
makeTurtle()
forward(100)
# eine Turtle erzeugen
# Turtle 100 nach vorne bewegen
Variablen
Variablen können als Container angesehen werden. Eine Variable hat einen Namen und einen Wert. Mit
dem Namen kann die Variable ausgewählt werden und ihr Wert gelesen oder verändert werden:
x = 5
y = 20 * x
x = 7
print y
#
#
#
#
Variable x definieren und auf den Wert 5 setzen
Variable y definieren und mit dem Wert von x berechnen
der Variablen x einen neuen Wert zuweisen
Wert der Variable y ausgeben (gibt 100)
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_mitte=turtle/variablen.inc.php
Variablen speichern Werte. Nun gibt es unterschiedliche Dinge die wir als Werte speichern möchten. Je
nachdem was wir speichern möchten, verwendet Pyhton einen entsprechenden Datentyp (Python wählt den
Datentyp selbst. Bei anderen Programmiersprachen muss dieser beim definieren der Variablen festgelegt
werden.)
Der Typ eines Objektes kann in Python immer mittels type() abgefragt werden:
>>> type(2.5)
<type 'float'>
>>> type(7)
<type 'int'>
fts
7
Python
Programmierkonzepte
Zahlen
Zum Speichern von Zahlen bietet Python vier Datentypen an:
• Integer – Mittels der Python-Klasse int können Ganze Zahlen gespeichert werden (bis zu einer Grösse
von 32 Bit).
• Long – Die Python-Klasse long speichert Ganze Zahlen beliebiger Grösse ab (begrenzt nur durch
den zur Verfügung stehenden Hauptspeicher). Ein Long-Wert wird durch ein hintenangestelltes «L»
gekenzeichnet.
• Float – Die Klasse float steht für Dezimalzahlen zur Verfügung.
• Komplex – Mit der Klasse complex können sogar Komplexe Zahlen dargestellt werden.
Da die «elementaren» Datentypen von Python selbst Klassen sind, kann man auch eigene Zahlen-Datentypen
definieren. Denkbar wäre z.B. eine Klasse rationalum Rationale Zahlen darzustellen.
Text
Text wird in Python mit der Klasse String gespeichert. Strings sind unveränderbare Zeichenketten, d.h.
geordnete Sammlungen von Zeichen. Auf ihre einzelnen Elementen kann mit dem Index-Operator [] lesend zugreifen werden. (Die Nummerierung beginnt bei 0.) Strings werden mit einfachen oder doppelten
Anführungszeichen umgeben.
>>> s = "Hallo Welt"
>>> t = "Carla's Song"
>>> s[0]
H
>>> len(s)
10
>>> s[len(s)-1]
t
>>> s+t
Hallo WeltCarla's Song
>>> s+". "+t
Hallo Welt. Carla's Song
Listen
Definieren und Werte zuweisen
>>>
>>>
>>>
>>>
einkaufen = [ "Eier", "Brot", "Schinken", "Bananen" ]
noten = [ 3.5, 5.5, 4, 4.5, 6 ]
mischmasch = [ 'Orangen', 4.50, 'Pfirsiche', 3.90 ]
leer = [ ]
Auf Listen zugreifen
>>> einkaufen
# ganze Liste
[ 'Eier', 'Brot', 'Schinken', 'Bananen' ]
>>> einkaufen[1]
# einzelnes Listenelement
Brot
>>> einkaufen[1:2]
# Teilliste 'von-bis'
['Brot', 'Schinken']
fts
8
Programmierkonzepte
Python
>>> einkaufen[1:]
['Schinken', 'Bananen']
>>> len(einkaufen)
5
>>> einkaufen(len(einkaufen)-1)
Bananen
# Teilliste 'von-bis-Ende'
# Länge der Liste (Anzahl Elemente)
# Letztes Listenelement
Listenelemente in Schleife durchgehen
>>> for was in einkaufen:
...
print "Kauf", was, "ein!"
Kauf Eier ein!
Kauf Brot ein!
Kauf Schinken ein!
Kauf Bananen ein!
def mittelwert(liste):
summe = 0
for element in liste:
summe = summe + element
return summe/len(liste)
>>> mittelwert(noten)
4.7
Listen von Listen
>>> tictactoe = [
...
[ 'o', ' ', ' ' ],
...
[ 'x', 'x', 'o' ],
...
[ 'o', ' ', ' ' ]
... ] >>>
>>> tictactoe[2][1] = 'x'
>>> tictactoe[0][1] = 'o'
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_
mitte=grafik/listen.inc.php
Wiederholungen
TigerJython bietet eine spezielle Repeat-Struktur, die es beim normalen Python nicht gibt (dort müsste man
mit einer for-Schleife arbeiten).
repeat anzahl:
Anweisungen, die
wiederholt werden
sollen
from gturtle import *
makeTurtle()
fts
9
Python
Programmierkonzepte
repeat 4:
forward(100)
left(90)
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_
mitte=turtle/wiederholung.inc.php
Funktionen
from gturtle import *
def square():
repeat 4:
forward(100)
left(90)
makeTurtle()
setPenColor("red")
square()
right(120)
setPenColor("blue")
square()
right(120)
setPenColor("green")
square()
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_
mitte=turtle/funktionen.inc.php
Parameter
from gturtle import *
def square(sidelength):
repeat 4:
forward(sidelength)
left(90)
makeTurtle()
setPenColor("red")
square(80)
left(180)
setPenColor("green")
square(50)
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_
mitte=turtle/parameter.inc.php
fts
10
Python
Programmierkonzepte
Selektion
from gturtle import *
def square(sidelength):
repeat 4:
forward(sidelength)
right(90)
makeTurtle()
s = inputInt("Enter the side length")
if s < 300:
square(s)
else:
print "The side length is too big"
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_
mitte=turtle/selektion.inc.php
Schleifen
from gturtle import *
a = 5
while a < 200:
forward(a)
right(90)
a = a + 2
Mehr: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.php&inhalt_
mitte=turtle/schleifen.inc.php
fts
11
4 Aufgaben
«Test»-Aufgaben Python
Löse die folgenden Aufgaben mit TigerJython und einer Turtle:
1. Zeichne einen Stern (verwende dazu die repeat-Anweisung)
2. Verschiebe das Zeichnen des Sternes in eine eigene Funktion und ruf diese mehrmals an verschiedenen
Turtle-Positionen auf.
3. Erweitere deine Funktion indem du die gewünschte Kantenlänge des Sternes als Parameter mitlieferst.
(Zusatzaufgabe: Anzahl Zacken des Sternes als zweiter Parameter)
4. Baue in der Stern-Funktion ein if ein welches auf Grund der Grösse des Sternes eine von mindestens
zwei Farben wählt. (z.B. grosse Sterne blau, kleine Sterne rot)
5. Anstatt einige fixe Sterne zu zeichnen, rufst du die Sternfunktion nun in einer while-Schleife auf.
Die Schleife läuft für die Zählvariable a von 2 bis 256 wobei sich a nach jedem Schleifendurchlauf
verdoppelt. Verwende a gerade als Kantenlänge des Sterns. (Du solltest nun mehrere Sterne erhalten:
Jeder neu gezeichnete Stern ist doppelt so gross wie der davor gezeichnete.)
Aufgabe «Diagramme»
Als Eingabe erhalten wir eine Folge von Werten. Diese möchten wir mit verschiedenen Diagramme-Arten
mit einer TigerJython-Turtle darstellen. Das Diagramm-Zeichnen wird in eine eigene Funktion ausgelagert.
Der Aufruf soll wie folgt aussehen:
from gturtle import *
makeTurtle()
werte = [12, 14, 9, 25, 4, 34.7, 31]
barchart(werte)
Eine Übersicht über alle Turtle-Befehle findet man hier: http://www.tigerjython.ch/index.php?
inhalt_links=navigation.inc.php&inhalt_mitte=turtle/turtledoc.html
Teilaufgabe 1
Damit wir die Diagramme im Bereich der Turtle sinnvoll platzieren können. Müssen wir zuerst einige Hilfsfunktionen definieren, die wir dann bei den einzelnen Diagramm-Zeichnungs-Funktionen verwenden können. (z.B. müssen wir bei einem Kuchendiagramm wissen, wie gross die Gesamtsumme, also 100%, ist –
oder bei einem Balken-/Säulendiagramm wie gross der höchste und ev. der kleinste Wert ist.)
Hilfsfunktion 1: Maximum
Schreibe eine Funktion max() welche die Liste der darzustellenden Werte erhält, diese mit einer forSchleife durchläuft, den grössten Wert bestimmt und diesen mittels return zurückgibt.
fts
12
Python
Aufgaben
def max(werte):
...
for wert in werte:
...
return ergebnis
Hilfsfunktion 2: Summe
Die zweite Hilfsfunktion heisst sum() und zählt alle Werte der Liste zusammen und gibt das Ergebnis
zurück.
Hilfsfunktion 3: Diagramm-Bereich
Als letzte Hilfsfunktion definieren wir eine Funktion chartArea(). Diese Funktion bekommt keine Parameter, sondern macht für jeden Diagrammtyp dasselbe, nämlich ein Rechteck zeichnen, welches den Bereich des Diagramms umgibt. Das Rechteck soll 600 Pixel breit und 400 Pixel hoch sein und zentriert im
Turtle-Fenster liegen.
Teilaufgabe 2: Balkendiagramm
Wir schreiben nun die Funktion barchart(). Diese erhält die zu zeichnenden Werte in Form einer Liste.
Diese Werte sollen nun mit einer Turtle in den Diagramm-Bereich als Säulen gezeichnet werden.
Tipps:
• Man geht die Werte der Liste mit einer for-Schleife durch.
• Damit man das Diagramm horizontal zentriert im Diagramm-Bereich zeichnen kann, verteilt man
die Säulen über die gesamte Breite. (Mit len(werte) kann man herausfinden wie viele Säulen zu
zeichnen sind.)
• Um die Säulen vertikal sinnvoll anzuordnen, kann man einen Dreisatz, resp. einen Skalier-Faktor
verwenden, so dass die höchste Säule gerade bis (oder knapp bis) an den oberen Rand des Bereichs
stösst (also 400 Pixel hoch ist).
Zusatzaufgabe:
• Zeichne die Balken in verschiedenen Farben. Eine Zufallsfarbe erhälst du mit der Funktion getRandomX11Color
• Um die Turtle (z.B. zwischen den Säulen) zu bewegen ohne einen Strich zu hinterlassen, rufst du
penUp() auf. Bevor weitergezeichnet werden soll, musst du dann penDown() aufrufen.
• Fülle die Balken. Dazu kannst du die Funktionen setFillColor(), startPath() und fillPath()
verwenden.
Teilaufgabe 3: Kreisdiagramm
Die Funktion piechart() soll ein Kreisdiagramm der Werte zeichnen.
Tipps:
•
•
•
•
fts
Der gesamte Kreis, also 100%, entspricht der Summe der Diagramm-Werte
Lege einen sinnvollen Radius fest
Einen Kreisbogen kannst du mit den Funktionen rightArc(radius, winkel) zeichnen
Fülle die Kuchenstücke. Dazu kannst du die Funktionen getRandomX11Color(), setFillColor(),
startPath() und fillPath() verwenden.
13
Python
Aufgaben
Zusatzaufgabe: Weitere Diagramm-Typen
Versuche dieselben Werte mit einem Linien-Diagramm oder einem Punkte-Diagramm darzustellen. Auch
diese Aufgabe ist mit einer Turtle lösbar. Einfacher wird es aber wenn du diese Diagramme mit einem
GPanel zeichnest.
Aufgabe «Histogramm»
Mit der library gpanel kann man Bilder laden, manipulieren und darstellen. Im folgenden Beispiel erhält
die Funktion grayscale ein Bitmap-Bild, geht dieses in einer verschachtelten Schleife Zeile um Zeile,
Pixel um Pixel durch und berechnet aus den 3 Farbwerten des Pixels einen Graustufenwert der in ein neues
Bild an die korrekte Stelle gezeichnet wird. Am Schluss wird das so neu berechnete Bild zurückgegeben.
from gpanel import *
def grayscale(original):
w = original.getWidth()
h = original.getHeight()
result = GBitmap(w, h)
for x in range(w):
for y in range(h):
color = original.getPixelColor(x, y)
red = color.getRed()
green = color.getGreen()
blue = color.getBlue()
intensity = (red + green + blue) // 3
gray = makeColor(intensity, intensity, intensity)
result.setPixelColor(x, y, gray)
return result
size = 300
makeGPanel(Size(2 * size, size))
window(0, 2 * size, size, 0)
img = getImage("sprites/colorfrog.png")
image(img, 0, size)
imgGray = grayscale(img)
image(imgGray, size, size)
Das Beispiel-Programm liefert den folgenden Output:
Quelle zum Beispiel: http://www.tigerjython.ch/index.php?inhalt_links=navigation.inc.
php&inhalt_mitte=grafik/bildbearbeitung.inc.php
Teilaufgabe 1: Graustufenfilter
• Kopiere und starte das obenstehende Beispiel.
• Teste den Graustufenfilter mit einem eigenen Bild.
• Kopiere die Funktion grayscale des Beispiels nach grayscaleLum() und passe in der neuen
Funktion die Berechnung des Graustufenwertes gemäss Wikipedia an: https://de.wikipedia.
org/wiki/Grauwert
fts
14
Aufgaben
Python
Abbildung 4.1: Frosch: Original und berechnetes Graustufenbild
• Teste deine Funktion indem du neben dem Graustufen-Frosch auch den mit der neuen Funktion berechneten Graustufen-Frosch anzeigst.
Teilaufgabe 2: Histogramm
Abbildung 4.2: Histogram
Ein Histogramm zeigt die Helligkeitsverteilung in einem Bild an: Auf der x-Achse sind die Helligkeitswerte
dargestellt. Ganz links wird die Anzahl schwarzer Pixel (alle drei Farbkanäle auf 0) dargestellt, ganz rechts
die Anzahl weisser Pixel (alle drei Farbkanäle 255).
• Erstelle weitere Funktion histogram(). Diese erhält ein Bild und zählt die Pixel auf einer Helligkeitsskale von 0 bis 255 und gibt das Ergebnis als Liste zurück
• Erstelle eine weitere Funktion drawHistogram() welche die mit histogram() berechnete Liste erhält und die Werte als Histogramm darstellt.
fts
15
Python
Aufgaben
Zusatzaufgabe: RGB-Histogramm
Versuche ein RGB-Histogramm zu zeichnen. D.h. für jeden Kanal eine separate Kurve (in der Farbe des
entsprechenden Farb-Kanals). Wie kann man die Kurven sinnvoll darstellen, so dass sie einander nicht
überdecken?
fts
16
5 Anhang
Quellen
• PDF «Datentypen» von Pascal Schuppli
• TigerJython-Lernmittel von Aegidius Plüss
fts
17