Datenverwaltung mit Datenstrukturen Klaus Becker 2012

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 # ...

Fallstudie - Lottosimulation Teil 1 Fallstudie - Lottosimulation

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.

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. # Datenverwaltung zahl1 = 25 zahl2 = 40 zahl3 = 44 zahl4 = 1 zahl5 = 45 zahl6 = 21 # Ausgabe print(zahl1) print(zahl2) print(zahl3) print(zahl4) print(zahl5) print(zahl6) # Datenverwaltung ziehung = [25, 40, 44, 1, 45, 21] # Ausgabe i = 0 while i < len(ziehung): print(ziehung[i]) i = i+1 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? Verwendung vieler Variablen

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. # Datenverwaltung feld1 = True feld2 = False ... # Ausgabe print(feld1) print(feld2) # Datenverwaltung 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, ] # Ausgabe ...

Eine Liste durchlaufen 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 # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] # Verarbeitung und Ausgabe i = 0 while i < len(ziehung): print(ziehung[i]) i = i+1 # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] # Verarbeitung und Ausgabe for i in range(len(ziehung)): print(i) print(ziehung[i]) Aufgabe: Ergänze das Programm so, dass man folgende Ausgabe erhält: Aufgabe: Teste auch das oben gezeigte Programm. Was leistet der range-Operator? >>> Kugel 1 : 25 Kugel 2 : 40 Kugel 3 : 44 Kugel 4 : 1 Kugel 5 : 45 Kugel 6 : 21 >>> 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]

Eine Liste durchlaufen Die Zahlen einer Lotto-Ziehung (ohne Zusatz-zahl) werden mit einer Liste verwaltet. Die Listenelemente sind dabei - beginnend mit 0 - mit einem Index durchnummeriert. # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] # Verarbeitung und Ausgabe for z in ziehung: print(z) Liste über die Elemente durchlaufen Aufgabe: Teste auch dieses Programm. Was leistet es?

Anzahl der Richtigen 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. # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] tipp = [1, 12, 21, 31, 37, 46] # Verarbeitung richtige = 0 i = 0 while i < len(ziehung): j = 0 while j < len(tipp): print('vergleiche: ', ziehung[i], tipp[j]) # ... j = j+1 i = i+1 # Ausgabe print(richtige) # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] tipp = [1, 12, 21, 31, 37, 46] # Verarbeitung richtige = 0 for z in ziehung: for t in tipp: print('vergleiche: ', z, t) # ... # Ausgabe print(richtige) Teste erst einmal, was die Programme schon leisten. Ergänze die noch fehlenden Teile.

Anzahl der Richtigen 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. # Initialisierung ziehung = [ True , False, False, False, False, False, False, False, False, False, False, False, False, False, ... ] tipp = [ False, False, False, False, True , False, False, # Verarbeitung richtige = 0 # ... # Ausgabe print(richtige)

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

Listen aneinanderhängen Elemente hinzufügen Der folgende Python-Dialog zeigt, wie man eine Liste zur Verwaltung der Zahlen eines Tipps schrittweise aufbauen kann. >>> liste = [] >>> liste [] >>> liste = liste + [12] >>> tipp [12] >>> liste = liste + [15] [12, 15] >>> liste = [7] + liste ... >>> liste = liste + [42, 47] >>> liste = [3] + liste Listen aneinanderhängen Aufgabe: Analysiere den gezeigten Python-Dialog. Stelle Vermutungen auf, was an Stelle der drei Punkte ... steht. Überprüfe deine Vermutung.

Ziehung automatisiert erzeugen Ziel ist es, eine Ziehung der Lottozahlen mit Hilfe des Zufallsgenerators von Python zu simulieren. Hier ein erster Vorschlag: from random import * # Verarbeitung ziehung = [] for i in range(6): zahl = randint(1, 49) ziehung = ziehung + [zahl] # Ausgabe print(ziehung) 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?

