5. Pool-Übung zum Modul „Einführung in die Informatik“

TU Bergakademie Freiberg
Institut für Informatik
Modul „Einführung in die Informatik“
Poolübung
5. Pool-Übung zum Modul „Einführung in die Informatik“
- Aufgaben Thema: Programmieren in Python, Teil 3
(Liste von Listen, Typ Dictionary, geschachtelte Schleifen, Zufallszahlengenerator;
Bild- und Soundbearbeitung)
0)
Vorbereitende Übungen zur 5. Poolübung im interaktiven Modus von Python
(VOR der Übung durchzuarbeiten)
siehe Anhang A, B und C
(Hausaufgabe: Anhang D)
----------------------------------------------------------------------------------------------------------------------------
1)
Liste von Listen: Einfache Matrizenberechnungen
(vgl. Aufg.-komplex Struktogramme, Aufg.13 Großübung 3)
- Vorbemerkung: Die Komponenten von Listen können nicht nur (wie bisher in einigen Aufgaben)
von einfachem Typ wie int und float sein, sondern können wiederum Listen oder auch Dictionaries sein.
Für eine reelle Matrix eignet sich in Python als Datenstruktur eine Liste von Listen.
Jede (Unter-)Liste in der Liste stellt dabei eine Matrixzeile (oder auch eine Matrixspalte) dar.
----------- Aufgabe: Eine reelle (n, m)-Matrix mit n Zeilen und m Spalten ist in einer gesonderten Funktion
zeilenweise von Tastatur einzulesen (n>=2; m>=3). Die Zeilenanzahl n und die Spaltenanzahl m seien
dem Nutzer bekannt und sind im Hauptprogramm vor dem Aufruf der Eingabefunktion von Tastatur
einzulesen.
- Zur Kontrolle (und zur Übung) ist die eingelesene Matrix in einer gesonderten Funktion auf den Bildschirm zeilenweise auszugeben.
- Danach ist in einer gesonderten Funktion die Summe über alle Elemente der 2. und 3. Spalte der Matrix zu ermitteln, die berechnete Summe als Resultat an das Hauptprogramm zurückzugeben und dort auf
den Bildschirm auszugeben.
In den Funktionen ist nicht mit globalen Variablen zu arbeiten.
(In der oben genannten Struktogrammaufgabe wurde außerdem noch die transponierte Matrix berechnet. Dieser Teil entfällt hier aus Zeitgründen, kann aber fakultativ behandelt werden.)
Vorgehen zur Lösung:
Öffnen Sie aus dem Verzeichnis der Poolübung 5 das unvollständige Teilprogramm
matrixberechStartfile.py . Die Funktion zur Matrixeingabe und ihr Aufruf sind darin schon vollständig
enthalten.
Ergänzen Sie dieses Startfile zum vollständigen Programm.
-----------------------------------------------------------------------------------------------------------------------------
2)
Arbeit mit dem Datentyp Dictionary in Python:
Ein „Wörterbuch“ mit Ländern und Hauptstädten
Dictionary (siehe auch Vorlesungsskript ):
- Kollektion von Schlüssel-Wert-Paaren (key-value-pairs), d.h. Abbildung von Schlüsseln auf Werte
- Zugriff auf Elemente der Kollektion über Schlüssel
(und nicht über Indizes wie bei Listen)
1
1108
Im
unvollständigen
Python-Startfile
Y:\lehre\Modul_Einf_in_die_Informatik_WS0809_Jung\
Pooluebungen\Pooluebung_5\HauptstadtVonLandStartfile.py ist bereits eine Minidatenbank mit LandHauptstadt-Paaren aus Südamerika enthalten.
Öffnen Sie dieses Startfile von der IDLE aus.
- Ergänzen Sie dieses Startfile zu einem vollständigen Programm, das Folgendes ausführt:
-- Es soll zunächst auf den Bildschirm ausgegeben werden:
Hauptstadt von:
-- Danach ist von Tastatur ein Land einzugeben.
-- Als Resultat ist vom Programm nun aus der Minidatenbank die entsprechende Hauptstadt auszugeben.
-- Wenn das Land nicht in der Minidatenbank enthalten ist, ist "nicht enthalten" auszugeben
und anschließend nach dem nächsten Land zu fragen
-- Die Abfrage "Hauptstadt von: " ist solange zu wiederholen, bis (als „Land“) Ende
(in irgendeiner Schreibweise!) eingegeben wird (die Zeichenkette "Ende" ist also Endeerkennungszeichen im Sinne der Struktogrammaufgabe 15; das Endeerkennungszeichen ist vom gleichen Typ wie der
Schlüssel).
-----------------------------------------------------------------------------------------------------------------------------
3)
Bildbearbeitung mit dem Modul PIL
( PIL ... Python Imaging Library ):
Korrektur eines Grünstichs in einem Farbbild
Vorbemerkungen:
- Zur Installation des Moduls PIL auf dem Privat-PC/-Laptop:
Das Installationsfile PIL-1.1.6.win32-py2.5.exe für Python 2.5 (!) finden Sie im Verzeichnis
Y:\lehre\Modul_Einf_in_die_Informatik_WS0809_Jung\Installationsfiles_Python_und_Module\Modul
PIL fuer Python 2.5 oder im WWW unter http://www.pythonware.com/products/pil/ (dort auch das
Installationsfile für Python 2.6). Beim Starten dieser Datei packt sich PIL automatisch in das PythonBibliotheksverzeichnis Python252\Lib\site-packages aus.
- Am Anfang des Lösungsprogramms muss die Klasse Image aus dem Modul PIL importiert werden. Das kann durch from PIL import Image oder auch durch import Image geschehen.
- Kopieren Sie zunächst alle Bildfiles aus Y:\lehre\Modul_Einf_in_die_Informatik_WS0809_Jung\
Pooluebungen\Multimediafiles\Bilder in das Python-Quelltextverzeichnis Z:\Python.
- Unter den kopierten jpg-Bildern befindet sich auch ein Bild GoldenGate_Gruenstich.jpg.
Öffnen Sie zunächst dieses Bild (mit einem Grünstich) mit einem beliebigen Bildbearbeitungsprogramm - z.B. mit IrfanView (oder durch Doppelklicken im Windows-Explorer).
- Eine nähere Untersuchung des Bildes ergab:
Der Grünstich kann entfernt werden, wenn man:
- in allen Pixeln mit einem Rotwert von 0<=Rotwert<=80 den Rotwert um 100% erhöht
- und in allen Pixeln mit einem Blauwert von 0<=Blauwert<=90
den Blauwert um 66,67% erhöht.
--------
Aufgabe:
Schreiben Sie ein Python-Skript zur Korrektur des Grünstichs
GoldenGate_Gruenstich.jpg. Gehen Sie dabei wie folgt vor:
- Beginnen Sie den Quelltext mit einer gesonderten Funktion zur Beseitigung des o.g. Grünstichs.
- Nach dieser Funktion sind ins Hauptprogramm folgende Anweisungen aufzunehmen:
-- Das grünstichige Bild öffnen und daraus ein internes Bildobjekt erzeugen
-- Die Funktion zur Grünstichkorrektur aufrufen (Bildobjekt übergeben)
-- Nach Rückkehr aus der Funktion das korrigierte Bild anzeigen
-- schließlich das korrigierte Bild z.B. unter dem Bezeichner GoldenGate_ohneStich.jpg
ins Python-Arbeitsverzeichnis Z:\Python speichern
2
1108
in
Wichtige Bemerkung zur Methode show( ) aus PIL:
Diese Methode ist relativ einfach gehalten: das Bild wird in ein temporäres BMP-File mit einem vom
System gewählten Namen konvertiert und mit der mit dem Typ BMP verbundenen Anwendung geöffnet.
(Etwa unglücklich ist das im Pool die umfangreiche Anwendung Photoshop.) Zuvor wird noch die
schwarze MS-DOS-Konsole geöffnet. Damit die Programmabarbeitung fortgesetzt wird, muss man (z.B.
mit der Maus) die geöffnete schwarze MS-DOS-Konsole schließen.
-------Öffnen Sie danach GoldenGate_ohneStich.jpg mit einem beliebigen Bildbearbeitungsprogramm.
-----------------------------------------------------------------------------------------------------------------------------
4*) (falls Zeit nicht mehr reicht Hausaufgabe)
Manipulation von Sound: Hinzufügen eines Echo-Effekts zu einem WAV-Sound
Diese Aufgabe baut auf dem VorlesungsskriptIinformatik10_Sound.pdf (Erzeugen von Echos) auf.
Vorbereitung:
In
der
Poolübung
3
sollten
Sie
alle
wav-Soundfiles
Einf_in_die_Informatik_WS0809_Jung\Pooluebungen\Multimediafiles\Sound
Quelltextverzeichnis Z:\Python kopieren (holen Sie dies evtl. nach).
aus
in
Y:\lehre\Modul_
das
Python-
Wählen Sie zunächst ein wav-File aus den kopierten wav-Files aus, zu dem Sie einen Echo-Effekt hinzufügen wollen.
Vorschlag: Wählen Sie ThisIsATest.wav, Spam-Song_MontyPython.wav, DontBeLate_2050.wav
bzw. – speziell zur Weihnachtszeit passend - GoTellItOnTheMountain_22050.wav.
Der Grundgedanke beim Echo-Effekt ist aus der Vorlesung bekannt:
- Jeder neue Sample-Wert (im Sound mit Echo) enthält Anteile des bisherigen Samples plus Anteile des
Samples, das delay (übliche Größe: delay aus Bereich 10000, …, 20000) Samples zurück liegt.
- Bekanntlich darf (bei 16 Bit Sampling-Tiefe) ein Samplewert nicht größer als 32767 sein (sonst wird
„abgeschnitten“ – sog. „Clipping“ -, was schlecht klingt). Deshalb lässt man den jeweiligen ursprünglichen Samplewert und das Echo-Sample mit Faktoren < 1 in den neuen Sound einfließen.
Aufgabe:
Lesen Sie im Hauptprogramm die Dateibezeichnung eines wav-Soundfiles ein (Vorschläge für geeignete wav-Soundfiles: siehe oben), und erzeugen Sie daraus ein internes Soundobjekt.
In einer gesonderten Funktion, an die beim Aufruf dieses interne Soundobjekt und ein Delay-Wert (z.B.
15000) als aktuelle Parameter zu übergeben sind, ist zunächst ein zweites Soundobjekt als Kopie des
übergebenen Soundobjekts zu erzeugen. Diesem Zielsound ist nun das Echo hinzuzufügen. Dabei sollen
in das neue Zielsound-Objekt der jeweilige ursprüngliche Samplewert mit dem Faktor 0.7 und das
Echo-Sample mit dem Faktor 0.3 einfließen. (Dadurch wird die bisherige Lautstärke annähernd beibehalten und Clipping vermieden.)
Das neue Soundobjekt mit Echo ist an das Hauptprogramm als Resultat zurückzugeben. Schließlich ist
im Hauptprogramm das neue Soundobjekt abzuspielen und dann in das Python- Arbeitsverzeichnis unter einer veränderten Filebezeichnung zu speichern.
Vorgehen zur Lösung:
Öffnen Sie aus dem Verzeichnis der Poolübung 5 das unvollständige Teilprogramm
echoToSoundStartfile.py. Ergänzen Sie dieses Startfile zu einem vollständigen Programm.
------------------------------ Fakultativer Zusatz: Bisher (und auch im Echo-Beispiel aus der Vorlesung) ist im Lösungs-WAVFile der Echo-Nachhall nach dem Ende des Original-Sounds noch nicht enthalten. Modifizieren Sie den
Quelltext, so dass der Zielsound auch diesen Echo-Nachhall enthält. (Testen Sie mit ThisIsATest.wav.)
3
1108
5*)
(Hausaufgabe) Nutzung des Zufallszahlengenerators von Python
Eingabe eines Tipps für die Spielart „5 aus 90“, Ziehung der Gewinnzahlen
und Auswertung
(vgl. Aufg.-komplex Struktogramme, Aufg. 16*)
Schreiben Sie folgendes vollständige Python-Programm:
Vom Hauptprogramm aus sollen drei Funktionen aufgerufen werden:
- zuerst eine Funktion zur Eingabe (über Tastatur) eines Tipps für die Spielart „5 aus 90“
- dann eine Funktion für eine Ziehung der Glückszahlen der Spielart „5 aus 90“ mithilfe des
Zufallszahlengenerators (mit anschließender Ausgabe der Glückszahlen auf den Bildschirm).
Dabei ist zu beachten, dass eine gezogene Glückszahl nicht noch einmal gezogen werden darf.
(Hinweis: Hier soll nicht die Funktion sample(…) aus dem Modul random verwendet werden.)
- und zuletzt eine Funktion zur Auswertung, wie viele Zahlen im Tipp richtig waren.
Die Anzahl der richtig getippten Zahlen ist im Hauptprogramm auszugeben.
In den Funktionen ist nicht mit globalen Variablen zu arbeiten.
Vorgehen bei der Lösung: Öffnen Sie das unvollständige Startfile zufall5aus90Startfile.py aus
dem Verzeichnis der Poolübung 5. Die Funktion tipp5aus90( ) ist dabei vollständig gegeben.
Vervollständigen Sie die Funktionen ziehung5aus90( ) und auswertung(…) sowie das Hauptprogramm.
**********************************************************************************
Die drei Anhänge A) B) C) sind - wie stets - VOR der Übung durchzuarbeiten
(während der Übung ist dafür keine Zeit vorgesehen)
Anhang A:
Übungen im interaktiven Modus zur Aufgabe 1 (Liste von Listen)
Im Folgenden soll interaktiv folgende reelle (2x4)-Matrix als Liste, bestehend aus zwei (Zeilen-) Listen,
eingegeben und zur Kontrolle wieder ausgegeben werden:
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
matrix=[]
#Matrix als leere Liste initialisieren
zeile=[1.0,2.0,3.0,4.0]
#Zuweisung der 1.Matrixzeile
matrix.append(zeile)
#Anhaengen der 1.Zeile an (leere) Matrix
matrix
#Unformatierte Kontrollausgabe
zeile=[5.0,6.0,7.0,8.0]
#Zuweisung der 2.Matrixzeile
matrix.append(zeile)
#Anhaengen der 2.Zeile an Matrix
matrix
#Unformatierte Ausgabe der (2x4)-Matrix (Liste von Listen!)
matrix[1]
#Unformatierte Ausgabe der zweiten Matrixzeile
matrix[1][2]
#Unformatierte Ausgabe des dritten Elements der zweiten Matrixzeile
for i in range(2):
#Formatierte Ausgabe der (2x4)-Matrix
for j in range(4):
print "%.2f " %matrix[i][j], #Komma-->kein Zeilenwechsel
print
#Zeilenwechsel nach Ausgabe einer Zeile
>>> #Oder andere Moeglichkeit zur formatierten Ausgabe ohne Indizes:
>>> for zeile in matrix:
for zahl in zeile:
print "%.2f " %zahl,
#Komma-->kein Zeilenwechsel
print
#Zeilenwechsel nach Ausgabe einer Zeile
----------------------------------------------------------------------------------------------------------------------------4
1108
Anhang B:
Übungen im interaktiven Modus zur Aufgabe 2 (Datentyp Dictionary)
# Ein kleines Telefonbuch als Dictionary
>>>televerz={"Peter":"(03731) 434733","Katja":"(45223) 784412",\
"Max":"(55433) 2356"}
#Zuweisung eines Dictionary
>>>type (televerz)
#Ausgabe des Typs
>>>televerz
#Ausgabe des Dictionary (in dieser Form nur im interaktiven Modus moeglich)
>>>print televerz
#unformatierte Ausgabe mit print
>>>televerz["Katja"]
#Zugriff auf Telefonnummer (=Wert) über Schluessel (=Name);
#dabei entspricht der Schluessel bei Dictionaries dem Index bei Listen
>>>televerz["Max"]
>>>print "%s\n%s\n%s" %(televerz["Peter"],televerz["Katja"],televerz["Max"])
#formatierte Ausgabe mit print; wieder Schluessel statt Index
>>>televerz["Vera"] = "(03733) 344555"
#Eingabe eines neuen Paares durch Zuweisung
>>>print televerz
>>>televerz["Paul"]=raw_input("Telefonnr. von Paul mit Vorwahl: ")
#Eingabe eines neuen Paares von Tastatur
>>>televerz["Anja"]=raw_input("Telefonnr. von Anja mit Vorwahl: ")
>>>print televerz
>>>del televerz["Peter"]
#Loeschen des Eintrags mit dem Schluessel "Peter"
>>>televerz
>>>"Katja" in televerz #gibt True zurueck, falls Key "Katja" enthalten, sonst False
>>>woerterbuch={}
#Zuweisung eines leeren Dictionary als Anfangswert
>>>woerterbuch
#Und noch eine kurze Uebung zu Strings:
>>>str="Hallo"
>>>strGross=str.upper()
#Umwandlung des String in nur Grossbuchstaben
>>>print strGross
>>>strKlein=str.lower()
#Umwandlung des String in nur Kleinbuchstaben
>>>print strKlein
-----------------------------------------------------------------------------------------------------------------------------
Anhang C:
Übungen im interaktiven Modus zur Aufgabe 3 (Bildbearbeitung mit PIL)
- Geben Sie im folgende Kommandos ein und interpretieren Sie deren Wirkung:
>>> import Image
# Klasse Image (aus PIL) importieren
>>> im = Image.open(r"Z:\Python\everest.jpg")
#jpg-Bild oeffnen (einlesen) und internes Bildobjekt im erzeugen
>>> print im.format, im.size, im.mode
# Attribute Bildformat, Bildgroesse als Tupel (Breite, Hoehe), Bildmodus ausgeben
>>> im.show()
# Bildausgabe auf Bildschirm
# --> siehe Bemerkung zu show() unter Aufgabe 3
>>> im.save(r"Z:\Python\everest.png") # Speichern mit Konvertierung
>>> width, height = im.size
# Bildgröße an Tupel (width, height) zuweisen
5
1108
# oder: (width, height) = im.size
for xpix in range (width):
# von 0 bis width-1
for ypix in range (height):
# von 0 bis height-1
r, g, b = im.getpixel((xpix, ypix)) # pixelweise RGB-Werte holen
rneu, gneu, bneu = r, g, int(0.8*b) # Blauanteil reduzieren
im.putpixel( (xpix,ypix), (rneu,gneu,bneu) )
# Setzen der manipulierten RGB-Intensitaeten
>>> im.show()
# Bildausgabe des manipulierten Bildes auf Bildschirm
>>> im.save(r"Z:\Python\everest_wenigerBlau.jpg")
---------------------------------------------------------------------------------------------------------------------------->>>
Anhang D (Hausaufgabe):
Übungen im interaktiven Modus zur Aufgabe 4 (Zufallszahlengenerator)
Vorbemerkung zum Zufallszahlengenerator und zum Python-Modul random
- Auch Python besitzt eine Möglichkeit, ganze bzw. reelle Zufallszahlen mit dem sog. (Pseudo-) Zufallszahlengenerator zu erzeugen (siehe dazu auch Skript informatik08.pdf, S. 15/16). Dazu muss man
vor der Benutzung des Zufallszahlengenerators das Modul random importieren.
Pseudo-Zufallszahlengeneratoren (im Folgenden kurz: Zufallszahlengeneratoren) liegt eine exakte deterministische Rechenvorschrift für die Erzeugung der (i+1)-ten Zufallszahl aus der i-ten Zufallszahl
zugrunde. Allerdings wird für jeden Zufallszahlengenerator statistisch getestet, dass die erzeugten Folgen praktisch alle Eigenschaften echter Zufallszahlenfolgen besitzen.
Man kann sich die von einem Zufallszahlengenerator erzeugte Folge von Zufallszahlen wie eine dicke
„Zahlentafel“ mit Zufallszahlen vorstellen. Vor der Benutzung muss man einen Zufallszahlengenerator
stets zufällig initialisieren. Diese zufällige Initialisierung kann man sich als Wahl einer zufälligen Startzahl (sog. Samen, englisch: seed) aus der „Zahlentafel“ mit Zufallszahlen vorstellen. (Nach dem (ersten)
Import des Moduls random erfolgt automatisch eine zufällige Initialisierung mit der Zeit.)
- Das Modul random enthält z.B. die folgenden wichtigen vier Funktionen:
seed( )
zufällige Initialisierung des Zufallszahlengenerators auf der Basis der aktuellen Zeit
random( )
gibt eine nächste reelle Zufallszahl aus dem Bereich [0.0, 1.0) zurück
randint(a, b) gibt eine nächste ganze Zufallszahl aus dem abgeschlossenen Bereich [a,b] zurück
uniform(a,b) gibt eine nächste float-Zufallszahl aus dem abgeschlossenen Bereich [a,b] zurück
- Kurze Übung dazu im interaktiven Modus der IDLE:
>>>import random #Import des Moduls random mit zufälliger Initialisierung des Zzgenerators
>>>print random.randint(1,20)
#int-Zufallszahl aus [1,20]
>>>for i in range(10):
print random.randint(1,90) #10 int-Zufallszahlen aus [1,90]
>>>print random.random()
#eine float-Zufallszahl aus [ 0.0, 1.0)
>>>print 10+15*random.random()
#eine float-Zufallszahl aus [10.0, 25.0)
>>>random.uniform(10,25)
#eine float-Zufallszahl aus [10.0, 25.0]
>>>i=3
>>>print i in [1,3,5] #Operator in testet Zugehoerigkeit zu Kollektion (Sequenz, Menge)
6
1108