Datenverwaltung mit Datenstrukturen

Klaus Becker

2012

2

Datenverwaltung mit Datenstrukturen

131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

3 Teil 1

Fallstudie - Lottosimulation

4 Lottosimulation

Wie wahrscheinlich ist es, dass man beim Lottospielen gewinnt? Diese Frage soll hier mit einem Simulationsprogramm beantwortet werden. Bei der Programmentwicklung werden wir uns mit der Verwaltung vieler Daten beschäftigen.

5 Datenverwaltung mit Listen

Die Zahlen einer Lotto-Ziehung (ohne Zusatzzahl) sollen mit Hilfe von Python verwaltet werden. Im Folgenden findest du zwei Vorschläge, wie man das machen könnte. # Datenverwaltungzahl1 = 25zahl2 = 40zahl3 = 44zahl4 = 1zahl5 = 45zahl6 = 21# Ausgabeprint(zahl1)print(zahl2)print(zahl3)print(zahl4)print(zahl5)print(zahl6)

# Datenverwaltungziehung = [25, 40, 44, 1, 45, 21]# Ausgabei = 0while i < len(ziehung): print(ziehung[i]) i = i+1

Verwendung vieler Variablen

Verwendung einer Variablen sowie einer Liste als "Datencontainer"

Aufgaben:(a) Welchen Vorteil hat es, wenn man eine Liste als eine Art "Datencontainer" benutzt? (b) Wie bildet man in Python eine Liste? Wie greift man auf einzelne Listenelemente zu? Wie sind diese durchnummeriert?

6 Datenverwaltung mit Listen

Aufgabe:Ein Tipp soll verwaltet werden. Zwei Möglichkeiten stehen zur Auswahl. Entscheide dich für eine Version und ergänze die fehlenden Teile.

# Datenverwaltungtipp = [ 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, ]# Ausgabe...

# Datenverwaltungfeld1 = Truefeld2 = False...# Ausgabeprint(feld1)print(feld2)...

7 Eine Liste durchlaufen

# Initialisierungziehung = [25, 40, 44, 1, 45, 21]# Verarbeitung und Ausgabei = 0while i < len(ziehung): print(ziehung[i]) i = i+1

Aufgabe: Ergänze das Programm so, dass man folgende Ausgabe erhält:

Die Zahlen einer Lotto-Ziehung (ohne Zusatz-zahl) werden mit einer Liste verwaltet. Die Listenelemente sind dabei - beginnend mit 0 - mit einem Index durchnummeriert. Liste über den Index durchlaufen

>>> Kugel 1 : 25Kugel 2 : 40Kugel 3 : 44Kugel 4 : 1Kugel 5 : 45Kugel 6 : 21

# Initialisierungziehung = [25, 40, 44, 1, 45, 21]# Verarbeitung und Ausgabefor i in range(len(ziehung)): print(i) print(ziehung[i])

Aufgabe:Teste auch das oben gezeigte Programm. Was leistet der range-Operator? >>> list(range(6))[0, 1, 2, 3, 4, 5]>>> list(range(3, 7))[3, 4, 5, 6]>>> list(range(2, 12, 3))[2, 5, 8, 11]

8 Eine Liste durchlaufen

Aufgabe:Teste auch dieses Programm. Was leistet es?

# Initialisierungziehung = [25, 40, 44, 1, 45, 21]# Verarbeitung und Ausgabefor z in ziehung: print(z)

Die Zahlen einer Lotto-Ziehung (ohne Zusatz-zahl) werden mit einer Liste verwaltet. Die Listenelemente sind dabei - beginnend mit 0 - mit einem Index durchnummeriert.

Liste über die Elemente durchlaufen

9 Anzahl der Richtigen

# Initialisierungziehung = [25, 40, 44, 1, 45, 21]tipp = [1, 12, 21, 31, 37, 46]# Verarbeitungrichtige = 0i = 0while i < len(ziehung): j = 0 while j < len(tipp): print('vergleiche: ', ziehung[i], tipp[j]) # ... j = j+1 i = i+1# Ausgabeprint(richtige)

# Initialisierungziehung = [25, 40, 44, 1, 45, 21]tipp = [1, 12, 21, 31, 37, 46]# Verarbeitungrichtige = 0for z in ziehung: for t in tipp: print('vergleiche: ', z, t) # ...# Ausgabeprint(richtige)

Ziel ist, es, die Anzahl der richtig getippten Zahlen mit einem Programm zu ermitteln.

Aufgabe:Die folgenden Programm liefert ein Gerüst, mit dem man jede Zahl der Liste ziehung mit jeder Zahl der Liste tipp vergleichen kann.

Teste erst einmal, was die Programme schon leisten. Ergänze die noch fehlenden Teile.

10 Anzahl der Richtigen

# Initialisierungziehung = [ True , False, False, False, False, False, False, False, False, False, False, False, False, False, ... ]tipp = [ True , False, False, False, False, False, False, False, False, False, False, True , False, False, ... ]# Verarbeitungrichtige = 0# ...# Ausgabeprint(richtige)

Aufgabe:

Die Lotto- und Tippzahlen sollen hier ebenfalls mit Listen verwaltet werden, aber auf eine etwas andere Weise. Ergänze das Programm so, dass man die Anzahl der Richtigen erhält.

11 Ziehung automatisiert erzeugen

Beim Lotto werden die 6 Kugeln mit Zahlen aus dem Bereich 1..49 der Reihe nach mit einem Zufallsgerät ermittelt. Ziel ist es, diesen Ziehungsvorgang zu simulieren und die gezogenen Zahlen schrittweise in eine Liste aufzunehmen

12 Elemente hinzufügen

>>> liste = []>>> liste[]>>> liste = liste + [12]>>> tipp[12]>>> liste = liste + [15]>>> liste[12, 15]>>> liste = [7] + liste>>> liste...>>> liste = liste + [42, 47]>>> liste...>>> liste = [3] + liste>>> liste...

Der folgende Python-Dialog zeigt, wie man eine Liste zur Verwaltung der Zahlen eines Tipps schrittweise aufbauen kann.

Listen aneinanderhängen

Aufgabe:Analysiere den gezeigten Python-Dialog. Stelle Vermutungen auf, was an Stelle der drei Punkte ... steht. Überprüfe deine Vermutung.

13 Ziehung automatisiert erzeugen

from random import *# Verarbeitungziehung = []for i in range(6): zahl = randint(1, 49) ziehung = ziehung + [zahl]# Ausgabeprint(ziehung)

Ziel ist es, eine Ziehung der Lottozahlen mit Hilfe des Zufallsgenerators von Python zu simulieren. Hier ein erster Vorschlag:

