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

TU Bergakademie Freiberg
Institut für Informatik
Modul „Einführung in die Informatik“
Poolübung
6. Pool-Übung zum Modul „Einführung in die Informatik“
- Aufgaben Thema: Programmieren in Python, Teil 4
(Bildbearbeitung mit PIL, Files, Zeichenketten; Wiederholung: Funktionen, Module;
Hausaufgabe: Objektorientierte Programmierung)
0)
Vorbereitende Übungen zur 6. Poolübung im interaktiven Modus von Python
(VOR der Übung durchzuarbeiten):
Anhang A:
Anhang B:
Anhang C:
Übungen im interaktiven Modus zur Aufgabe 1 (Bildbearbeitung mit PIL)
Übungen im interaktiven Modus zur Aufgabe 2 (Files)
(Hausaufgabe) Übungen im interaktiven Modus zur Aufgabe 4
(Objektorientierte Programmierung:
Klassen und Objekte)
----------------------------------------------------------------------------------------------------------------------------
1)
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_WS1112_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 und 2.7). Beim Starten dieser Datei packt sich PIL automatisch in das
Python-Bibliotheksverzeichnis 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.
- In Aufg. 1 wird die Kenntnis des Vorlesungsskripts Informatik12-Bildverarbeitung.pdf vorausgesetzt.
- Kopieren Sie zunächst alle Bildfiles aus Y:\lehre\Modul_Einf_in_die_Informatik_WS1112_Jung\
Pooluebungen\Multimediafiles\Bilder in das Python-Quelltextverzeichnis W:\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.
1
1111
in
- Nach dieser Funktion sind ins Hauptprogramm in Form eines Testrahmens 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 W:\Python speichern
Wichtige Bemerkung zur Methode show( ) aus PIL:
Die Methode show( ) 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. Zuvor wird noch eine (schwarze) MS-DOS-Konsole geöffnet. Damit die Programmabarbeitung
nach show( ) fortgesetzt wird, muss man (z.B. mit der Maus) die geöffnete schwarze MS-DOS-Konsole
schließen (dann bleibt das Bild stehen) oder das Bild selbst schließen (dann wird auch das MS-DOSFenster geschlossen).
-------Öffnen Sie danach GoldenGate_ohneStich.jpg mit einem beliebigen Bildbearbeitungsprogramm
(z.B. IrfanView).
-----------------------------------------------------------------------------------------------------------------------------
2)
Dateiarbeit (Files):
Einlesen eines Datenfiles mit ganzen Zahlen von Festplatte,
Berechnung der Fakultäten dieser Zahlen sowie
Schreiben der Resultate auf den Bildschirm und in ein neues Festplattenfile
(vgl. Vorlesung und Großübung 5, Aufg. 2.2)
In der 4. Großübung wurde in Aufgabe 1.a) ein Programm entwickelt, in dem in einer Funktion
nfak(n);
n ... natürliche Zahl (d.h. ganz und >= 0);
die Fakultät n! einer aus einem Testrahmen (Hauptprogramm) übergebenen natürlichen Zahl n
(mittels for-Zählschleife) ermittelt wird. Dieses Programm wurde als nfak_for_Modul.py gespeichert.
Dieses File ist im Plattenverzeichnis der 6. Poolübung zu finden. In Aufgabe 2 sollen dieses Modul
importiert und die Funktion nfak(n) daraus verwendet werden (vgl. dazu 4. Großübung, Aufg. 2).
Vorbemerkungen:
- Wie in der Vorlesung behandelt, betrachtet Python Files (=Dateien) als Sequenz von Zeichen, die mit
den built-in-Funktionen nur als Zeichenkette (String) gelesen oder geschrieben werden können.
Will man also Zahlen aus einem File einlesen und dann verarbeiten, so muss man nach dem Lesen den
Zahlenstring durch int( ) bzw. float( ) in den geforderten Zahlentyp konvertieren. Beim Schreiben von
Zahlen in Files sind sie vorher mit str( ) in eine Zeichenkette zu konvertieren.
- Im Festplattenverzeichnis der 6. Poolübung ist ein ASCII-Textfile gzahlen.txt gespeichert, das natürliche ganze Zahlen (1 Zahl pro Zeile) enthält. Kopieren Sie dieses File ins Python-Arbeitsverzeichnis
W:\Python. Sehen Sie sich zunächst den Inhalt dieser Datei mit einem beliebigen Editorprogramm an
(z.B. Notepad/Editor).
Aufgabe: Ein vollständiges Python-Programm ist zu entwickeln, in dem alle ganzen Zahlen aus dem
Festplattenfile W:\Python\gzahlen.txt in eine Liste eingelesen werden. Danach ist von jedem Listenelement die Fakultät zu bestimmen, wozu die Funktion nfak(n) aus dem Modul nfak_for_Modul.py zu
verwenden ist (siehe oben).
Die Resultate sind in der Form (hier für das Beispiel n=3 angegeben):
3! = 6 auf den Bildschirm
sowie in ein neues Festplattenfile W:\Python\fakultaeten.txt auszugeben (pro Fakultät eine Zeile).
Sehen Sie sich danach zur Kontrolle den Inhalt des Files W:\Python\fakultaeten.txt mit einem beliebigen
Editorprogramm an (z.B. Notepad/Editor).
2
1111
3)
Berechnung der Quersumme einer natürlichen Zahl
sowie der Summe von Quersummen natürlicher Zahlen
a)
Berechnung der Quersumme einer natürlichen Zahl
Schreiben Sie eine Python-Funktion für die Berechnung der Quersumme einer natürlichen Zahl
(natZahl = 0, 1, 2, 3, …). Die natürliche Zahl ist vom aufrufenden Skript zu übergeben. Die berechnete
Quersumme ist an das aufrufende Programm zurückzugeben. In der Funktion ist nicht mit globalen Variablen zu arbeiten.
In einem Testrahmen (Hauptprogramm) zum Testen der Funktion ist eine natürliche Zahl von Tastatur
einzulesen. Danach ist die Funktion zur Berechnung der Quersumme aufzurufen. Das Resultat (Quersumme) soll im aufrufenden Testrahmen ausgegeben werden.
Fordern Sie im Testrahmen den Nutzer nach jeder erfolgten Berechnung einer Quersumme zur Eingabe
einer nächsten natürlichen Zahl auf. Ein Abbruch der Berechnung soll dabei durch Eingabe einer (beliebigen) negativen Zahl (als „natürliche Zahl“) erreicht werden.
- Beispiel zur Erklärung der Quersumme:
quersumme(4233) = 4+2+3+3 = 12
- Hinweis zum Lösungsalgorithmus:
Schreiben Sie zwei Versionen zur Berechnung der Quersumme:
- Erste Version: Konvertierung der eingelesenen natürlichen Zahl in einen String, zeichenweiser Zugriff auf die „Zifferbuchstaben“ und Konvertierung der „Zifferbuchstaben“ in eine ganze
Zahl.
Hinweis zum „zeichenweisen Zugriff“:
Es ist bekannt, dass die Zählgröße i aus der folgenden for-Schleife der Reihe nach die Werte
1, 2, …, 10 (also die Elemente der Liste) annimmt:
>>>for i in [1,2,3,4,5,6,7,8,9,10]:
print i
Allgemein gilt dies aber nicht nur für Listen, sondern für Kollektionen, d.h. für Listen, Zeichenketten,
Tupel, Dictionaries und Mengen. Also nimmt z.B. im folgenden Beispiel die Variable zeichen der Reihe
nach als Wert die Zeichen der Zeichenkette "Informatik" an (dadurch „zeichenweiser Zugriff“
möglich):
>>>for zeichen in "Informatik":
print zeichen, " ",
Nennen Sie in der ersten Lösungsversion die Funktion quersum(n). Speichern Sie die erste Lösungsversion unter der Bezeichnung W:\Python\auf3a_quersumme.py ab. Dieser Quelltext soll in
Aufgabe b) als Modul importiert werden.
Verwenden Sie eventuell als Startfile das unvollständige Skript auf3a_quersumme_Startfile.py
- Zweite Version: sukzessive Verwendung des Divisionsrests der ganzzahligen Division
durch 10 sowie danach „Abhacken“ der letzten Ziffer der Zahl durch ganzzahlige Division durch 10 .
(Der Testrahmen ist in beiden Versionen gleich.)
Verwenden Sie eventuell als Startfile das unvollständige Skript auf3a_quersumme_V2_Startfile.py
-----------------
b)
Erweiterung
(Hausaufgabe):
Summe von Quersummen mehrerer natürlicher Zahlen
Erweitern Sie die erste Version der Lösung von 3.a) wie folgt:
Jetzt soll nicht die Quersumme einer natürlichen Zahl berechnet werden, sondern die Summe der
Quersummen mehrerer eingegebener natürlicher Zahlen. Eine Wiederholung der Berechnung (während eines Programmlaufs) wie in 3.a) soll hier aus Einfachheitsgründen nicht vorgesehen werden.
Beispiel:
Eingegeben wurde: [34, 567, 700]
Summe der 3 Quersummen = 32
1111
3
Hinweise zur Lösung:
Verwenden
Sie
evtl.
als
Startfile
das
unvollständige
Python-Programm
auf3b_summeVonQuersummen_Startfile.py aus dem bekannten Poolübungsverzeichnis.
In diesem Startfile erfolgt die Berechnung der Summe der Quersummen in folgender Weise:
- Im Hauptprogramm (Testrahmen) werden die natürlichen Zahlen eingegeben (Abbruch: beliebige negative Zahl) und in einer Liste natürlicher Zahlen gespeichert.
- Dann wird eine Funktion zur Berechnung der Summe der Quersummen aufgerufen. In dieser
Funktion (!!!) soll innerhalb der Anweisung zur Summenberechnung jeweils eine Funktion zur Berechnung der Quersumme einer natürlichen Zahl aufgerufen werden und zwar genau die Funktion zur
Berechnung der Quersumme aus der ersten Lösungsversion von 3.a). Dazu sollen der Quelltext
W:\Python\auf3a_quersumme.py aus 3.a) als Modul importiert und die Funktion quersum(n) daraus
genutzt werden. (Hier wird also eine Funktion von einer anderen Funktion aus aufgerufen.)
- Die Lösung wird schließlich wieder im Testrahmen ausgegeben.
Ergänzen Sie das Startfile an den gekennzeichneten Stellen, und testen Sie das Programm.
-----------------------------------------------------------------------------------------------------------------------------
4*)
(Hausaufgabe)
Erzeugung von Objekten (Instanzen) einer eigenen Klasse Sphere („Kugel“)
und Übungen damit (OOP- Objektorientierte Programmierung)
Die folgende Aufgabe ist bewusst ähnlich zum Musterbeispiel aus dem Vorlesungsskript informatik11OOP.pdf, um zugleich das Verständnis für die Vorlesung zu fördern. Nehmen Sie also bei der Lösung
dieses Skript zu Hilfe.
Zu entwickeln ist ein vollständiges Python-Programm, in dem zunächst eine Klasse Sphere für das geometrische Objekt Kugel (Sphere) zu definieren ist. Diese Klasse soll als stark private
(Objekt-)Attribute (also keine öffentlichen Attribute) die drei Mittelpunktkoordinaten x, y, z sowie den
Radius r besitzen. (Auf ein solches – vor öffentlichem Zugriff geschütztes – stark privates Attribut kann
man nur innerhalb der Methoden eines Objekts der Klasse zugreifen. Von außerhalb kann man auf
stark private Attribute nur noch über Getter- und Setter-Methoden zugreifen.)
Fügen Sie ein (logisch zur Klasse gehörendes) Klassenattribut __numSpheres (siehe Vorlesung:
Bekanntlich gibt es Objektattribute, die sich auf Eigenschaften einzelner Objekte beziehen, und Klassenattribute, die Merkmale aller Objekte einer Klasse darstellen). Das Klassenattribut __numSpheres
soll als Wert die Anzahl der Objekte (Instanzen) der Klasse Sphere annehmen. Nach jeder Erzeugung
einer neuen Instanz soll der aktuelle Wert von __numSpheres ausgegeben werden.
Neben der Konstruktormethode soll die Klasse vier weitere Methoden besitzen:
- eine Methode zum Setzen des Mittelpunkts x,y,z (sog. Setter-Methode),
- eine Methode, die den aktuellen Mittelpunkt zurückgibt (sog. Getter-Methode)
- sowie je eine Methode zum Setzen und zum Zurückgeben des Radius.
Von einem Hauptprogramm in Form eines Testrahmens aus sind Objekte dieser Klasse zu erzeugen
und die Attribute zu manipulieren. Dabei ist wie folgt vorzugehen:
-- Erzeugung einer Einheitskugel als Objekt (Instanz) der Klasse Sphere
-- Ausgabe des beim Erzeugen gesetzten Mittelpunkts und Radius’ über die GetterMethoden (direkter Zugriff nicht möglich – probieren Sie es aus)
-- Setzen eines neuen Mittelpunkts und eines neuen Radius’ durch Methodenaufruf
-- Ausgabe des veränderten Mittelpunkts und Radius’ über die Getter-Methoden
-- Erzeugen eines beliebigen zweiten Objekts der Klasse Sphere,
um die erneute Ausgabe des Klassenattributs __numSpheres zu testen
Verwenden Sie eventuell als Startfile das unvollständige Skript auf4_classSphereStartfile.py.
----------------------------------------------------------------------------------------------------------------------------1111
4
Da es die 6. Poolübung die letzte Poolübung zu Python ist, wurden auf Wunsch
einiger Studenten mehrere fakultative zusätzliche Hausaufgaben zur individuellen
Übung ausgearbeitet. Um das vorliegende Aufgabenmanuskript nicht zu lang werden zu lassen, sind diese Zusatz-Hausaufgaben im pdf-Dokument
Pooluebung6_EidI_Fakultative_Zusatz-Hausaufg_WS1112.pdf
im Festplattenverzeichnis der Poolübung 6 zu finden.
Achtung: Darunter befindet sich auch eine Klausuraufgabe von 2007 zu Python.
-----------------------------------------------------------------------------------------------------------------------------
Anhänge:
Anhang A:
Übungen im interaktiven Modus zur Aufgabe 1 (Bildbearbeitung mit PIL)
- Geben Sie folgende Kommandos ein und interpretieren Sie deren Wirkung:
>>> import Image
# Klasse Image (aus PIL) importieren
>>> im = Image.open(r"W:\Python\everest.jpg")
#jpg-Bild oeffnen (einlesen) und internes (Bild-)Objekt im der Klasse Image erzeugen;
#ueber das Objekt im kann man nun auf die Methoden und Attribute zugreifen;
#Beim Modul TUBAFSound ist das anders:
#dort keine Methoden (objektorientiertes API), sondern Funktionen (prozedurales API)!
>>> 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 1 !
>>> im.save(r"W:\Python\everest.png") #Speichern; hier mit Konvertierung (jpg png)
>>> width, height = im.size
#Bildgröße an Tupel (width, height) zuweisen
#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)-Tupel 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"W:\Python\everest_wenigerBlau.jpg")
-----------------------------------------------------------------------------------------------------------------------------
Anhang B:
Übungen im interaktiven Modus zur Aufgabe 2 (Files)
Die Dateiarbeit (Arbeit mit Files auf Festplatte usw.) wurde im Vorlesungsskript
Informatik09-Python-IO.pdf behandelt. Dieser Vorlesungsstoff wird in Aufgabe 2 vorausgesetzt.
Dateien (files) sind Datenobjekte, die unter einem Dateibezeichner auf einem Peripheriespeicher
(Festplatte, CD-ROM, DVD, Mediacard, Diskette, ...) gespeichert sind und dort vom Betriebssystem
verwaltet werden.
Python betrachtet Files (=Dateien) allgemein als Sequenz von Zeichen (1 Byte/Zeichen), die mit den
eingebauten ("built-in") Funktionen nur als Zeichenkette gelesen bzw. geschrieben werden können.
Ein File ist (im Prinzip) beliebig lang; sein Ende wird durch das Steuerzeichen eof (end of file) gekennzeichnet.
5
1111
Mit Hilfe des Konstruktors open( ) der vordefinierten Klasse File kann man gemäß
fileObjekt=open(<filebezeichner>,<modus>) die Datei <filebezeichner> öffnen und ein neues Fileobjekt mit dem Namen fileObjekt erzeugen, das mit dieser Datei verknüpft ist.
(Hinweis: Statt open(<filebezeichner>,<modus>) kann man auch den identischen Konstruktor
file(<filebezeichner>,<modus>) verwenden.) Beim Erzeugen des (logischen) Fileobjekts wird im
Hauptspeicher eine Datenstruktur angelegt, über die die Verbindung zur physischen Datei läuft. In
dieser Datenstruktur wird auch ein „Dateizeiger“ (Cursor) verwaltet. Der Dateizeiger zeigt stets auf das
aktuelle Zeichen der Datei, das als nächstes zu lesen bzw. zu schreiben ist (d.h. auf die sogenannte
"aktuelle Fileposition"). Die zeichenweise Zählung der Datenzeiger-Position beginnt bei 0. Als Beispiel
zeigt der Dateizeiger nach dem Öffnen einer Datei im Modus „r“, „rw“ oder „w“ auf den Anfang der
Datei (Position 0L). Die aktuelle Position des Dateizeigers kann man über die Methode (Funktion)
fileObjekt.tell( )
abfragen.
Man
kann
den
Dateizeiger
über die Methode
fileObjekt.seek(<zeichennummer>) auf eine neue aktuelle Position einstellen.
Man kann sich ein File prinzipiell als ein Magnetband vorstellen, das mit einem Schreib-Lese-Kopf
beschrieben und gelesen werden kann. Der Dateizeiger gibt dann die jeweilige Position des SchreibLese-Kopfes an.
Die wichtigsten Methoden zum Lesen/Schreiben von Dateien wie read, readline, readlines bzw. write,
writelines wurden in der Vorlesung behandelt:
read( )
... gesamte Datei wird (von der aktuellen Dateizeigerposition an) als String eingelesen
(mit allen Newline-Zeichen '\n')
readline( )
... eine Zeile wird (von der aktuellen Dateizeigerposition an) als String eingelesen
(einschließlich des abschließenden Newline-Zeichens '\n')
readlines( ) ... gesamte Datei wird (von der aktuellen Dateizeigerposition an) als Liste von Strings
eingelesen (jede Zeile als ein String einschließlich des abschließenden '\n')
write(string) ... schreibt einen String in die Datei ab aktuelle Dateizeigerposition
(evtl. wird überschrieben)
writelines(sequence) ... eine Sequenz von Strings wird konkateniert und in die Datei geschrieben;
es werden (im Gegensatz zum Namen) keine (!) Zeilenwechsel eingefügt.
(diese Methode braucht man seltener).
Auf die in der Vorlesung behandelte Ausgabe in Files mit print durch File-Umlenkung (mittels „>>“)
und auf das Lesen/Schreiben von Dateien mit den Funktionen load / dump aus dem Modul pickle wird
in der Übung aus Zeitgründen nicht eingegangen.
----------------------------------------------------------------------------------------------------------------------------# Es folgen Übungen im interaktiven Modus der IDLE:
>>> f=open(r'W:\Python\test.out','w')
#Öffnen eines neues File zum Schreiben ('w'); Filebez. wegen \ als raw-String
>>> type(f)
#Durch open(…) wurde ein Objekt f vom Typ file erzeugt
>>> f.tell() #Ausgabe der aktuellen Position des "Dateizeigers" (hier: 0L)
>>> f.write('Freiburk/Sachsen') #Schreiben in File (hier mit Fehlern)
>>> f.tell()
#Ausgabe der aktuellen Position des "Dateizeigers" (hier: 16L)
>>> f.seek(5)
#Einstellen der Position des Dateizeigers auf Zeichen "u"
>>> f.write('erg')#Überschreiben ab "u" (Korrigieren der Fehler)
>>> f.close()
#Schließen des File
>>> f=open(r'W:\Python\test.out','r')
#Öffnen eines existierenden Files zum Lesen ('r')
>>> text=f.read()
>>> print text
#Ausgabe des korrigierten Textes: 'Freiberg/Sachsen'
>>> f.close()
# Öffnen Sie nun das geschriebene ASCII-File W:\Python\test.out zur Kontrolle
# mit einem beliebigen Editorprogramm (z.B. Notepad/Editor).
6
1111
# Und nun weitere Uebungen zum Lesen/Schreiben von Dateien.
# Erklären Sie die Interpreter-Ausgaben anhand der obigen Beschreibung der Methoden:
>>> f=open(r'W:\Python\datei.txt','w')
>>> f.write('Zeile 1\nZeile 2\nZeile 3\n')
>>> f.writelines(('rot','gelb','gruen'))
>>> f=open(r'W:\Python\datei.txt','r')
>>> print f.readline()
'Zeile 1\n'
#Ausgabe
>>> print f.readlines()
['Zeile 2\n', 'Zeile 3\n', 'rotgelbgruen']
#Ausgabe
>>> print f.seek(0)
>>> print f.read()
'Zeile 1\nZeile 2\nZeile 3\nrotgelbgruen'
#Ausgabe
>>> print f.read()
''
#Ausgabe
>>> f.close()
-----------------------------------------------------------------------------------------------------------------------------
Anhang C*:
(Hausaufgabe) Übungen im interaktiven Modus zur Aufgabe 4*
(Objektorientierte Programmierung:
Klassen und Objekte)
a)
Vorbemerkung zu Klassen und Objekten:
Eine Einführung in die Objektorientierte Programmierung war Gegenstand des Vorlesungsskripts
informatik11-OOP.pdf. Dieser Stoff wird für Aufgabe 4* vorausgesetzt.
Eine Klasse dient als Vorlage (Bauplan, Schablone) für Objekte dieser Klasse. Sie definiert Attribute (in
Form von Variablen) und Methoden (in Form von Funktionen). Ein Objekt ist eine konkrete Ausprägung - eine Instanz - einer Klasse. Erst beim Erzeugen von Objekten erhalten Attribute konkrete Werte
zugewiesen. Über die Methoden können diese Werte manipuliert werden. Die Attribute beschreiben den
Zustand und die Methoden das Verhalten von Objekten.
Aus einer anderen Sicht ist eine Klasse ein komplexer Datentyp mit zugehörigen Methoden, von dem
Variablen (Objekte) angelegt werden können. Jedes Objekt ist aus dieser Sicht eine Datenstruktur eines
komplexen Typs.
Namen von nutzerdefinierten Klassen sollten mit einem Großbuchstaben beginnen, Namen von Objekten mit einem Kleinbuchstaben.
(Hinweis: Auf Polymorphismus und Vererbung wird in der Übung aus Zeitgründen nicht eingegangen.)
-----b)
Vordefinierte Klassen:
Vordefinierte Klassen sind schon aus den ersten Vorlesungen bekannt, z.B. die vordefinierte Klasse list.
- Kurze Übung im interaktiven Modus der IDLE zu vordefinierten Klassen:
>>>li=[2,4,6]
#li verweist auf ein Objekt (Instanz) der vordef. Klasse list
>>>li.append(8) #Aufruf der Listen-Methode append(); ein Methodenaufruf entspricht einer
#Botschaft (Nachricht) an ein Objekt, eine bestimmte Operation auszuführen
>>>print li
>>>li.insert(1,9) #vor dem Listenelement mit Index 1 als neues Element die Zahl 9 einfuegen
>>>li.extend([12,10]) #Aufruf einer weiteren Listen-Methode extend()
>>>print li
>>>li.sort()
#Methode zur aufsteigenden Sortierung der Liste
>>>print li
7
1111
Hinweis zu zwei oben benutzten Listenmethoden:
extend … Erweiterung einer Liste mit Elementen aus Listen, Tupeln, Strings usw.
append … Erweiterung einer Liste um ein Element
-----c)
Definition (nutzer-)eigener Klassen:
- Definition einer Klasse mit dem Schlüsselwort class
- Objekte (Instanzen) einer Klasse werden durch Aufruf der Klasse erzeugt, wobei die Argumente denen
des Konstruktors der Klasse– aber ohne dessen erstes Argument self - entsprechen.
- (Objekt-) Attribute der Klasse werden durch die Konstruktormethode __init__ der Klasse initialisiert;
die Konstruktormethode wird bei der Erzeugung einer Instanz automatisch aufgerufen.
Die Konstruktormethode __init__ darf keine return-Anweisung enthalten. Bei Methoden mit voran- und
nachgestellten doppelten Unterstrichen handelt es sich um überladene Methoden - siehe Vorlesung.
Attribute bestehen aus einem Attributnamen und einem Attributwert. Alle Objekte einer Klasse besitzen
die gleichen Objektattribute, aber möglicherweise unterschiedliche Objektattributwerte.
Bemerkung: Bei Klassenattributen ist die Wertbelegung für alle Objekte einer Klasse gleich.
- das erste Argument des Konstruktors sollte stets self sein, womit das neue Objekt referenziert wird.
- Kurze Übung im interaktiven Modus der IDLE zu (nutzer-)eigenen Klassen:
>>>class Student:
#Definition einer Klasse Student
def __init__(self,n,m):
#Konstruktor(-methode) der Klasse
self.fullName = n
#Initialisierung des (Objekt-)Attributs fullName
self.matrikel = m
#Initialisierung eines weiteren (Objekt-)Attributs
def setMatrikel(self,num):
#Def. einer Methode der Klasse
self.matrikel = num
def getMatrikel(self):
#Def. einer Methode der Klasse
return self.matrikel
>>>print type(Student)
>>>stud1 = Student("Karl Kunze",44544) #Erzeugung der Instanz stud1
>>>print type(stud1)
>>>print stud1.fullName
#Ausgabe eines Attributs
>>>print stud1.matrikel
>>>stud1.setMatrikel(44545)
#Methodenaufruf
>>>print stud1.getMatrikel()
>>>stud2 = Student ("Dieter Krause",39788)
#Zweite Instanz (Objekt)
>>>print stud2.fullName, stud2.matrikel
-----------------------------------------------------------------------------------------------------------------------------
8
1111