Powerpoint-Präsentation

Listen und ihre Verarbeitung
Klaus Becker
2009
2
Listen und ihre Verarbeitung
Brot
Butter
Joghurt
Äpfel
Schokolade
Mehl
Eier
...
Inhalte:

Datenstruktur Liste

Listen als Objekte

Datenmodellierung mit Listen

Stapel

Schlangen
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
...
3
Teil 1
Datenstruktur Liste
Verwaltung von Daten
4
Listen werden in der Informatik - wie auch im täglichen Leben - benutzt, wenn man mehrere
zusammengehörende Daten als eine Einheit darstellen und verwalten will. Da solche
Zusammenstellungen von Daten sehr häufig vorkommen, bildet die Datenstruktur Liste ein
zentrales Konstrukt bei der automatisierten Verarbeitung von Daten.
Brot
Butter
Joghurt
Äpfel
Schokolade
Mehl
Eier
...
Einkaufsliste
[email protected]
[email protected]
[email protected]
[email protected] [email protected] [email protected]
[email protected]
...
Mailingliste
Einstieg - Mailingliste
5
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
...
Mailingliste
M = ['[email protected]', '[email protected]', ... ]
M = [\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]'\
]
Liste mit Zeichenketten
6
Einstieg - Aufgaben (siehe 8.1.1)
Bearbeiten Sie die Aufgaben des Abschnitts 8.1.1.
Aufgabe 1: Eine Liste in Python eingeben
Aufgabe 2: Listenoperationen ausprobieren
Aufgabe 3: Ein Element entfernen
Aufgabe 4: Ein Element hinzufügen.
Bei Bedarf können Sie sich im Abschnitt 8.1.3 über Listen und ihre Verarbeitung informieren.
7
Einstieg - Lotto
# Version 2
Liste mit Zahlen
tipp = [1, 12, 21, 31, 37, 46]
ziehung = [1, 21, 25, 40, 44, 45]
# Version 1
tipp1 = 1
tipp2 = 12
tipp3 = 21
tipp4 = 31
tipp5 = 37
tipp6 = 46
ziehung1 = 1
ziehung2 = 21
ziehung3 = 25
ziehung4 = 40
ziehung5 = 44
ziehung6 = 45
einzelne Zahlen
# Version 3
Liste mit Wahrheitswerten
tipp = [ \
True , False, False, False, False, False, False, \
False, False, False, False, True , False, False, \
False, False, False, False, False, False, True , \
False, False, False, False, False, False, False, \
False, False, True , False, False, False, False, \
False, True , False, False, False, False, False, \
False, False, False, True , False, False, False, \
]
ziehung = [ \
True , False, False, False, False, False, False, \
False, False, False, False, False, False, False, \
False, False, False, False, False, False, True , \
False, False, False, True , False, False, False, \
False, False, False, False, False, False, False, \
False, False, False, False, True , False, False, \
False, True , True , False, False, False, False, \
]
8
Einstieg - Aufgaben (siehe 8.1.2)
Bearbeiten Sie die Aufgaben des Abschnitts 8.1.2.
Aufgabe 1: Zugriff auf Listenelemente
Aufgabe 2: Verarbeitung von Listen
Aufgabe 4: Analyse von Programmen
Aufgabe 5: Ergänzung von Programmen
Aufgabe 6: Entwicklung eines Programms
Bei Bedarf können Sie sich im Abschnitt 8.1.3 über Listen und ihre Verarbeitung informieren.
Lösungen - Aufgaben (siehe 8.1.1)
9
Aufgabe 2: Listenoperationen
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
M
M[0]
M[1]
M[4]
M[0:2]
M[2:5]
M[1:4]
M[3:3]
M + ['[email protected]']
['[email protected]'] + M
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
>>>
?
M[0:1] + M[2:7]
M[0:3] + M[4:7]
M[0:2] + ['[email protected]'] + M[2:7]
M[0:5] + ['[email protected]'] + M[5:7]
len(M)
len(M[3:6])
10
Lösungen - Aufgaben (siehe 8.1.1)
Aufgabe 3: Element entfernen
Aufgabe 4: Element einfügen
M = [\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]'\
]
M = [\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]',\
'[email protected]'\
]
# Element entfernen
def entfernen(L, i):
H = L[0:i] + L[(i+1):len(L)]
return H
# Element einfügen
def einfuegen(L, x, i):
H = L[:i] + [x] + L[i:]
return H
# Test
print M
print entfernen(M, 2)
print M
# Test
print M
print einfuegen(M, '[email protected]', 2)
print M
11
Lösungen - Aufgaben (siehe 8.1.2)
Aufgabe 2/3: Anzahl der Richtigen
# Version 2
tipp = [1, 12, 21, 31, 37, 46]
ziehung = [1, 21, 25, 40, 44, 45]
# Anzahl der Richtigen
richtige = 0
for t in tipp:
for z in ziehung:
if t == z:
richtige = richtige + 1
print richtige
# Version 3
tipp = [ \
True , False, False, False, False, False, False, \
False, False, False, False, True , False, False, \
False, False, False, False, False, False, True , \
False, False, False, False, False, False, False, \
False, False, True , False, False, False, False, \
False, True , False, False, False, False, False, \
False, False, False, True , False, False, False, \
]
ziehung = [ \
True , False, False, False, False, False, False, \
...
False, True , True , False, False, False, False, \
]
# Anzahl der Richtigen
richtige = 0
for i in range(49):
if (tipp[i] == True) and (ziehung[i] == True):
richtige = richtige + 1
print richtige
12
Lösungen - Aufgaben (siehe 8.1.2)
Aufgabe 4/5: Erzeugung der Lottoziehung
# Version 2
from random import *
ziehung = []
for i in range(6):
zahl = randint(1, 49)
ziehung = ziehung + [zahl]
print ziehung
# Version 3
from random import *
ziehung = []
for i in range(49):
ziehung = ziehung + [False]
for i in range(6):
zahl = randint(1, 49)
ziehung[zahl-1] = True
for i in range(49):
if ziehung[i] == True:
print(i+1)
# Version 3
from random import *
ziehung = []
for i in range(49):
ziehung = ziehung + [False]
for i in range(6):
ok = False
while not ok:
zahl = randint(1, 49)
if ziehung[zahl-1] == False:
ok = True
ziehung[zahl-1] = True
for i in range(49):
if ziehung[i] == True:
print(i+1)
13
Lösungen - Aufgaben (siehe 8.1.2)
Aufgabe 6: Wiederholte Lottoziehungen
from random import *
def tipp():
t=[\
True , False, False, False, ...
...
False, False, False, True , ...
]
return t
def ziehung():
z = []
for i in range(49):
z = z + [False]
for i in range(6):
ok = False
while not ok:
zahl = randint(1, 49)
if z[zahl-1] == False:
ok = True
z[zahl-1] = True
return z
def richtige(z, t):
r=0
for i in range(49):
if (t[i] == True) and (z[i] == True):
r=r+1
return r
def simulation(n):
t = tipp()
haeufigkeiten = [0, 0, 0, 0, 0, 0, 0]
i=0
while i < n:
z = ziehung()
r = richtige(z, t)
haeufigkeiten[r] = haeufigkeiten[r] + 1
i=i+1
return haeufigkeiten
def ausgabe(h):
for i in range(7):
print i, " Richtige: ", h[i]
# Test
haeufigkeiten = simulation(10000)
ausgabe(haeufigkeiten)
14
Fachkonzept - Liste
Eine Liste ist eine endliche Folge von Elementen, bei der man neue
Elemente hinzufügen und vorhandene Elemente entfernen kann.
 Zur Darstellung von Listen verwenden wir - wie in Python - eckige