Aufgabe:

(a) Analysiere das Programm und erkläre die einzelnen Anweisungen.

(b) Teste das Programm mehrfach. Welche Schwierigkeit tritt hier auf.

(c) Kannst du die Schwierigkeit beheben?

14 Ziehung automatisiert erzeugen

from random import *# Verarbeitungziehung = []for i in range(49): ziehung = ziehung + [False]for i in range(6): zahl = randint(1, 49) ziehung[zahl-1] = True# Ausgabefor i in range(49): if ziehung[i] == True: print(i+1)

Ziel ist es, eine Ziehung der Lottozahlen mit Hilfe des Zufallsgenerators von Python zu simulieren. Hier ein weiterer Vorschlag:

Aufgabe:

(a) Teste das folgende Programm. Erkläre, wie hier die Liste zur Verwaltung der Wahrheitswerte aufgebaut wird.

(b) Auch hier ist noch etwas nicht in Ordnung. Kannst du die Schwierigkeit durch Ergänzungen im Programm beheben?

15 Gewinnchancen beim Lotto

Die Gewinnchancen beim Lottospiel kann man näherungsweise ermitteln, indem man sehr oft einen (evtl. festen) Tipp vorgibt und eine Lotto-Ziehung durchführt. Man muss dann nur mitzählen, wie oft man 0, 1, ..., 6 Richtige hatte.

Tipp Ziehung Richtige---------------------------------------------------------------------------[ 1, 12, 21, 31, 37, 46] [25, 40, 44, 1, 45, 21] [0, 0, 1, 0, 0, 0, 0][ 1, 12, 21, 31, 37, 46] [11, 15, 3, 20, 40, 30] [1, 0, 1, 0, 0, 0, 0][ 1, 12, 21, 31, 37, 46] [ 6, 49, 32, 18, 19, 24] [2, 0, 1, 0, 0, 0, 0]...

Aufgaben:

(a) Entwickle ein Programm zur Ermittlung der Gewinnchancen beim Lotto. Mit dem Programm soll es z.B. möglich sein zu ermitteln, wie oft man 0, 1, 2, ..., 6 Richtige erhält, wenn man 10000 mal Lotto spielt. Strukturiere das Programm mit Hilfe von Funktionen.

(b) Wie lange dauert es im wirklichen Leben, bis 10000 Ziehungen durchgeführt wurden, wenn man von einer Ziehung am Mittwoch und einer am Samstag ausgeht und wenn man einen Tipp pro Spiel abgibt? Beurteile mit den Ergebnissen die Gewinnaussichten beim Lottospiel.

16 Gewinnchancen beim Lotto

Wenn man ein Programm zur wiederholten Simulation entwickeln möchte, dann sollte man Funktionen zur Durchführung von Teilaufgaben nutzen. Hier ein Vorschlag zur Modellierung von Funktionen.

17 Gewinnchancen beim Lotto

Aufgabe:Implementiere die vorgeschlagenen Funktionen. Benutze dabei die bereits entwickelten Listenverarbeitungsprogramme.

def neueZiehung(): 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 return ziehung

mögliche Implementierung

18 Gewinnchancen beim Lotto

Aufgabe:Implementiere die vorgeschlagenen Funktionen. Benutze die bereits implementierten Funktionen.

19 Teil 2

Fallstudie - Newsletter

20 Newsletter

Newsletter werden benutzt, um allen Mitgliedern einer Gruppe Informationen per E-Mail zukommen zu lassen. So könnte z.B. das inf-schule-Team allen Interessierten eine E-Mail schicken, wenn es Neuerungen in den Materialien gibt.

>>> From: inf-schule@gmx.deTo: alex2101@web.deSubject: Neuerungen

Hallo!...

21 Newsletter automatisiert senden

Solche elektronischen Rundschreiben kann man automatisiert verfassen und versenden. Das folgende Python-Programm zeigt, wie das (im Prinzip) geht.

# Mail erstellenmail_from = 'inf-schule@gmx.de'mail_to = 'alex2101@web.de'mail_subject = 'Neuerungen'mail_header = 'From: ' + mail_from + '\n' + 'To: ' + mail_to + '\n' + 'Subject: ' + mail_subject + '\n'mail_text = 'Hallo!\n ...'mail_body = '\n' + mail_text + '\n\n'mail = mail_header + mail_bodyprint(mail)# Mail versendenimport smtplibbenutzer = 'inf-schule@gmx.de'passwort = '...' # wird nicht verratenempfaenger = 'alex2101@web.de'mailserver = 'smtp.gmx.de'smtp = smtplib.SMTP(mailserver)smtp.login(benutzer, passwort)smtp.sendmail(benutzer, empfaenger, mail)smtp.quit()

22 Datenverwaltung mit einer Liste

Interessant wird das Programm, wenn man das elektronische Rundschreiben an mehrere Empfänger verschicken kann.

# Mail erstellenmail_from = 'inf-schule@gmx.de'mail_to = 'alex2101@web.de'mail_subject = 'Neuerungen'mail_header = 'From: ' + mail_from + '\n' + 'To: ' + mail_to + '\n' + 'Subject: ' + mail_subject + '\n'mail_text = 'Hallo!\n ...'mail_body = '\n' + mail_text + '\n\n'mail = mail_header + mail_bodyprint(mail)# Mail versendenimport smtplibbenutzer = 'inf-schule@gmx.de'passwort = '...' # wird nicht verratenempfaenger = 'alex2101@web.de'mailserver = 'smtp.gmx.de'smtp = smtplib.SMTP(mailserver)smtp.login(benutzer, passwort)smtp.sendmail(benutzer, empfaenger, mail)smtp.quit()

# DatenverwaltunglisteAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]# Datenverarbeitungfor adresse in listeAdressen: # verarbeite adresse

23 Eine Liste dynamisch verändern

Im Newsletter-Programm des MSS-Leiters werden die E-Mail-Adressen sämtlicher Schülerinnen und Schüler der 11. Jahrgangsstufe mit einer Liste verwaltet. Beachte, dass die Liste mehr als 100 Elemente haben kann.

Während der ersten Wochen des Schuljahres gibt es ständig Änderungswünsche:

'amueller@gmx.de'

'carla2@hotmail.org'

'herbert.fluhr@web.de'

'petra@dahm.de'

'ewen@t-online.de'

't_schmidt@web.de'

'nicole.weber@gmx.de'

...

'lars-schneider@gmx.de'

