Ü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?