Klammern.
 Alle Elemente einer Liste werden mit Kommata getrennt.
 Eine besondere Liste ist die leere Liste. Sie enthält keine Elemente.
 Die Elemente einer Liste können (in unserer Darstellung hier) von
beliebigem - also auch unterschiedlichem - Typ sein.
 Eine Liste kann selbst wieder Listen als Elemente haben. Listen
können also geschachtelt werden.
['[email protected]', '[email protected]', '[email protected]', ...]
[1, 12, 21, 31, 37, 46]
[]
[1, 21, 25, 40, 44, 45, ("Zusatzzahl", 3), ("Superzahl", 5)]
[[1, 12, 21, 31, 37, 46], [3, 8, 10, 30, 31, 49], [5, 12, 20, 22, 29, 40]]
Brot
Butter
Joghurt
Äpfel
Schokolade
Mehl
Eier
...
15
Fachkonzept - Liste
Element
[10, 15, 21, 33, 37, 40]
0
1
2
3
4
5
Index
 Die Elemente einer Liste sind (in unserer Darstellung hier) alle durchnummeriert. Die
Nummerierung beginnt dabei mit 0. Die Nummer eines Listenelements wird auch Index
genannt.
 Wir gehen (in unserer Darstellung hier) davon aus, dass ein Zugriff auf jedes Listenelement
möglich ist. Wenn L eine Liste bezeichnet, dann beschreibt der Ausdruck L[i] das
Listenelement mit der Nummer i.
>>> L = [10, 15, 21, 33, 37, 40]
>>> L[0]
10
>>> L[1]
lesender Zugriff
15
>>> L = [10, 15, 21, 33, 37, 40]
>>> L
[10, 15, 21, 33, 37, 40]
>>> L[4] = 36
schreibender Zugriff
>>> L
[10, 15, 21, 33, 36, 40]
16
Fachkonzept - Liste
Element
['g', 't', 'e', 'c', 's', 'k', 'p']
0
1
2
3
4
5
6
Index
>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> L[0:2]
['g', 't']
>>> L[2:5]
['e', 'c', 's']
>>> L[1:5]
['t', 'e', 'c', 's']
>>> L[3:3]
[]
Teillisten
 Wenn L eine Liste bezeichnet, dann