Durch Schulwechsel, Umzug, freiwilliges Wiederholen etc. werden 7 Schülerinnen und Schüler neu in die 11. Jahrgangsstufe aufgenommen. Ihre E-Mail-Adressen müssen in die Liste integriert werden.

Herbert Fluhr hat sich doch für eine Ausbildung als Bankkaufmann entschieden und die Schule verlassen. Seine E-Mail-Adresse muss gelöscht werden.

Carla hat sich mal wieder eine neue E-Mail-Adresse zugelegt. Ihre alte Adresse muss durch die neue ersetzt werden.

Um den MSS-Leiter zu entlasten, sollen im Folgenden Programmeinheiten entwickelt werden, mit denen eine dynamische Veränderung einer bestehenden Liste leicht möglich ist.

'carla_meier@online.de'

24 Zugriff auf Listenelemente

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> listeAdressen[0]'amueller@gmx.de'>>> listeAdressen[1]'carla2@hotmail.org'>>> listeAdressen[6]'nicole.weber@gmx.de'>>> listeAdressen[7]Traceback (most recent call last): ... listeAdressen[7]IndexError: list index out of range

lesender Zugriff

25 Zugriff auf Listenelemente

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> listeAdressen[1] = 'carla_meier@online.de'>>> listeAdressen['amueller@gmx.de', 'carla_meier@online.de', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']...

schreibender Zugriff

26 Zugriff auf Teillisten

>>> liste = ['G', 'i', 'r', 'a', 'f', 'f', 'e']>>> liste[0:2]['G', 'i']>>> liste[2:5]['r', 'a', 'f']>>> liste[1:6]['i', 'r', 'a', 'f', 'f']>>> liste[3:3][]

>>> liste = ['G', 'i', 'r', 'a', 'f', 'f', 'e']>>> liste[3:] # von Nummer 3 bis zum Ende der Nummerierung['a', 'f', 'f', 'e']>>> liste[:3] # von Nummer 0 bis zur Nummer 2 (= 3-1)['G', 'i', 'r']>>> liste[:] # von Nummer 0 bis zum Ende der Nummerierung['G', 'i', 'r', 'a', 'f', 'f', 'e']

Ein Zugriff auf eine Teilliste ist möglich: Wenn liste eine Liste bezeichnet, dann beschreibt der Ausdruck liste[i:j] die Liste, die alle Elemente der Ausgangsliste liste mit den Nummern von i bis j-1 enthält. Beachte, dass diese Teilliste auch leer sein kann.

Zugriff auf eine Teilliste

27 Zugriff auf Teillisten

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]

Aufgabe: Stelle zunächst Vermutungen auf, was an Stelle der drei Punkte steht. Überprüfe deine Vermutungen, indem du den Python-Dialog selbst ausführst.

>>> listeAdressen[0:2]...>>> listeAdressen[2:5]...>>> listeAdressen[1:4]...>>> listeAdressen[3:3]...>>> listeAdressen[3:9]...>>> listeAdressen[0:len(listeAdressen)]...>>> listeAdressen[2:]...>>> listeAdressen[:2]...>>> listeAdressen[:]...

28 Listen zusammenfügen

>>> liste1 = ['T', 'e', 'r', 'm']>>> liste2 = ['i', 'n']>>> liste1 + liste2['T', 'e', 'r', 'm', 'i', 'n']

Bei der Konkatenation von Listen werden diese zu einer Gesamtliste verbunden. Wenn liste1 und liste2 zwei Listen bezeichnen, dann beschreibt der Ausdruck liste1+liste2 die Liste, die zunächst alle Elemente von L und danach alle Elemente von M enthält.

29 Listen zusammenfügen

>>> liste = []>>> liste[]>>> liste = liste + ['n']>>> liste...>>> liste = liste + ['t']>>> liste...>>> liste = ['o'] + liste>>> liste...>>> liste = liste + ['a', 'g']>>> liste...>>> liste = ['M'] + liste>>> liste...

>>> a = [1]>>> b = [2]>>> c = [3]>>> a = a+b>>> b = a+c>>> c = c+b>>> a...>>> b...>>> c...

Aufgabe: Stelle zunächst Vermutungen auf, was an Stelle der drei Punkte steht. Überprüfe deine Vermutungen, indem du den Python-Dialog selbst ausführst.

30 Listenelemente einfügen

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]>>> listeAdressen + ['lars-schneider@gmx.de']['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de', 'lars-schneider@gmx.de']>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> listeAdressen = listeAdressen + ['lars-schneider@gmx.de']>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de', 'lars-schneider@gmx.de']

Das Einfügen von Listenelementen am Anfang und Ende einer Liste ist einfach.

erzeugt eine neue Liste

verändert die Liste

31 Listenelemente einfügen

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]>>> listeAdressen[0:2] + ['lars-schneider@gmx.de'] + listeAdressen[2:7]['amueller@gmx.de', 'carla2@hotmail.org', 'lars-schneider@gmx.de', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> listeAdressen = listeAdressen[0:2] + ['lars-schneider@gmx.de'] + listeAdressen[2:7]>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'lars-schneider@gmx.de', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']

Ein Einfügen von Listenelementen an einer bestimmten Stelle innerhalb einer Liste ist wie folgt möglich.

erzeugt eine neue Liste

verändert die Liste

32 Listenelemente entfernen

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', ]>>> listeAdressen = ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> listeAdressen[0:len(listeAdressen)-1]['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de']>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> listeAdressen = listeAdressen[0:len(listeAdressen)-1]>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de']

Aus einer Liste kann man Elemente auch wieder löschen. Der folgende Python-Dialog zeigt wie das geht.

erzeugt eine neue Liste

verändert die Liste

33 Listenelemente entfernen

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de' ]>>> listeAdressen = ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> listeAdressen[0:1] + listeAdressen[2:5]['amueller@gmx.de', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> listeAdressen = listeAdressen[0:1] + listeAdressen[2:5]>>> listeAdressen['amueller@gmx.de', 'herbert.fluhr@web.de', 'petra@dahm.de']

Aus einer Liste kann man Elemente auch wieder löschen. Der folgende Python-Dialog zeigt wie das geht.

erzeugt eine neue Liste

verändert die Liste

34 Eine Liste dynamisch verändern

'amueller@gmx.de'

'carla2@hotmail.org'

'herbert.fluhr@web.de'

'petra@dahm.de'

'ewen@t-online.de'

't_schmidt@web.de'

'nicole.weber@gmx.de'

'lars-schneider@gmx.de'

'carla_meier@online.de'

'mia@miaweb.de'

>>> listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]

Aufgabe:Benutze die eingeführten Listenoperationen, um die Liste mit E-Mail-Adressen in der gezeigten Weise zu verändern.