Ziehung automatisiert erzeugen Ziel ist es, eine Ziehung der Lottozahlen mit Hilfe des Zufallsgenerators von Python zu simulieren. Hier ein weiterer Vorschlag: from random import * # Verarbeitung ziehung = [] for i in range(49): ziehung = ziehung + [False] for i in range(6): zahl = randint(1, 49) ziehung[zahl-1] = True # Ausgabe if ziehung[i] == True: print(i+1) 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?

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.

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.

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

Gewinnchancen beim Lotto Aufgabe: Implementiere die vorgeschlagenen Funktionen. Benutze die bereits implementierten Funktionen.

Fallstudie - Newsletter Teil 2 Fallstudie - Newsletter

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.de To: alex2101@web.de Subject: Neuerungen Hallo! ...

Newsletter automatisiert senden Solche elektronischen Rundschreiben kann man automatisiert verfassen und versenden. Das folgende Python-Programm zeigt, wie das (im Prinzip) geht. # Mail erstellen mail_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_body print(mail) # Mail versenden import smtplib benutzer = 'inf-schule@gmx.de' passwort = '...' # wird nicht verraten empfaenger = 'alex2101@web.de' mailserver = 'smtp.gmx.de' smtp = smtplib.SMTP(mailserver) smtp.login(benutzer, passwort) smtp.sendmail(benutzer, empfaenger, mail) smtp.quit()

Datenverwaltung mit einer Liste Interessant wird das Programm, wenn man das elektronische Rundschreiben an mehrere Empfänger verschicken kann. # Mail erstellen mail_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_body print(mail) # Mail versenden import smtplib benutzer = 'inf-schule@gmx.de' passwort = '...' # wird nicht verraten empfaenger = 'alex2101@web.de' mailserver = 'smtp.gmx.de' smtp = smtplib.SMTP(mailserver) smtp.login(benutzer, passwort) smtp.sendmail(benutzer, empfaenger, mail) smtp.quit() # Datenverwaltung 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' ] # Datenverarbeitung for adresse in listeAdressen: # verarbeite adresse

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: 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. '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' 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.

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] >>> listeAdressen[7] Traceback (most recent call last): ... listeAdressen[7] IndexError: list index out of range lesender Zugriff

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' ['amueller@gmx.de', 'carla_meier@online.de', 'herbert.fluhr@web.de', 'petra@dahm.de', ... schreibender Zugriff

Zugriff auf Teillisten 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. >>> 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] [] Zugriff auf eine Teilliste >>> 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']

Zugriff auf Teillisten 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 = [ '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] ... >>> listeAdressen[2:5] >>> listeAdressen[1:4] >>> listeAdressen[3:3] >>> listeAdressen[3:9] >>> listeAdressen[0:len(listeAdressen)] >>> listeAdressen[2:] >>> listeAdressen[:2] >>> listeAdressen[:]

Listen zusammenfügen 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. >>> liste1 = ['T', 'e', 'r', 'm'] >>> liste2 = ['i', 'n'] >>> liste1 + liste2 ['T', 'e', 'r', 'm', 'i', 'n']

Listen zusammenfügen 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. >>> a = [1] >>> b = [2] >>> c = [3] >>> a = a+b >>> b = a+c >>> c = c+b >>> a ... >>> b >>> c >>> liste = [] >>> liste [] >>> liste = liste + ['n'] ... >>> liste = liste + ['t'] >>> liste = ['o'] + liste >>> liste = liste + ['a', 'g'] >>> liste = ['M'] + liste

Listenelemente einfügen Das Einfügen von Listenelementen am Anfang und Ende einer Liste ist einfach. >>> 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 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de'] >>> listeAdressen = listeAdressen + ['lars-schneider@gmx.de'] erzeugt eine neue Liste verändert die Liste

Listenelemente einfügen Ein Einfügen von Listenelementen an einer bestimmten Stelle innerhalb einer Liste ist wie folgt möglich. >>> 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] erzeugt eine neue Liste verändert die Liste

Listenelemente entfernen Aus einer Liste kann man Elemente auch wieder löschen. Der folgende Python-Dialog zeigt wie das geht. >>> 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] erzeugt eine neue Liste verändert die Liste