beschreibt der Ausdruck L[i:j] die Liste, die
alle Elemente der Ausgangsliste L mit den
Nummern von i bis j-1 enthält. Beachte,
dass diese Teilliste auch leer sein kann.
>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> L[2:]
['e', 'c', 's', 'k', 'p']
>>> L[:2]
['g', 't']
>>> L[:]
['g', 't', 'e', 'c', 's', 'k', 'p']
17
Fachkonzept - Liste
Element
['g', 't', 'e', 'c', 's', 'k', 'p']
0
1
2
3
4
5
6
Index
 Bei der Konkatenation von Listen werden
diese zu einer Gesamtliste verbunden. Wenn
L und M zwei Listen bezeichnen, dann
beschreibt der Ausdruck L+M die Liste, die
zunächst alle Elemente von L und danach
alle Elemente von M enthält.
>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> M = ['a', 'g', 't']
>>> L + M
['g', 't', 'e', 'c', 's', 'k', 'p', 'a', 'g', 't']
>>> L + ['u']
['g', 't', 'e', 'c', 's', 'k', 'p', 'u']
>>> [] + M
['a', 'g', 't']
Konkatenation
 Da Listen dynamisch wachsen oder
schrumpfen können, benötigt man häufig
eine Operation zur Bestimmung der Länge
der Liste. Die Länge einer Liste beschreibt
dabei die Anzahl der Listenelemente. Wenn
L eine Listen bezeichnet, dann beschreibt
der Ausdruck len(L) die Länge der Liste.
>>>
>>>
7
>>>
0
>>>
2
L = ['g', 't', 'e', 'c', 's', 'k', 'p']
len(L)
len([])
len([1, [2, 3]])
Länge
18
Übungen (siehe 8.1.4)
Bearbeite die Aufgaben 1 .. 7.
19
Teil 2
Listen als Objekte
20
Einstieg - merkwürdiges Verhalten
Im folgenden Python-Dialog wird ein Lotto-Tipp kopiert und anschließend etwas abgeändert.
Was fällt auf?
>>> tipp1 = [4, 13, 21, 33, 34, 42]
>>> tipp2 = tipp1
>>> tipp2[1] = 8
>>> tipp2
[4, 8, 21, 33, 34, 42]
>>> tipp1
[4, 8, 21, 33, 34, 42]
>>> tipp1 = [4, 13, 21, 33, 34, 42]
>>> tipp1
[4, 13, 21, 33, 34, 42]
>>> tipp2
[4, 8, 21, 33, 34, 42]
>>> tipp2[0] = 3
>>> tipp2
[3, 8, 21, 33, 34, 42]
>>> tipp1
[4, 13, 21, 33, 34, 42]
21
Verwaltung von Listen mit Variablen
Jedes Datenobjekt hat (in Python) eine Identitätsnummer, einen Typ und einen bestimmten
Wert.
>>> id([4, 13, 21, 33, 34, 42])
12289008
>>> type([4, 13, 21, 33, 34, 42])
<type 'list'>
>>> [4, 13, 21, 33, 34, 42]
[4, 13, 21, 33, 34, 42]
>>> tipp1 = [4, 13, 21, 33, 34, 42]
>>> id(tipp1)
12289008
>>> type(tipp1)
<type 'list'>
>>> tipp1
[4, 13, 21, 33, 34, 42]
Variablen dienen in der Informatik dazu, Datenobjekte zu verwalten. Variablen werden an
Datenobjekte angebunden, um die betreffenden Datenobjekte verwalten zu können.
Eine Variable, die ein Datenobjekt referenziert, ist eine Art Name für das betreffende
Datenobjekt. Mit dem Variablennamen kann man sich die Identitätsnummer, den Typ und den
Wert des referenzierten Datenobjekts verschaffen.
22
Verwaltung von Listen mit Variablen
>>> tipp1 = [4, 13, 21, 33, 34, 42]
>>> tipp2 = tipp1
>>> tipp2[1] = 8
>>> tipp2
[4, 8, 21, 33, 34, 42]
>>> tipp1
[4, 8, 21, 33, 34, 42]
>>> tipp1 = [4, 13, 21, 33, 34, 42]
>>> tipp1
[4, 13, 21, 33, 34, 42]
>>> tipp2
[4, 8, 21, 33, 34, 42]
>>> tipp2[0] = 3
>>> tipp2
[3, 8, 21, 33, 34, 42]
>>> tipp1
[4, 13, 21, 33, 34, 42]
23
Listen als Objekte
Listen sind (in Python) Objekte vom Typ list, die Daten
verwalten und die dem Benutzer Operationen zur
Verarbeitung der Daten zur Verfügung stellen.
>>> L
[3, 7, 5, 4, 2]
>>> L.__len__()
5
>>> L.__getitem__(1)
7
>>> L.__setitem__(1, 8)
>>> L
[3, 8, 5, 4, 2]
>>> L.__delitem__(1)
>>> L
[3, 5, 4, 2]
>>> L.__len__()
4
>>> L = []
>>> L
[]
>>> L.append(3)
>>> L
[3]
>>> L.append(5)
>>> L
[3, 5]
>>> L.insert(1, 7)
>>> L
[3, 7, 5]
>>> L.insert(0, 5)
>>> L
[5, 3, 7, 5]
>>> L.remove(5)
>>> L
[3, 7, 5]
>>> L.extend([4, 2])
>>> L
[3, 7, 5, 4, 2]
24
Listenverarbeitung
L = Listenkonstruktor
>>> L = [1, 2, 3]
>>> L
[1, 2, 3]
>>> id(L)
12283056
>>> L = L + [4]
>>> L
[1, 2, 3, 4]
>>> id(L)
12289008
>>> L = L[1:]
>>> L
[2, 3, 4]
>>> id(L)
12257720
>>> L = [1, 2] + L[1:]
>>> L
[1, 2, 3, 4]
>>> id(L)
Erzeugung neuer Listen
12289008
L.Listenoperation
>>> L = [1, 2, 3]
>>> L
[1, 2, 3]
>>> id(L)
12283536
>>> L[1] = 5
>>> L
[1, 5, 3]
>>> id(L)
12283536
>>> L.remove(5)
>>> L
[1, 3]
>>> id(L)
12283536
>>> L.insert(1, 2)
>>> L
[1, 2, 3]
>>> id(L)
12283536
Veränderung einer
bestehenden Listen
25
Übungen (siehe 8.2.5)
Bearbeiten Sie die Aufgaben des Abschnitts 8.2.5.
26
Teil 3
Datenmodellierung mit Listen
27
Einstieg - Magische Quadrate
Ein magisches Quadrat ist ein Zahlenschema, bei dem alle Zeilen-, Spalten- und
Diagonalsummen gleich sind.
Darstellung mit Listen
>>> q = [[16, 5, 9, 4], [2, 11, 7, 14], [3, 10, 6, 15], [13, 8, 12, 1]]
>>> q[0]
[16, 5, 9, 4]
>>> q[0][0]
16
>>> q[0][1]
5
>>> q[0][0] + q[0][1] + q[0][2] + q[0][3]
34
28
Einstieg - Aufgaben (siehe 8.3.1)
Entwickle eine Funktion zeilensumme(quadrat, i), eine Funktion spaltensumme(quadrat, i)
und zwei Funktionen diagonalsumme_lr(quadrat) und diagonalsumme_rl(quadrat), mit deren
Hilfe man die entsprechenden Summen bei einem gegebenen Zahlenschema berechnen kann.
Entwickle auch eine Funktion, die überprüft, ob ein Zahlenschema ein magisches Quadrat
darstellt.
>>>
>>>
34
>>>
34
>>>
34
>>>
True
q = [[16, 5, 9, 4], [2, 11, 7, 14], [3, 10, 6, 15], [13, 8, 12, 1]]
zeilensumme(q, 0)
spaltensumme(q, 3)
diagonalsumme_lr(q)
magischesQuadrat(q)
29
Lösung - Aufgaben (siehe 8.3.1)
def zeilensumme(q, n):
summe = 0
l = len(quadrat)
i=0
while i < l:
summe = summe + q[n-1][i]
i=i+1
return summe
def diagonalsumme_rl(q):
summe = 0
l = len(quadrat)
i=0
while i < l:
summe = summe + q[i][l-i-1]
i=i+1
return summe
def spaltensumme(q, n):
...
while i < l:
summe = summe + q[i][n-1]
i=i+1
return summe
def magischesQuadrat(q):
magisch = True
s = diagonalsumme_lr(q)
if diagonalsumme_rl(q) != s:
magisch = False
n=0
while n < len(quadrat):
if zeilensumme(q, n+1) != s:
magisch = False
if spaltensumme(q, n+1) != s:
magisch = False
n=n+1
return magisch
def diagonalsumme_lr(q):
...
while i < l:
summe = summe + q[i][i]
i=i+1
return summe
30
Datenstrukturen
Datenstrukturen ermöglichen es, strukturierte Daten als Einheit zu verwalten.
Reihung aus Reihungen
Darstellung mit Listen
# Lottoschein
schein = [[3, 6, 19, 21, 38, 41], [4, 9, 17, 37, 38, 39], [18, 23, 28, 36, 38, 46]]
31
Reihung / Verbund
Bei einer Reihung werden Daten desselben
Typs zu einer Einheit zusammengefasst.
Bei einem Verbund werden Daten zu einer
Einheit zusammengefasst, die von
unterschiedlichem Typ sein können.
Reihung
Verbund
Darstellung als Liste
# Reihung
[10, 15, 21, 33, 37, 40]
Darstellung als Liste
# Verbund
["Albert", "Einstein", 1879, 1955]
Darstellung als Tupel
# Verbund
("Albert", "Einstein", 1879, 1955)
32
Schachtelung von Reihung u. Verbund
Reihungen und Verbunde können beliebig ineinander geschachtelt werden.
Zeichenkette
Reihung
Zeichenkette
Verbund von Zahlen
Verbund von Zahlen
Verbund
Darstellung mit Listen
# Schachtelung von Reihung und Verbund
[["Albert", "Einstein", [14, 3, 1879], [18, 5, 1955]], ...]
33
Mehrdimensionale Reihung
Mehrdimensionale Reihungen sind Reihungen von Reihungen ....
Reihung
Reihung
Darstellung mit Listen
# zweidimensionale Reihung
[[16, 5, 9, 4], [2, 11, 7, 14], [3, 10, 6, 15], [13, 8, 12, 1]]
Dynamische Datenstrukturen
34
Dynamische Datenstrukturen sind Datenstrukturen, die sich dynamisch verändern können.
# Liste
["Anna", "Peter", "Tim", "Greta", "Katrin"]
Liste
Baum
Graph
# Baum
["Andreas", \
["Peter", \
[Matthias], \
[Katharina]], \
["Christiane", \
["Winfried"], \
["Ursula"]]]
# Graph
[\
["TR", ["KO", "KL"]], \
["KO", ["TR", "MZ", "KL"]], \
["MZ", ["KO", "KL"]], \
["KL", ["TR", "KO", "MZ"]] \
]
Darstellung mit Listen
35
Übungen (siehe 8.3.3)
Bearbeiten Sie Aufgabe 3 (Simulation eines Tischtennisspiels) oder Aufgabe 4 (Irrlauf in
Mannheim).
36
Teil 4
Stapel
37
Einstieg - Rechenterme
(92 - 79) * 27
Rechenterm
Auswertung eines
Rechenterms
38
Einstieg - Aufgaben (siehe 8.4.1)
Aufgabe 1: Darstellung von Rechentermen mit Listen
(92 - 79) * 27
[27, 79, 92, "-", "*"]
Aufgabe 2: Algorithmus zur Auswertung von Rechentermen
39
Stapel
Ein Stapel ist eine Datenstruktur, die als Behälter für Datenobjekte dient und nach dem LIFOPrinzip (last in, first out) arbeitet.
Stapeloperationen:
 top(): liefert das oberste Datenobjekt (sofern der Stapel nicht leer ist)
 push(e): legt das übergebene Datenobjekt oben auf den Stapel
 pop(): entfernt das oberste Stapelobjekt (sofern der Stapel nicht leer ist)