35 Listenoperationen selbst definieren

Bei der automatisierten Verwaltung und Versendung von Newsletter ist es günstig, wenn unterschiedliche Operationen zur Verarbeitung von Listen mit E-Mail-Adressen zur Verfügung stehen. Mit solchen Operationen sollte es z.B. möglich sein, auf einfache Weise neue E-Mail-Adressen hinzuzufügen oder auch vohandene E-Mail-Adressen wieder zu löschen.

Programmiersysteme wie Python stellen in der Regel eine Reihe vordefinierter Operationen zur Verarbeitung von Listen zur Verfügung. So kann man in Python die Operation len zur Bestimmung der Anzahl der Listenelemente und die Operation + zum Aneinanderhängen von Listen benutzen.

Zur flexiblen Verarbeitung von Listen sind weitere Operationen wünschenswert. Im Folgenden wird gezeigt, wie man sich Listenoperationen selbst definieren kann.

Operationen zur Listenverarbeitung werden dabei mit Hilfe von Funktionen realisiert. Wir werden versuchen, die Listenoperationen als flexibel verwendbare Bausteine zu konzipieren. Das hat den Vorteil, dass man sie in vielen verschiedenen Anwendungssituationen benutzen kann. Wir werden daher zunächst vom Kontext "Newsletter" absehen und neue Operationen zur Listenverarbeitung möglichst allgemein festlegen.

36 Listenoperationen selbst definieren

Das Verhalten der Funktion mitErstemElement lässt sich gut mit einem Black-Box-Diagramm verdeutlichen.

def mitErstemElement(element, liste):

""" >>> mitErstemElement(3, [25, 40, 44, 1, 45, 21]) [3, 25, 40, 44, 1, 45, 21] >>> mitErstemElement(7, []) [7] """ neueListe = [element] + liste return neueListe

Der folgende Python-Quelltext zeigt, wie man die Funktion mitErstemElement definieren kann. Beachte, dass in der Funktionsdefinition Testfälle zur Verhaltensbeschreibung integriert sind.

37 Listenoperationen selbst definieren

Testen im Ausführfenster:

>>> adressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]>>> mitErstemElement('momo7@online.de', adressen)['momo7@online.de', 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> adressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> adressen = mitErstemElement('momo7@online.de', adressen)>>> adressen['momo7@online.de', 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']

def mitErstemElement(element, liste):

""" >>> mitErstemElement(3, [25, 40, 44, 1, 45, 21]) [3, 25, 40, 44, 1, 45, 21] >>> mitErstemElement(7, []) [7] """ neueListe = [element] + liste return neueListe

# Test

adressen = ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']print(adressen)adressen = mitErstemElement('momo7@online.de', adressen)print(adressen)

Testen mit einem Testprogramm:

38 Listenoperationen selbst definieren

Test der integrierten Testfälle:

def mitErstemElement(element, liste):

""" >>> mitErstemElement(3, [25, 40, 44, 1, 45, 21]) [3, 25, 40, 44, 1, 45, 21] >>> mitErstemElement(7, []) [7] """ neueListe = [element] + liste return neueListe

if __name__ == '__main__': from doctest import testmod testmod(verbose=True)

39 Listenoperationen selbst definieren

Aufgabe: Entwickle und teste analog Funktionen zur Realisierung der folgenden Listenoperationen:

40 Listenoperationen selbst definieren

Aufgabe: Entwickle und teste analog Funktionen zur Realisierung der folgenden Listenoperationen:

41 Daten sichern

Wenn man E-Mail-Adressen mit einer Liste verwaltet, dann erfolgt die Datenhaltung nur solange das Programmiersystem aktiv ist. Für eine längerfristige Datenhaltung müssen die Daten in einer externen Datei gespeichert werden. Um beides nutzen zu können - längerfristige Datenhaltung in einer Datei und flexible Datenhaltung und -verarbeitung mit Listen - benötigt man Funktionen, die das Speichern und Laden von Daten sowie das Umwandeln von Listen und Texten ermöglichen.

>>> adressen = ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> adressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> ========================== RESTART ====================>>> adressenTraceback (most recent call last): File "<pyshell#30>", line 1, in <module> adressenNameError: name 'adressen' is not defined

42 Bausteine

Funktionen zur Listenverarbeitung muss man nicht immer selbst konzipieren und definieren. Oft kann man auf bereits existierende Funktionsdefinitionen zurückgreifen. Wenn die Funktionsdefinitionen hinreichend dokumentiert sind, dann kann man die Funktionen als fertige Bausteine benutzen.

def textAusDatei(dateiname): # lädt einen Text aus einer Datei und gibt ihn als # Zeichenkette zurück # beachte: setzt die Codierung iso-8859-1 voraus datei = open(dateiname, 'r', encoding='iso-8859-1') text = datei.read() datei.close() return text

def textInDateiSpeichern(dateiname, text): # speichert eine Zeichenkette in einer Datei # beachte: benutzt die Codierung iso-8859-1 datei = open(dateiname, 'w', encoding='iso-8859-1') datei.write(text) datei.close()

43 Bausteine

def textAusStringListe(liste): """ >>> textAusStringListe(['Tamara', 'Peter', 'Bello']) 'Tamara\nPeter\nBello' """ text = '' if len(liste) > 0: text = text + liste[0] for element in liste[1:]: text = text + '\n' + element return text

def stringListeAusText(text): """ >>> stringListeAusText('Tamara\nPeter\nBello') ['Tamara', 'Peter', 'Bello'] >>> stringListeAusText('Text\nmit\n\nmehreren\nZeilen') ['Text', 'mit', '', 'mehreren', 'Zeilen'] """

liste = text.split('\n') return liste

44 Bausteine verwenden

Aufgabe: Speichere die Bausteine zum Laden und Speichern in einer Datei mit dem Dateinamen listenoperationen_zum_laden_und_speichern.py ab. Führe das Python-Programm mit den Funktionsdefinitionen einmal aus, damit Python die Funktionsdefinitionen "übernimmt". Entwickle anschließend geeignete Testprogramme. Beachte, dass die Testprogramme im selben Verzeichnis gespeichert sind wie das Programm mit den Funktionsdefinitionen. from listenoperationen_zum_laden_und_speichern import *

# Test

listeAdressen = [ 'amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de' ]

text = textAusStringListe(listeAdressen)print(text)

45 Teil 3

Listen in Python

46 Fachkonzept - Liste

Eine Liste ist eine Datenstruktur zur Verwaltung endlicher Folgen von Daten, bei der man flexibel neue Daten hinzufügen und vorhandene Daten entfernen kann. Listen werden mit eckigen Klammern dargestellt.

Alle Elemente e. Liste werden mit Kommata getrennt.

Eine besondere Liste ist die leere Liste.

Die Elemente einer Liste können (in Python) von beliebigem - also auch unterschiedlichem - Typ sein.

Eine Liste kann selbst wieder Listen als Elemente haben. Listen können also geschachtelt werden.

[1, 12, 21, 31, 37, 46]

['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', ...]

[]

[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]]

'amueller@gmx.de'

'carla2@hotmail.org'

'herbert.fluhr@web.de'

'petra@dahm.de'

'ewen@t-online.de'

't_schmidt@web.de'

'nicole.weber@gmx.de'

'lars-schneider@gmx.de'

'carla_meier@online.de'

'mia@miaweb.de'

47 Liste als sequentieller Datentyp

Index

>>> L = [10, 15, 21, 33, 37, 40]>>> L[0]10>>> L[1]15

lesender Zugriff

>>> L = [10, 15, 21, 33, 37, 40]>>> L[10, 15, 21, 33, 37, 40]>>> L[4] = 36>>> L[10, 15, 21, 33, 36, 40]

schreibender Zugriff

Während ein lesender Zugriff auf jedes Element der Sequenz bei allen sequentiellen Datenobjekten möglich ist, ist ein schreibender Zugriff nur bei veränderbaren Datenobjekten (wie Listen) möglich.

Sequentielle Datenobjekte sind in Python zusammengesetzte Datenobjekte, die aus einer Folge von (gleichartigen oder auch verschiedenen) Datenobjekten bestehen. Die Elemente eines solchen sequentiellen Datenobjekts sind durchnummeriert Die Nummerierung beginnt immer bei 0. Die Nummer wird auch Index genannt.

25

ziehung0

401

442

1

3

454

215

Element

48 Liste als sequentieller Datentyp

>>> ziehung = [25, 40, 44, 1, 45, 21]>>> ziehung[0:2][25, 40]>>> ziehung[2:5][44, 1, 45]>>> ziehung[3:3][]

Teillisten

>>> ziehung = [25, 40, 44, 1, 45, 21]>>> ziehung[:2][25, 40]>>> ziehung[2:][44, 1, 45, 21]>>> ziehung[:][25, 40, 44, 1, 45, 21]

Ein Zugriff auf eine Teilliste ist möglich: 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.

Teillisten

25

ziehung0

401

442

1

3

454

215

49 Liste als sequentieller Datentyp

>>> tippAnfang = [2, 6]>>> tippEnde = [16, 40, 41, 43]>>> tippAnfang + tippEnde[2, 6, 16, 40, 41, 43]>>> tippAnfang + [10][2, 6, 10]>>> [] + tippAnfang[2, 6]

Konkatenation

>>> tippAnfang = [2, 6, 16, 40]>>> len(tippAnfang)4>>> len([])0

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.

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änge

25

ziehung0

401

442

1

3

454

215

50 Liste als sequentieller Datentyp

>>> tippAnfang = [2, 6, 16, 40]>>> t = 25>>> t in tippAnfangFalse>>> t = 40>>> t in tippAnfangTrue

Elementbeziehung

Mit einem Ausdruck der Gestalt e in L kann man überprüfen, ob das von e verwaltete Datenobjekt in der von L verwalteten Liste vorkommt.

25

ziehung0

401

442

1

3

454

215

>>> ziehung = [25, 40, 44, 1, 45, 21]>>> for z in ziehung:

print(z)

25404414521

Mit einer for-Anweisung der Gestalt for e in L: ...kann man alle Elemente einer Liste (Sequenz) der Reihe nach durchlaufen.

Durchlaufen einer Liste

51 Eine Liste kopieren

Wie kopiert man eine E-Mail-Adressliste? Das ist gar nicht so einfach, wie der folgende Python-Dialog zeigt.

>>> adressen1 = ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> adressen2 = adressen1>>> adressen2[1] = 'carla@mueller.de'>>> adressen2['amueller@gmx.de', 'carla@mueller.de', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> adressen1['amueller@gmx.de', 'carla@mueller.de', 'herbert.fluhr@web.de', 'petra@dahm.de']

52 Eine Liste kopieren

Wie kopiert man eine E-Mail-Adressliste? Das ist gar nicht so einfach, wie der folgende Python-Dialog zeigt.

>>> adressen1 = ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> adressen2 = adressen1[:]>>> adressen2[1] = 'carla@mueller.de'>>> adressen2['amueller@gmx.de', 'carla@mueller.de', 'herbert.fluhr@web.de', 'petra@dahm.de']>>> adressen1['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de']

53

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]

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.

>>> liste1 = [4, 13, 21, 33, 34, 42]>>> id(liste1)12289008>>> type(liste1)<type 'list'>>>> liste1[4, 13, 21, 33, 34, 42]

54

Verwaltung von Listen mit Variablen

>>> liste1 = [4, 13, 21, 33, 34, 42]>>> liste2 = liste1>>> liste2[1] = 8>>> liste2[4, 8, 21, 33, 34, 42]>>> liste1[4, 8, 21, 33, 34, 42]>>> liste1 = [4, 13, 21, 33, 34, 42]>>> liste1[4, 13, 21, 33, 34, 42]>>> liste2[4, 8, 21, 33, 34, 42]>>> liste2[0] = 3>>> liste2[3, 8, 21, 33, 34, 42]>>> liste1[4, 13, 21, 33, 34, 42]

55 Listen als Objekte

Listen sind - in Python - Objekte der Klasse list. Listen bringen daher eine Reihe vordefinierter Operationen (Methoden) zur Verarbeitung mit. >>> adressen1 = ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de, 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de']>>> listeAdressen.append('tom.brand@schule.de')>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de', 'tom.brand@schule.de']>>> listeAdressen.insert(3, 'katrin12@yahoo.com')>>> listeAdressen['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', 'katrin12@yahoo.com', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de', 'tom.brand@schule.de']>>> listeAdressen.remove('carla2@hotmail.org')>>> listeAdressen['amueller@gmx.de', 'herbert.fluhr@web.de', 'katrin12@yahoo.com', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de', 'tom.brand@schule.de']>>> listeAdressen.extend(['carla2@hotmail.org', 'carl3@hotmail.org'])>>> listeAdressen['amueller@gmx.de', 'herbert.fluhr@web.de', 'katrin12@yahoo.com', 'petra@dahm.de', 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de', 'tom.brand@schule.de', 'carla2@hotmail.org', 'carl3@hotmail.org']

56 Listen als Objekte

>>> liste = ['a', 'b']>>> liste['a', 'b']>>> id(liste)20306640>>> liste.append('c')>>> liste['a', 'b', 'c']>>> id(liste)20306640

>>> liste = ['a', 'b']>>> liste['a', 'b']>>> id(liste)20306120>>> liste[0] = 'c'>>> liste['c', 'b']>>> id(liste)20306120

>>> liste = ['a', 'b']>>> liste['a', 'b']>>> id(liste)10126560>>> liste + ['c']['a', 'b', 'c']>>> id(liste + ['c'])20307000>>> liste['a', 'b']>>> id(liste)10126560>>> liste[0:2]['a', 'b']>>> id(liste[0:2])19981656>>> liste['a', 'b']>>> id(liste)10126560

Erzeugung neuer Listen

Veränderung einer bestehenden Listen

Veränderung einer bestehenden Listen

objektorientiert: L.Listenoperation funktional: L = Listenkonstruktor

57 Teil 4

Fallstudie - Logdatei

58 Logdateien

Logdateien werden benutzt, um Information über Prozesse, die auf einem Computersystem laufen, automatisiert zu protokollieren. Logdateien werden von bestimmten Rechnern für unterschiedlichste Zwecke erstellt.

Beachte:

Mit der Erstellung von Logdateien eng verbunden ist das Problem der Vorratsdatenspeicherung. Häufig werden in Logdateien Daten über einen längeren Zeitraum gespeichert, die personenbeziehbar sind und Rückschlüsse auf das Verhalten der betreffenden Personen zulassen. (siehe z.B.: http://www.zeit.de/datenschutz/malte-spitz-vorratsdaten)

131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

Beispiele:

Ein Schulserver protokolliert (je nach Einstellung) u.a., wann welches Programm auf welchem Rechner benutzt wurde.

Web-Serber protokollieren u.a., wer welche Webseite wann aufgerufen hat.

Die Rechner von Telekommunikationsanbietern protokollieren u.a., wann und wo welches Handy eingeschaltet war.

59 Eine Webserver-Logdatei

In einer Webserver-Logdatei werden alle Zugriffe auf Dateien, die zur Darstellung von Webseiten benötigt werden, protokolliert. Wir betrachten im Folgenden die Daten einer solchen Webserver-Logdatei (in etwas vereinfachter Form, da weitere Angaben weggelassen sind):

131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

Erläuterung:

131.246.0.13 IP-Adresse des aufrufenden Hosts

- Benutzernamer, sofern erforderlich

- Passwort, falls erforderlich

[24/Jul/2012:12:44:21 +0200] Zeitstempel bestehend aus Datum, Uhrzeit und Zeitverschiebung

"GET /informatik/index.html HTTP/1.1" Anfrage an den Server

200 Antwort des Servers (200: erfolgreiche Anfrage)

512 Dateigröße (Anzahl der Bytes)

60 Verwaltung von Logdatei-Daten

Wenn Daten einer Logdatei automatisiert analysiert weren sollen, dann sollten sie in einer gut verarbeitbaren Form vorliegen.

Eine naheliegende Möglichkeit wäre, die einzelnen Einträge einer Logdatei als Zeichenketten darzustellen und alle diese Zeichenketten mit einer Liste zu verwalten.

131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

['131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512','131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805',...]

Aufgabe:

Welchen Nachteil hätte diese Darstellung der Daten mit Hilfe von Zeichenketten?

61

Verwaltung mit geschachtelten Listen

Wir werden im Folgenden versuchen, die Strukur der darzustellenden Daten besser zu erfassen. Vorerst betrachten wir nur den Zeitstempel eines Datensatzes.

131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

>>> zeitstempel = [[24, 'Jul', 2012], [12, 44, 21], ['+', 2, 0]]>>> zeitstempel[[24, 'Jul', 2012], [12, 44, 21], ['+', 2, 0]]>>> zeitstempel[0][24, 'Jul', 2012]>>> zeitstempel[0][1]...>>> zeitstempel[1]...>>> zeitstempel[1][0]...>>> zeitstempel[1][0:2]...>>> zeitstempel[2][1]...

62

Verwaltung mit geschachtelten Listen

Aufgabe:

(a) Wie würde man analog den Zeitstempel [21/Jan/2008:12:44:01 +0100] mit Listen darstellen?

(b) Im Python-Dialog oben fehlen etliche Auswertungsergebnisse (hier angedeutet durch ...). Stelle zunächst Vermutungen auf, was hier von Python als Ergebnis zurückgeliefert wird. Überprüfe anschließend deine Vermutungen.

(c) Welche Vorteile hat die Darstellung strukturierter Daten mit geschachtelten Listen?

(d) Überlege dir eine strukturierte Listendarstellung für die Daten einer Logdatei.131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

63 Datenverwaltung mit Tupeln

Daten mit einer komplexen Struktur lassen sich oft auch (in Python) als Tupel verwalten. Beachte, dass hier bei der Datendarstellung runde Klammern benutzt werden .131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

>>> zeitstempel = ((24, 'Jul', 2012), (12, 44, 21), ('+', 2, 0))>>> zeitstempel((24, 'Jul', 2012), (12, 44, 21), ('+', 2, 0))>>> zeitstempel[0](24, 'Jul', 2012)>>> zeitstempel[0][1]'Jul'>>> zeitstempel[1](12, 44, 21)>>> zeitstempel[1][0]12>>> zeitstempel[1][0:2](12, 44)>>> zeitstempel[2][1]2

>>> zeitstempel = [[24, 'Jul', 2012], [12, 44, 21], ['+', 2, 0]]>>> zeitstempel[[24, 'Jul', 2012], [12, 44, 21], ['+', 2, 0]]>>> zeitstempel[0][24, 'Jul', 2012]>>> zeitstempel[0][1]'Jul'>>> zeitstempel[1][12, 44, 21]>>> zeitstempel[1][0]12>>> zeitstempel[1][0:2][12, 44]>>> zeitstempel[2][1]2

64 Unterschied Tupel - Liste

Aufgabe:

Der folgende Python-Dialog zeigt einen weiteren Unterschied zwischen Listen und Tupeln. Beschreibe diesen Unterschied.

>>> datum1 = [24, 'Jul', 2012]>>> datum1[24, 'Jul', 2012]>>> datum1[0] = 25>>> datum1[25, 'Jul', 2012]>>> datum2 = (24, 'Jul', 2012)>>> datum2(24, 'Jul', 2012)>>> datum2[0] = 25Traceback (most recent call last): File ... datum2[0] = 25TypeError: 'tuple' object does not support item assignment

>>> uhrzeit1 = [12, 44]>>> uhrzeit1 = uhrzeit1 + [1]>>> uhrzeit1[12, 44, 1]>>> uhrzeit2 = (12, 44)>>> uhrzeit2 = uhrzeit2 + (1)Traceback (most recent call last): File ... uhrzeit2 = uhrzeit2 + (1)TypeError: can only concatenate tuple (not "int") to tuple

65 Fachkonzept - Tupel

Eine Tupel ist eine Datenstruktur, bei der mehrere Daten zu einer Einheit zusammengefasst werden.

Tupel weisen einige Ähnlichkeiten mit Listen auf, unterscheiden sich aber in einigen Punkten wesentlich von Listen.

Ein lesender Zugriff auf Tupelelemente erfolgt genau wie bei Listen. Ein schreibender Zugriff auf Tupelelemente ist - anders als bei Listen - nicht möglich. Man kann ein Tupel nicht dadurch abändern, dass man ein Element durch ein anderes ersetzt. Wenn man ein Tupel abändern will, muss man ein neues Tupelobjekt erzeugen. >>> datum = (24, 'Jul', 2012)>>> uhrzeit = (12, 44, 21)>>> zeitverschiebung = ('+', 2, 0)>>> zeitstempel = (datum, uhrzeit, zeitverschiebung)>>> zeitstempel((24, 'Jul', 2012), (12, 44, 21), ('+', 2, 0))

Tupel zusammenpacken

>>> zeitstempel = ((25, 'Jul', 2012), (10, 20, 0), ('+', 2, 0))>>> (datum, uhrzeit, zeitverschiebung) = zeitstempel>>> datum(25, 'Jul', 2012)>>> uhrzeit(10, 20, 0)>>> zeitverschiebung('+', 2, 0)

Tupel auspacken

66

Datenverwaltung mit Tupeln und Listen

Aufgabe:

Die Daten einer Webserver-Logdatei sollen mit Hilfe von Listen und Tupeln adäquat dargestellt werden. Was könnte man mit Tupeln erfassen, was sollte man mit Listen erfassen? 131.246.0.13 - - [24/Jul/2012:12:44:21 +0200] "GET /informatik/index.html HTTP/1.1" 200 512 131.246.0.13 - - [24/Jul/2012:12:44:25 +0200] "GET /informatik/bild.png HTTP/1.1" 200 805 # ...

Aufgabe:

Ergänze selbst weitere Datensätze. Entwickle geeignete Funktionen zur Analyse der Daten einer Logdatei.

67 Teil 5

Fallstudie - Spiel des Lebens

68 Spiel des Lebens

Beim Spiel des Lebens geht es darum, ob einzelne Zellen in einer Welt, die nur aus Zellen besteht, überleben oder ob sie absterben.

Spielregeln:

Eine tote Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren.

Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.

Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration lebend.

Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung.

69 Verwaltung der Spielwelt

Diese Welt kann man z.B. mit Hilfe von Listen darstellen:

>>> welt = [[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]>>> welt[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]>>> welt[0][3]...>>> welt[1][2]...>>> welt[2][1]...>>> welt[2]...>>> [welt[0][3], welt[1][3], welt[2][3], welt[3][3], welt[4][3]]...

Liste bestehend aus Listen

zweidimensionale Datenanordnung

70 Verwaltung der Spielwelt

Aufgabe: Entwickle ein Programm zur Ausgabe der Spielwelt auf dem Bildschirm.

# Initialisierungwelt = [[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]

# Ausgabe...

71 Algorithmus zur Spielsimulation

Aufgabe:

Wo steckt der Fehler?

ALGORITHMUS neueWelt:Übergabe: weltFÜR i von 0 bis 4: FÜR j von 0 bis 4: anzahl = Anzahl der lebenden Nachbarn von welt[i][j] # Eine tote Zelle mit genau drei lebenden Nachbarn # wird in der Folgegeneration neu geboren. WENN welt[i][j] == 0 und anzahl == 3: welt[i][j] = 1 # Lebende Zellen mit weniger als zwei lebenden Nachbarn # sterben in der Folgegeneration an Einsamkeit. SONST WENN welt[i][j] == 1 und anzahl < 2: welt[i][j] = 0 # ...Rückgabe: welt

Achtung: fehlerhaft!

72 Algorithmus zur Spielsimulation

ALGORITHMUS neueWelt:Übergabe: weltkopie = Kopie der Liste weltFÜR i von 0 bis 4: FÜR j von 0 bis 4: anzahl = Anzahl der lebenden Nachbarn von welt[i][j] # Eine tote Zelle mit genau drei lebenden Nachbarn # wird in der Folgegeneration neu geboren. WENN welt[i][j] == 0 und anzahl == 3: kopie[i][j] = 1 # Lebende Zellen mit weniger als zwei lebenden Nachbarn # sterben in der Folgegeneration an Einsamkeit. SONST WENN welt[i][j] == 1 und anzahl < 2: kopie[i][j] = 0 # ...Rückgabe: kopie

So ist es korrekt!

73 Eine Kopie der Welt erzeugen

>>> welt = [[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]>>> kopie = welt[:]>>> welt[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]>>> kopie[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]>>> kopie[2][2] = 0>>> kopie[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]>>> welt[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]

So funktioniert es nicht!

Aufgabe:

Wie kann man es besser machen?

74 Anzahl der Nachbarn zählen

Black-Box-Modellierung

Aufgabe:

Entwickle eine Funktionsdefinition zu der beschriebenen Funktion und teste sie mit verschiedenen Übergabedaten. Beachte, dass die Zellen an den Rändern der Welt weniger Nachbarn haben.

anzahlLebendeNachbarn

2 x

3 y

5return

[[0, 0, 0, 0, 0],[0, 1, 1, 1, 0],[0, 0, 1, 0, 0],[0, 0, 1, 1, 0],[0, 0, 0, 0, 0]]

welt

75 Eine neue Welt erzeugen

Black-Box-Modellierung

Aufgabe:

Implementiere diese Funktion. Du kannst dich dabei an dem oben gezeigten (verbesserten) Algorithmus orientieren.

neueWelt

[[0, 0, 1, 0, 0]

[0, 1, 1, 1, 0],

[0, 0, 0, 0, 0],

[0, 0, 1, 1, 0],

[0, 0, 0, 0, 0]]

return

[[0, 0, 0, 0, 0],[0, 1, 1, 1, 0],[0, 0, 1, 0, 0],[0, 0, 1, 1, 0],[0, 0, 0, 0, 0]]

welt

76 Spiel des Lebens

Aufgabe:

Es gibt zahlreiche interessante Fragestellungen zum Spiel des Lebens, z.B.: Gibt es Welten, die sich nicht verändern? Weitere Fragestellungen ergeben sich aus dem Artikel bei Wikipedia.

Entwickle dein Simulationsprogramm entsprechend selbstständig weiter.

77

Verwaltung zweidim. Dateneinheiten

Häufig steht man vor dem Problem, eine zweidimensionale Dateneinheit zu verwalten. Hier bietet es sich an, diese Dateneinheit aus Listen aufzubauen.

0 0 0 0 0

0 1 1 1 0

0 0 1 0 0

0 0 1 1 0

0 0 0 0 0

0 0 0 0 0

0 1 1 1 0

0 0 1 0 0

0 0 1 1 0

0 0 0 0 0

L[0]L:

L[1]

L[2]

L[3]

L[4]

L[0][0]

L[0][1]

L[0][2]

L[0][3]

L[0][4]

L[4][0]

L[4][1]

L[4][2]

L[4][3]

L[4][4]

78

Verarbeitung zweidim. Dateneinheiten

Häufig steht man vor dem Problem, eine zweidimensionale Dateneinheit zu verwalten. Hier bietet es sich an, diese Dateneinheit aus Listen aufzubauen.

0 0 0 0 0

0 1 1 1 0

0 0 1 0 0

0 0 1 1 0

0 0 0 0 0

L[0]L:

L[1]

L[2]

L[3]

L[4]

L[0][0]

L[0][1]

L[0][2]

L[0][3]

L[0][4]

L[4][0]

L[4][1]

L[4][2]

L[4][3]

L[4][4]

# L: Liste bestehend aus Listen zur Verwaltung einer 2-D-Dateneinheit# n: Anzahl der Daten pro Zeile bzw. Spalte

FÜR i von 0 bis n-1: FÜR j von 0 bis n-1: verarbeite L[i][j]

79 Fachkonzept - Datenstruktur

Datenstrukturen ermöglichen es, strukturierte Daten als Einheit zu verwalten.

'Losnummer'

3 6 19

21

38

41

4 9 17

37

38

39

18

23

28

36

38

46

'Superzahl'

'Ziehungstage'

'Laufzeit'

'Spiel 77'

'Super 6'

'Gluecksspirale'

4440674

4

'Sa + Mi'

1

False

False

False

Datenmodellierung mit den Datenstrukturen "Liste" und "Tupel"

80 Fachkonzept - Datenstruktur

'Losnummer'

3 6 19

21

38

41

4 9 17

37

38

39

18

23

28

36

38

46

'Superzahl'

'Ziehungstage'

'Laufzeit'

'Spiel 77'

'Super 6'

'Gluecksspirale'

4440674

4

'Sa + Mi'

1

False

False

False

Implementierung mit den Datenstrukturen "Liste" und "Tupel"

>>> lottoschein = [ [(3, 6, 19, 21, 38, 41), (4, 9, 17, 37, 38, 39), (18, 23, 28, 36, 38, 46)], ('Losnummer', 4440674), ('Superzahl', 4), ('Ziehungstage', 'Sa + Mi'), ('Laufzeit', 1), ('Spiel 77', False), ('Super 6', False), ('Gluecksspirale', False) ]

Zentrale Datenstrukturen in Python sind Listen und Tupel.

81 Fachkonzept - Datenstruktur

Datenstrukturen ermöglichen es, strukturierte Daten als Einheit zu verwalten.

>>> lottoschein = [ [(3, 6, 19, 21, 38, 41), (4, 9, 17, 37, 38, 39), (18, 23, 28, 36, 38, 46)], ('Losnummer', 4440674), ('Superzahl', 4), ('Ziehungstage', 'Sa + Mi'), ('Laufzeit', 1), ('Spiel 77', False), ('Super 6', False), ('Gluecksspirale', False) ]

Datenmodellierung mit den Datenstrukturen "Liste" und "Tupel"

82 Übungen - Datenstruktur

>>> lottoschein = [ [(3, 6, 19, 21, 38, 41), (4, 9, 17, 37, 38, 39), (18, 23, 28, 36, 38, 46)], ('Losnummer', 4440674), ('Superzahl', 4), ('Ziehungstage', 'Sa + Mi'), ('Laufzeit', 1), ('Spiel 77', False), ('Super 6', False), ('Gluecksspirale', False) ]>>> lottoschein[0][1]...>>> lottoschein[0][1][2]...>>> lottoschein[1][0]...

Aufgabe: Zugriff auf geschachtelte Daten

Ergänze die Ergebnisse. Überprüfe sie mit Python.

Aufgabe: Datenmodellierung

Wie könnte man die Gewinnquoten beim Lotto mit Datenstrukturen erfassen?

83 Übungen - Datenstruktur

Aufgabe: Magische Quadrate

Ein magisches Quadrat ist eine quadratische Anordnung der Zahlen 1, 2, ..., sodass die Summe der Zahlen aller Zeilen, Spalten und der beiden Diagonalen gleich ist.

Eines der bekanntesten magischen Quadrate ist auf dem Kupferstich Melencolia I von Albrecht Dürer zu sehen.

Entwickle ein Programm, mit dem man ein quadratisches Zahlenfeld daraufhin überprüfen kann, ob es ein magisches Quadrat darstellt.

84 Übungen - Datenstruktur

Aufgabe: Sudoku

Deine Aufgabe ist es, ein Programm zu entwickeln, mit dem man Sudoku-Lösungsvorschläge auf ihre Korrektheit überprüfen kann. Das Programm soll gegebenenfalls Rückmeldungen über die gefundenen Fehler machen.

Überlege dir zunächst eine Datenstruktur zur Verwaltung von Sudokus. Entwickle anschließend ein Verfahren, mit dem man die Korrektheit von Sudokus testen kann und implementiere es in Python.

Für Experten: Viel schwieriger ist es, zu einem vorgegebenen Sudoku-Rätsel eine Lösung automatisiert zu erzeugen.

3

1 9

9 8

8 6

4

5

6

3 1

2

6

4 1

2 8

9

7

5 3 4 6 7

6 7 2 1 9

1 9 8 3 4

8 5 9 7 6

4 2 6 8 5

8 9 1 2

5 3 4 8

2 5 6 7

1 4 2 3

3 7 9 1

7 1 3 9 2

9 6 1 5 7

2 8 7 4 1

3 4 5 2 8

4 8 5 7

3 2 8 4

9 6 3 5

6 1 7 9