Listenelemente entfernen Aus einer Liste kann man Elemente auch wieder löschen. Der folgende Python-Dialog zeigt wie das geht. >>> 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] erzeugt eine neue Liste verändert die Liste

Eine Liste dynamisch verändern Aufgabe: Benutze die eingeführten Listenoperationen, um die Liste mit E-Mail-Adressen in der gezeigten Weise zu verändern. >>> 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' ] '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'

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.

Listenoperationen selbst definieren Das Verhalten der Funktion mitErstemElement lässt sich gut mit einem Black-Box-Diagramm verdeutlichen. Der folgende Python-Quelltext zeigt, wie man die Funktion mitErstemElement definieren kann. Beachte, dass in der Funktionsdefinition Testfälle zur Verhaltensbeschreibung integriert sind. 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

Listenoperationen selbst definieren Testen im Ausführfenster: Testen mit einem Testprogramm: >>> 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) 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)

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)

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

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

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 ==================== Traceback (most recent call last): File "<pyshell#30>", line 1, in <module> adressen NameError: name 'adressen' is not defined

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)

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

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)

Teil 3 Listen in Python

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. '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' 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. 'mia@miaweb.de' [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]]

Liste als sequentieller Datentyp 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. Element 25 40 44 1 45 21 ziehung 1 2 3 4 5 Index 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. >>> L = [10, 15, 21, 33, 37, 40] >>> L[0] 10 >>> L[1] 15 >>> L = [10, 15, 21, 33, 37, 40] >>> L [10, 15, 21, 33, 37, 40] >>> L[4] = 36 [10, 15, 21, 33, 36, 40] lesender Zugriff schreibender Zugriff

Liste als sequentieller Datentyp 25 40 44 1 45 21 ziehung 1 2 3 4 5 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. >>> ziehung = [25, 40, 44, 1, 45, 21] >>> ziehung[0:2] [25, 40] >>> ziehung[2:5] [44, 1, 45] >>> ziehung[3:3] [] >>> ziehung = [25, 40, 44, 1, 45, 21] >>> ziehung[:2] [25, 40] >>> ziehung[2:] [44, 1, 45, 21] >>> ziehung[:] [25, 40, 44, 1, 45, 21] Teillisten Teillisten

Liste als sequentieller Datentyp 25 40 44 1 45 21 ziehung 1 2 3 4 5 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. 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. >>> tippAnfang = [2, 6] >>> tippEnde = [16, 40, 41, 43] >>> tippAnfang + tippEnde [2, 6, 16, 40, 41, 43] >>> tippAnfang + [10] [2, 6, 10] >>> [] + tippAnfang [2, 6] >>> tippAnfang = [2, 6, 16, 40] >>> len(tippAnfang) 4 >>> len([]) Länge Konkatenation

