Übungen
Aufgabe 1: Ein Modul benutzen
Zur Klasse Wuerfel
soll folgende Implementierung in einer Datei wuerfel.py
abgespeichert sein:
from random import randint
class Wuerfel(object):
def __init__(self):
self.augen = randint(1, 6)
def werfen(self):
self.augen = randint(1, 6)
(a) Was leistet das folgende Programm, das das Modul Wuerfel
als Baustein benutzt?
from wuerfel import *
# Würfelprogramm
w = Wuerfel()
w.werfen()
versuche = 1
while w.augen != 6:
w.werfen()
versuche = versuche + 1
print("Anzahl der Versuche:", versuche)
(b) Es soll getestet werden, wie oft man drei Würfel werfen muss, bis mindestens einer eine 6 liefert.
Entwickle ein geeignetes Simulationsprogramm, das die Klasse Wuerfel
als Baustein benutzt.
(c) Erstelle eine Schnittstellenbeschreibung der Klasse Würfel.
Aufgabe 2: Ein Modul benutzen
Die Klasse Schlange
kann man verwenden, um Warteschlangen zu simulieren.
class Schlange(object):
def __init__(self):
self.liste = []
def istLeer(self):
if self.liste == []:
return True
else:
return False
def mitLetztem(self, element):
self.liste = self.liste + [element]
def ohneErstes(self):
if not self.istLeer():
self.liste = self.liste[1:]
def erstes(self):
if self.istLeer():
return None
else:
return self.liste[0]
def anzahlElemente(self):
return len(self.liste)
def getSchlange(self):
return self.liste
def setSchlange(self, liste):
self.liste = liste
(a) Teste zunächst interaktiv, wie man ein neues Schlange
-Objekt erzeugt und die Schlangenoperationen
zur Verwaltung von Daten nutzt, z.B. so:
>>> s = Schlange()
>>> s.getSchlange()
[]
>>> s.mitLetztem(4)
>>> s.mitLetztem(7)
>>> s.getSchlange()
[4, 7]
>>> s.erstes()
4
>>> s.ohneErstes()
>>> s.getSchlange()
[7]
>>> s.setSchlange([3, 9, 6])
>>> s.getSchlange()
[3, 9, 6]
Erstelle ein Klassendiagramm und eine Schnittstellenbeschreibung zur Klasse Schlange
.
Die Darstellung soll so sein, dass die Klasse benutzt werden kann, ohne dass man den
die Implementierung analysieren muss.
(b) Entwickle ein Programm, das die Verwendung der Klasse Schlange
verdeutlicht.
Eine einfache Aufgabe könnte wie folgt lauten: Der Benutzer wird wiederholt aufgefordert, eine bestimmte Eingabe zu machen (z.B. eine Zahl eingeben). Alle Benutzereingaben werden gesammelt. Hierzu wird die Schlange benutzt. Danach werden die gesammelten Benutzereingaben der Reihe nach abgearbeitet (bei Zahlen z.B. verdoppelt und ausgegeben).
Eine andere Aufgabe könnte darin bestehen, eine Warteschlange zu simulieren: Mit einer vorgegebenen Wahrscheinlichkeit kommt in jedem Schritt ein neuer Kunde in die Warteschlange, mit einer anderen vorgegebenen Wahrscheinlichkeit wird in jedem Schritt ein Kunde bedient - sofern sich einer in der Warteschlange befindet. Interessant ist hier die Frage, wie lang die Schlange bei vorgegebenen Wahrscheinlichkeiten wird. Der folgende Python-Quelltext zeigt, wie man mit Wahrcheinlichkeiten umgeht.
from random import random
wAnstellen = 0.6 # Wahrscheinlichkeit
zAnstellen = random() # Zufallszahl aus dem Intervall [0, 1[
# Anstellen
if zAnstellen < wAnstellen:
# ...
Aufgabe 3: chuck a luck
Ziel ist es, das Spiel chuck a luck
mit Objekten zu simulieren.
Informiere dich gegebenenfalls im Abschnitt
Einstieg - Das Spiel chuck-a-luck,
wie das Spiel funktioniert.
Folgende Klassen sollen als Bausteine zur Simulation zur Verfügung gestellt werden:
(a) Implementierungen der Klasse Wuerfel
und Konto
liegen bereits vor.
Entwickle selbst die noch fehlende Implementierung zur Klasse Spielzahl
.
Mit Hilfe dieser Bausteine sollen dann Python-Dialoge wie der folgende möglich sein.
>>> k = Konto(100)
>>> s = Spielzahl()
>>> wA = Wuerfel()
>>> wB = Wuerfel()
>>> wC = Wuerfel()
>>> k.auszahlen(1)
>>> k.stand
99
>>> s.setzen(3)
>>> s.zahl
3
>>> wA.werfen()
>>> wB.werfen()
>>> wC.werfen()
>>> wA.augen
3
>>> wB.augen
6
>>> wC.augen
2
>>> k.einzahlen(2)
>>> k.stand
101
(b) Mit Hilfe eines Simulationsprogramms soll ermittelt werden, ob das chuck-a-luck-Spiel fair ist. Ergänze und teste hierzu das folgende Programm.
from chuckaluck import *
# Erzeugung der Objekte
k = Konto(100)
s = Spielzahl()
wA = Wuerfel()
wB = Wuerfel()
wC = Wuerfel()
# feste Spielzahl setzen
s.setzen(6)
# wiederholte Durchführung des Spiels
i = 0
while i < 100:
# ...
i = i + 1
# Ausgabe des Kontostands
print(k.stand)
Aufgabe 4: Schnittstellenbeschreibung
Gegeben ist folgende Implementierung der Klasse Bruch
:
class Bruch(object):
def __init__(self, z, n):
self.zaehler = z
self.nenner = n
def erweitern(self, k):
self.zaehler = self.zaehler * k
self.nenner = self.nenner * k
def kuerzen(self, k):
if (self.zaehler % k == 0) and (self.nenner % k == 0):
self.zaehler = self.zaehler // k
self.nenner = self.nenner // k
def vollstaendigKuerzen(self):
# ggT von Zähler und Nenner bestimmen
x = self.zaehler
y = self.nenner
while y > 0:
h = x % y
x = y
y = h
ggt = x
# kürzen
self.kuerzen(ggt)
def add(self, b):
x1 = self.zaehler
x2 = self.nenner
y1 = b.zaehler
y2 = b.nenner
z1 = x1*y2 + x2*y1
z2 = x2*y2
self.zaehler = z1
self.nenner = z2
self.vollstaendigKuerzen()
def darstellen(self):
bruchAlsZeichenkette = str(self.zaehler) + '/' + str(self.nenner)
return bruchAlsZeichenkette
(a) Erstelle ein Klassendiagramm und eine Schnittstellenbeschreibung zur Klasse Bruch
.
(b) Entwickle ein Testprogramm, das die Klasse Bruch
als Modul benutzt.
(c) Füge der Klasse Bruch
weitere Operationen hinzu und teste diese Erweiterung.
Aufgabe 5: Einbindung von Modulen
Teste die Einbindung folgender Modulimporte und ihre Auswirkung auf den globalen Namensraum.
>>> from random import randint
>>> globals()
>>> from random import *
>>> globals()
>>> import random
>>> globals()
Warum wird bei sehr umfangreichen Modulen empfohlen, die dritte der oben aufgelisteten Einbindungsvarianten zu benutzen?