40
Implementierung als Klasse
class Stapel(object):
def __init__(self):
self.liste = []
def isEmpty(self):
if self.liste == []:
return True
else:
return False
def push(self, element):
self.liste = [element] + self.liste
def pop(self):
if not self.isEmpty():
self.liste = self.liste[1:]
def top(self):
if self.isEmpty():
return None
else:
return self.liste[0]
def size(self):
return len(self.liste)
def getStapel(self):
return self.liste
def setStapel(self, liste):
self.liste = liste
>>> s = Stapel()
>>> s.push(6)
>>> s.getStapel()
[6]
>>> s.push(3)
>>> s.getStapel()
[3, 6]
>>> s.top()
3
>>> s.pop()
>>> s.getStapel()
[6]
41
Übungen (siehe 8.4.3/8.4.4)
8.4.3: Aufgabe 1:
Testen Sie die Stapeloperationen.
>>> t = Stapel()
>>> t.setStapel([27, 79, 92, "-", "*"])
>>> s = Stapel()
>>> print t.getStapel()
[27, 79, 92, '-', '*']
>>> print s.getStapel()
[]
>>> e = t.top()
>>> s.push(e)
>>> t.pop()
>>> print t.getStapel()
[79, 92, '-', '*']
>>> print s.getStapel()
[27]
...
8.4.4: Aufgabe 1:
Die in den Abbildungen gezeigten
Operationen sollen mit Hilfe von zwei
Stapel-Objekten durchgespielt werden.
42
Übungen (siehe 8.4.3/8.4.4)
8.4.4: Aufgabe 2: Ergänzen Sie die
Implementierung, so dass der folgende
Python-Dialog möglich wird. Testen Sie die
Funktion auswerten auch mit anderen Termen.
def auswerten(term):
t = Stapel()
t.setStapel(term)
s = Stapel()
while t.size() > 0:
print "T:", t.getStapel()
print "S:", s.getStapel()
print
e = t.top()
t.pop()
if type(e) == int:
s.push(e)
else:
...
print "T:", t.getStapel()
print "S:", s.getStapel()
print
return s.top()
>>> auswerten([27, 79, 92, "-", "*"])
T: [27, 79, 92, '-', '*']
S: []
T: [79, 92, '-', '*']
S: [27]
T: [92, '-', '*']
S: [79, 27]
T: ['-', '*']
S: [92, 79, 27]
T: [13, '*']
S: [27]
T: ['*']
S: [13, 27]
T: [351]
S: []
...
43
Lösungen (siehe 8.4.3/8.4.4)
8.4.4: Aufgabe 1:
>>> t = Stapel()
>>> t.setStapel([27, 79, 92, "-", "*"])
>>> s = Stapel()
>>> print t.getStapel()
[27, 79, 92, '-', '*']
>>> print s.getStapel()
[]
>>> e = t.top()
>>> print e
27
>>> t.pop()
>>> s.push(e)
>>> print t.getStapel()
[79, 92, '-', '*']
>>> print s.getStapel()
[27]
...
...
>>> e = t.top()
>>> print e
>>> m = s.top()
>>> s.pop()
>>> n = s.top()
>>> s.pop()
>>> t.push(m-n)
>>> print t.getStapel()
[13, '-', '*']
>>> print s.getStapel()
[27]
>>>
...
Lösungen (siehe 8.4.3/8.4.4)
44
def auswerten(term):
t = Stapel()
t.setStapel(term)
s = Stapel()
while t.size() > 0:
print "T:", t.getStapel()
print "S:", s.getStapel()
print
e = t.top()
t.pop()
if type(e) == int:
s.push(e)
else:
...
print "T:", t.getStapel()
print "S:", s.getStapel()
print
return s.top()
m = s.top()
s.pop()
n = s.top()
s.pop()
op = e
if op == "+":
t.push(m+n)
elif op == "-":
t.push(m-n)
elif op == "*":
t.push(m*n)
elif op == "/":
t.push(m/n)
45
Teil 5
Schlangen
46
Einstieg - Warteschlange
Beim Drucken von Aufträgen kann es vorkommen, dass neue Druckaufträge den Drucker
erreichen, bevor der aktuelle Druckauftrag abgearbeitet ist. Drucker sehen für diesen Fall
einen Puffer vor, in dem die neuen Druckaufträge zwischengespeichert werden.
>>> simuliereDrucken()
S: ['Eine']
S: ['Eine', 'Warteschlange']
S: ['Eine', 'Warteschlange', 'bildet']
S: ['Eine', 'Warteschlange', 'bildet', 'sich,']
Eine
S: ['Warteschlange', 'bildet', 'sich,', 'wenn']
S: ['Warteschlange', 'bildet', 'sich,', 'wenn', 'mehr']
Warteschlange
S: ['bildet', 'sich,', 'wenn', 'mehr', 'Anforderungen']
bildet
sich,
wenn
S: ['mehr', 'Anforderungen', 'pro']
S: ['mehr', 'Anforderungen', 'pro', 'Zeiteinheit']
...
Simulation einer
Druckerwarteschlange
47
Schlange
Eine Schlange ist eine Datenstruktur, die als Behälter für Datenobjekte dient und nach dem
FIFO-Prinzip (first in, first out) arbeitet.
Schlangenoperationen:
 erstes(): liefert das erste Schlangenelement (sofern die Schlange nicht leer ist)
 mitLetztem(e): fügt das übergebene Schlangenelement hinten in die Schlange ein
 ohneErstes(): entfernt das erste Schlangenelement (sofern die Schlange nicht leer ist)