Liste als sequentieller Datentyp 25 40 44 1 45 21 ziehung 1 2 3 4 5 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. Mit einer for-Anweisung der Gestalt for e in L: ... kann man alle Elemente einer Liste (Sequenz) der Reihe nach durchlaufen. >>> tippAnfang = [2, 6, 16, 40] >>> t = 25 >>> t in tippAnfang False >>> t = 40 True >>> ziehung = [25, 40, 44, 1, 45, 21] >>> for z in ziehung: print(z) 25 40 44 1 45 21 Durchlaufen einer Liste Elementbeziehung

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

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

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] >>> liste1 = [4, 13, 21, 33, 34, 42] >>> id(liste1) 12289008 >>> type(liste1) <type 'list'> >>> liste1 [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.

Verwaltung von Listen mit Variablen >>> liste2 = liste1 >>> liste2[1] = 8 >>> liste2 [4, 8, 21, 33, 34, 42] >>> liste1 [4, 13, 21, 33, 34, 42] >>> liste2[0] = 3 [3, 8, 21, 33, 34, 42]

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') ['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') ['amueller@gmx.de', 'herbert.fluhr@web.de', 'katrin12@yahoo.com', 'petra@dahm.de', >>> listeAdressen.extend(['carla2@hotmail.org', 'carl3@hotmail.org']) 'ewen@t-online.de', 't_schmidt@web.de', 'nicole.weber@gmx.de', 'tom.brand@schule.de', 'carla2@hotmail.org', 'carl3@hotmail.org']

Listen als Objekte >>> liste = ['a', 'b'] >>> liste objektorientiert: L.Listenoperation funktional: L = Listenkonstruktor >>> liste = ['a', 'b'] >>> liste ['a', 'b'] >>> id(liste) 20306640 >>> liste.append('c') ['a', 'b', 'c'] >>> liste = ['a', 'b'] >>> liste ['a', 'b'] >>> id(liste) 10126560 >>> liste + ['c'] ['a', 'b', 'c'] >>> id(liste + ['c']) 20307000 >>> liste[0:2] >>> id(liste[0:2]) 19981656 Veränderung einer bestehenden Listen >>> liste = ['a', 'b'] >>> liste ['a', 'b'] >>> id(liste) 20306120 >>> liste[0] = 'c' ['c', 'b'] Veränderung einer bestehenden Listen Erzeugung neuer Listen

Teil 4 Fallstudie - Logdatei

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. 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. 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)

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)

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?

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]

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 # ...

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

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 [25, 'Jul', 2012] >>> datum2 = (24, 'Jul', 2012) >>> datum2 (24, 'Jul', 2012) >>> datum2[0] = 25 Traceback (most recent call last): File ... datum2[0] = 25 TypeError: '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

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)) >>> 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 zusammenpacken Tupel auspacken

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.

Fallstudie - Spiel des Lebens Teil 5 Fallstudie - Spiel des Lebens

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.

Verwaltung der Spielwelt Diese Welt kann man z.B. mit Hilfe von Listen darstellen: zweidimensionale Datenanordnung Liste bestehend aus Listen >>> 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]]

Verwaltung der Spielwelt Aufgabe: Entwickle ein Programm zur Ausgabe der Spielwelt auf dem Bildschirm. # Initialisierung 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]] # Ausgabe ...

Algorithmus zur Spielsimulation ALGORITHMUS neueWelt: Übergabe: welt FÜ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! Aufgabe: Wo steckt der Fehler?

Algorithmus zur Spielsimulation ALGORITHMUS neueWelt: Übergabe: welt kopie = Kopie der Liste welt FÜ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!

Eine Kopie der Welt erzeugen >>> 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 >>> kopie[2][2] = 0 [[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?

Anzahl der Nachbarn zählen anzahlLebendeNachbarn 2 x 3 y [[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 return 5 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.

Eine neue Welt erzeugen [[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, 1, 0, 0] [0, 1, 1, 1, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]] return Black-Box-Modellierung Aufgabe: Implementiere diese Funktion. Du kannst dich dabei an dem oben gezeigten (verbesserten) Algorithmus orientieren.

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.

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. 1 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] 1 1 1 1 1 1

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. 1 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]

Fachkonzept - Datenstruktur Datenstrukturen ermöglichen es, strukturierte Daten als Einheit zu verwalten. 'Losnummer' 3 6 19 21 38 41 4 9 17 37 39 18 23 28 36 46 'Superzahl' 'Ziehungstage' 'Laufzeit' 'Spiel 77' 'Super 6' 'Gluecksspirale' 4440674 'Sa + Mi' 1 False Datenmodellierung mit den Datenstrukturen "Liste" und "Tupel"

Fachkonzept - Datenstruktur Zentrale Datenstrukturen in Python sind Listen und Tupel. 'Losnummer' 3 6 19 21 38 41 4 9 17 37 39 18 23 28 36 46 'Superzahl' 'Ziehungstage' 'Laufzeit' 'Spiel 77' 'Super 6' 'Gluecksspirale' 4440674 'Sa + Mi' 1 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) ]

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"

Übungen - Datenstruktur Aufgabe: Zugriff auf geschachtelte Daten Ergänze die Ergebnisse. Überprüfe sie mit Python. >>> 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: Datenmodellierung Wie könnte man die Gewinnquoten beim Lotto mit Datenstrukturen erfassen?

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

Ü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 8 6 4 5 2 7 5 3 4 6 7 2 1 9 8