48
Implementierung als Klasse
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
>>> s = Schlange()
>>> s.getSchlange()
[]
>>> s.mitLetztem(4)
>>> s. mitLetztem(7)
>>> s.getSchlange()
[4, 7]
>>> s.erstes()
4
>>> s.ohneErstes()
>>> s.getSchlange()
[7]
49
Übungen (siehe 8.5.3/8.5.4)
8.5.3: Aufgabe 1:
Testen Sie die Schlangenoperationen.
50
Übungen (siehe 8.5.3/8.5.4)
>>> simuliereDrucken()
S: ['Eine']
S: ['Eine', 'Warteschlange']
S: ['Eine', 'Warteschlange', 'bildet']
S: ['Eine', 'Warteschlange', 'bildet', 'sich,']
Eine
S: ['Warteschlange', 'bildet', 'sich,', 'wenn']
S: ['Warteschlange', 'bildet', 'sich,', 'wenn', 'mehr']
Warteschlange
S: ['bildet', 'sich,', 'wenn', 'mehr', 'Anforderungen']
bildet
sich,
wenn
S: ['mehr', 'Anforderungen', 'pro']
S: ['mehr', 'Anforderungen', 'pro', 'Zeiteinheit']
S: ['mehr', 'Anforderungen', 'pro', 'Zeiteinheit', 'an']
mehr
S: ['Anforderungen', 'pro', 'Zeiteinheit', 'an', 'ein']
S: ['Anforderungen', 'pro', 'Zeiteinheit', 'an', 'ein', 'System']
Anforderungen
S: ['pro', 'Zeiteinheit', 'an', 'ein', 'System', 'gerichtet']
pro
Zeiteinheit
an
ein
System
gerichtet
S: ['werden,']
S: ['werden,', 'als']
S: ['werden,', 'als', 'dieses']
...
8.5.4: Aufgabe 1:
Ziel ist es, eine Druckerwarteschlange zu
simulieren. Dabei sollen Python-Protokolle
der folgenden Art entstehen.
...
...
werden,
als
dieses
S: ['in']
in
S: ['der']
der
S: ['selben']
S: ['selben', 'Zeit']
selben
Zeit
S: ['verarbeiten']
verarbeiten
S: ['kann.']
kann.
51
Übungen (siehe 8.5.3/8.5.4)
# -*- coding: iso-8859-1 -*from schlange import *
from random import *
def simuliereDrucken():
f = file("warteschlange.txt", 'r')
text = f.read()
liste = text.split()
s = Schlange()
i=0
while (len(liste) > 0) or not s.istLeer():
z = randint(0, 1)
if z == 0:
# Auftrag drucken
else:
# Auftrag erteilen
8.5.4: Aufgabe 1:
...
Analysiere zunächst den Quelltext und kläre
folgende Fragen:
* Woher stammen die als Druckaufträge
dienenden Zeichenketten?
* Welche Rolle spielt der Zufallsgenerator bei
der Simulation?
Vervollständige den Quelltext und teste das
Simulationsprogramm.
52
Lösungen (siehe 8.4.3/8.4.4)
8.5.4: Aufgabe 1:
# -*- coding: iso-8859-1 -*from schlange import *
from random import *
def simuliereDrucken():
f = file("warteschlange.txt", 'r')
text = f.read()
liste = text.split()
s = Schlange()
i=0
while (len(liste) > 0) or not s.istLeer():
z = randint(0, 1)
...
...
if z == 0:
# Drucken
if not s.istLeer():
auftrag = s.erstes()
s.ohneErstes()
print auftrag
else:
# Auftrag
if len(liste) > 0:
auftrag = liste[0]
liste = liste[1:]
s.mitLetztem(auftrag)
print "S:", s.getSchlange()
53
Teil 6
Miniprojekt: Monoalphabetische
Chiffriersysteme
54
Einstieg - Caesar-Verschlüsselung
PYLZFOWBNQCYBUVNCBLGYC
HYAYBYCGMWBLCZNYHNTCZY
LN
VDOYH
FDHVDU
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
D E F G H I J K L M N O P Q R S T U V W X Y Z A B C
Quelltext:
SALVECAESAR
Schlüssel: D
Geheimtext:
VDOYHFDHVDU
55
Fachkonzept - Chiffriersystem
Ein Chiffriersystem dient dazu, Klartexte in Geheimtexte und umgekehrt Geheimtexte in
Klartexte zu transformieren. Zum Ver- und Entschlüsseln (man sagt auch Codieren und
Decodieren) wird in der Regel jeweils ein Schlüssel benötigt.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
D E F G H I J K L M N O P Q R S T U V W X Y Z A B C
Verschiebe-Chiffriersystem
56
Fachkonzept - Chiffriersystem
Ein monoalphabetisches Chiffriersystem ist ein Chiffriersystem, bei dem jedem Buchstaben des
Alphabets ein anderer Buchstabe des Alphabets fest zugeordnet wird.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
G O Z L N C R E W K A X B J F Q Y I S M V D U P H T
monoalphabetisches Chiffriersystem
57
Exkurs - Python-Implementierung
# -*- coding: iso-8859-1 -*def buchstabeCodieren(c, v):
m = ord(c)
n=m+v
if n > 90:
n = n - 26
d = chr(n)
return d
def buchstabeDecodieren(c, v):
m = ord(c)
n=m-v
if n < 65:
n = n + 26
d = chr(n)
return d
def textDecodieren(text, v):
klartext = ''
for c in text:
klartext = klartext + buchstabeDecodieren(c, v)
return klartext
def textLaden(dateiname):
f = file(dateiname, 'r')
text = f.read()
return text
def textVorbereiten(text):
grossText = text.upper()
bereinigterText = ''
for c in grossText:
if (ord(c) >= 65) and (ord(c) <= 90):
bereinigterText = bereinigterText + c
return bereinigterText
def textCodieren(text, v):
geheimtext = ''
for c in text:
geheimtext = geheimtext + buchstabeCodieren(c, v)
return geheimtext
58
Projekt - Auftrag
Entwickeln Sie ein Programm, mit dem man ein beliebiges monoalphabetisches Chiffriersystem
betreiben kann. Mit diesem Programm soll man beliebige Texte mit einer beliebigen festen
Zuordnungstabelle verschlüsseln und auch wieder entschlüsseln können.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
G O Z L N C R E W K A X B J F Q Y I S M V D U P H T
Zusätzlich soll es das System ermöglichen, die Häufigkeiten von Buchstaben in Texten zu
ermitteln, so dass man das System auch nutzen kann, um eine unbekannte Zuordnungstabelle
zu rekonstruieren.
Projekt - Modellierung
59
Zunächst ist zu klären, wie eine Zuordnungstabelle und eine Häufigkeitstabelle mit
Datenstrukturen beschrieben werden soll.
Zuordnungstabelle
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
G O Z L N C R E W K A X B J F Q Y I S M V D U P H T
['G', 'O', 'Z', 'L', 'N', 'C', 'R', 'E', 'W', ..., 'T']
0
1
2
3
4
5
6
7
8
...
25
A
B
C
D
E
F
G
H
I
...
Z
Häufigkeitstabelle
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
3 1 0 1 9 1 2 3 1 0 1 2 3 6 1 0 0 4 5 5 1 0 0 0 0 0
[ 3,
0
A
3,
1
B
1,
2
C
0,
3
D
1,
4
E
9,
5
F
1,
6
G
2,
7
H
3,
8
I
...,
...
...
0]
25
Z
60
Projekt - Modellierung
Zusätzlich muss geklärt werden, welche Operationen mit Hilfe von Funktionen implementiert
werden sollen.
def zeichenCodieren(c, Z):
...
return ...
def zeichenDecodieren(c, Z):
...
return ...
def textCodieren(text, Z):
...
return ...
def textDecodieren(text, Z):
...
return ...
def textAnalysieren(text):
...
return ...
Für weitere Informationen siehe 8.6.5.
61
Projekt - Implementierung
Im vorangegangenen Abschnitt sind eine Reihe von Funktionen / Prozeduren modelliert
worden. Diese müssen jetzt alle implementiert werden. Natürlich könnte jetzt jeder für sich die
Sache anpacken.
Bei größeren Software-Entwicklungsprojekten teilt man sich in solch einer Situation die Arbeit
auf. Das spart dann viel Zeit - sofern alle gute Arbeit leisten.
Probieren Sie das auch mal hier aus. Jeder ist für eine Teilaufgabe zuständig und
verantwortlich. Wenn alle Funktionen / Prozeduren fertig sind, dann kann das Gesamtsystem
aus den Teilen zusammengebaut werden.
62
Projekt - Testen
Mit dem entwickelten (De-) Chiffriersystem soll der folgende Geheimtext decodiert werden.
Tipp: bello.
OFVTOFRRLSVLAXLVIKSLXSLRSOSXSLRXSLVSVIFJDV
QSUDZVSVILSQSROSKISVFVISKSVILSFWBLXFVSKBVI
ISVIKLXXSVILSILSLVLZKSKSLOSVSVAEKFYZSCSRXS
VLVBVASKSKOFRRLSKOSVFVVXUSKISVALSFRRSBVXSK
AYZSLISVALYZBVXSKSLVFVISKLVAEKFYZSOSUDZVZS
LXSVBVIOSASXTSVILSOFRRLSKXKSVVXJDVISVFWBLX
FVSKVISKGRBAAOFKDVVSJDVISVQSROSKVILSMFKVSB
VIILSASLVSILSXFEGSKAXSVFRRILSASKALVIILSQSR
OSKBVITUFKISAUSOSVUSLRALSJDVISKCBRXBKBVIRS
QSVAUSLASISKKDSMLAYZSVEKDJLVTFMUSLXSAXSVSV
XGSKVXALVIASZKASRXSVCFBGRSBXSTBILSASVCDMMS
VBVIIFAUFATBKJSKUSLYZRLYZBVOISKOSMBSXSKGBS
ZKXSLVGBSZKSVBVIUSLRALSISVOSKMFVSVILSNSVAS
LXAISAKZSLVSARSQSVBVIMLXISVSVALSAXFSVILOCK
LSOGBSZKSVASZKVFZSALVIFBAILSASMOKBVIBSQSKX
KSGGSVFBYZILSZSRJSXLSKILSBSQKLOSVOFRRLSKFV
XFEGSKCSLXUSLRALSALYZLVGFAXXFSORLYZSVOSGSY
ZXSVMLXISVOSKMFVSVMSAASVUDQSLALSILSASSVXUS
ISKJDVLZKSMOSQLSXGSKVZFRXSVDISKASRQAXLVISK
SVOSQLSXCFSMEGSVSLVXSLRIFJDVISVULSOSAFOXIL
SOFRRLSKQSUDZVSVGLVISXASLVSVBKAEKBVOFVISKK
ZDVSULKIQSOKSVTXJDVISKOFKDVVSISMDTSFVBVIIS
MOSQLSXISKQSROSKSKAXKSYCXALYZJDVISVASWBFVS
...
...
KVBVIZSRJSXLSKVZLVQLATBMKZSLVBVITSLOXVFYZV
DKISVIFAOSQLSXISKQSROSKQSOLVVXFVISVFSBAASK
AXSVOKSVTSVOFRRLSVASKAXKSYCXALYZQLAFVISVBV
XSKSVXSLRISAKZSLVABVIRLSOXVFYZVDKIDAXSVFWB
LXFVLSVSKAXKSYCXALYZJDVISMGRBAAOFKDVVSQLAF
VILSEHKSVFSSVBVITBISMNSVLOSVXSLRISADTSFVAI
SKQLAAEFVLSVKSLYZXSARLSOXLVKLYZXBVOVDKIUSA
XSV
63
Projekt - Erweiterungen
Die Zuordnungstabelle soll mit Hilfe eines Schlüsselwortes erzeugt werden.
Schlüsselwort: INITIALISIERUNGVONVARIABLEN
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
I N T A L S E R U G V O B C D F H J K M P Q W X Y Z