Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Datenverwaltung mit Datenstrukturen Klaus Becker 2012.

Ähnliche Präsentationen


Präsentation zum Thema: "Datenverwaltung mit Datenstrukturen Klaus Becker 2012."—  Präsentation transkript:

1 Datenverwaltung mit Datenstrukturen Klaus Becker 2012

2 2 Datenverwaltung mit Datenstrukturen [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #...

3 3 Teil 1 Fallstudie - Lottosimulation

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

7 7 Eine Liste durchlaufen # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] # Verarbeitung und Ausgabe i = 0 while 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 : 25 Kugel 2 : 40 Kugel 3 : 44 Kugel 4 : 1 Kugel 5 : 45 Kugel 6 : 21 # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] # Verarbeitung und Ausgabe for 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 8 Eine Liste durchlaufen Aufgabe: Teste auch dieses Programm. Was leistet es? # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] # Verarbeitung und Ausgabe for 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 9 Anzahl der Richtigen # 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) 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 10 Anzahl der Richtigen # Initialisierung ziehung = [ 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,... ] # Verarbeitung richtige = 0 #... # Ausgabe print(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 11 Ziehung automatisiert erzeugen Beim Lotto werden die 6 Kugeln mit Zahlen aus dem Bereich 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 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 13 Ziehung automatisiert erzeugen from random import * # Verarbeitung ziehung = [] for i in range(6): zahl = randint(1, 49) ziehung = ziehung + [zahl] # Ausgabe print(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 14 Ziehung automatisiert erzeugen 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 for 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 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 mal Lotto spielt. Strukturiere das Programm mit Hilfe von Funktionen. (b) Wie lange dauert es im wirklichen Leben, bis 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 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 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 18 Gewinnchancen beim Lotto Aufgabe: Implementiere die vorgeschlagenen Funktionen. Benutze die bereits implementierten Funktionen.

19 19 Teil 2 Fallstudie - Newsletter

20 20 Newsletter Newsletter werden benutzt, um allen Mitgliedern einer Gruppe Informationen per zukommen zu lassen. So könnte z.B. das inf-schule-Team allen Interessierten eine schicken, wenn es Neuerungen in den Materialien gibt. >>> From: To: Subject: Neuerungen Hallo!...

21 21 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 = mail_to = 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 = passwort = '...' # wird nicht verraten empfaenger = mailserver = 'smtp.gmx.de' smtp = smtplib.SMTP(mailserver) smtp.login(benutzer, passwort) smtp.sendmail(benutzer, empfaenger, mail) smtp.quit()

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

23 23 Eine Liste dynamisch verändern Im Newsletter-Programm des MSS-Leiters werden die -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 -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 -Adresse muss gelöscht werden. Carla hat sich mal wieder eine neue -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.

24 24 Zugriff auf Listenelemente >>> listeAdressen = [ ] >>> listeAdressen >>> listeAdressen[0] >>> listeAdressen[1] >>> listeAdressen[6] >>> listeAdressen[7] Traceback (most recent call last):... listeAdressen[7] IndexError: list index out of range lesender Zugriff

25 25 Zugriff auf Listenelemente >>> listeAdressen = [ ] >>> listeAdressen >>> listeAdressen[1] = >>> listeAdressen schreibender Zugriff

26 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 27 Zugriff auf Teillisten >>> listeAdressen = [ ] 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 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 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 30 Listenelemente einfügen >>> listeAdressen = [ ] >>> listeAdressen >>> listeAdressen >>> listeAdressen = listeAdressen + >>> listeAdressen Das Einfügen von Listenelementen am Anfang und Ende einer Liste ist einfach. erzeugt eine neue Liste verändert die Liste

31 31 Listenelemente einfügen >>> listeAdressen = [ ] >>> listeAdressen[0:2] + + listeAdressen[2:7] >>> listeAdressen >>> listeAdressen = listeAdressen[0:2] + + listeAdressen[2:7] >>> listeAdressen 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 32 Listenelemente entfernen >>> listeAdressen = [ ] >>> listeAdressen = >>> listeAdressen[0:len(listeAdressen)-1] >>> listeAdressen >>> listeAdressen = listeAdressen[0:len(listeAdressen)-1] >>> listeAdressen 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 33 Listenelemente entfernen >>> listeAdressen = [ ] >>> listeAdressen = >>> listeAdressen[0:1] + listeAdressen[2:5] >>> listeAdressen >>> listeAdressen = listeAdressen[0:1] + listeAdressen[2:5] >>> listeAdressen 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 34 Eine Liste dynamisch verändern >>> listeAdressen = [ ] Aufgabe: Benutze die eingeführten Listenoperationen, um die Liste mit -Adressen in der gezeigten Weise zu verändern.

35 35 Listenoperationen selbst definieren Bei der automatisierten Verwaltung und Versendung von Newsletter ist es günstig, wenn unterschiedliche Operationen zur Verarbeitung von Listen mit -Adressen zur Verfügung stehen. Mit solchen Operationen sollte es z.B. möglich sein, auf einfache Weise neue - Adressen hinzuzufügen oder auch vohandene -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 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 37 Listenoperationen selbst definieren Testen im Ausführfenster: >>> adressen = [ ] >>> adressen) >>> adressen >>> adressen = adressen) >>> 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 = online.de', print(adressen) adressen = adressen) print(adressen) Testen mit einem Testprogramm:

38 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 39 Listenoperationen selbst definieren Aufgabe: Entwickle und teste analog Funktionen zur Realisierung der folgenden Listenoperationen:

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

41 41 Daten sichern Wenn man -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 = >>> adressen >>> ========================== RESTART ==================== >>> adressen Traceback (most recent call last): File " ", line 1, in adressen NameError: name 'adressen' is not defined

42 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 voraus datei = open(dateiname, 'r', encoding='iso ') text = datei.read() datei.close() return text def textInDateiSpeichern(dateiname, text): # speichert eine Zeichenkette in einer Datei # beachte: benutzt die Codierung iso datei = open(dateiname, 'w', encoding='iso ') datei.write(text) datei.close()

43 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 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 = [ ] text = textAusStringListe(listeAdressen) print(text)

45 45 Teil 3 Listen in Python

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

47 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 ziehung Element

48 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 ziehung

49 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 ziehung

50 50 Liste als sequentieller Datentyp >>> tippAnfang = [2, 6, 16, 40] >>> t = 25 >>> t in tippAnfang False >>> t = 40 >>> t in tippAnfang True 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 ziehung >>> ziehung = [25, 40, 44, 1, 45, 21] >>> for z in ziehung: print(z) 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 51 Eine Liste kopieren Wie kopiert man eine -Adressliste? Das ist gar nicht so einfach, wie der folgende Python- Dialog zeigt. >>> adressen1 = >>> adressen2 = adressen1 >>> adressen2[1] = >>> adressen2 >>> adressen1

52 52 Eine Liste kopieren Wie kopiert man eine -Adressliste? Das ist gar nicht so einfach, wie der folgende Python- Dialog zeigt. >>> adressen1 = >>> adressen2 = adressen1[:] >>> adressen2[1] = >>> adressen2 >>> adressen1

53 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]) >>> type([4, 13, 21, 33, 34, 42]) >>> [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) >>> type(liste1) >>> liste1 [4, 13, 21, 33, 34, 42]

54 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 55 Listen als Objekte Listen sind - in Python - Objekte der Klasse list. Listen bringen daher eine Reihe vordefinierter Operationen (Methoden) zur Verarbeitung mit. >>> adressen1 = >>> >>> listeAdressen >>> listeAdressen.insert(3, >>> listeAdressen >>> >>> listeAdressen >>> >>> listeAdressen

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

57 57 Teil 4 Fallstudie - Logdatei

58 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.: [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #... 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 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): [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #... Erläuterung: IP-Adresse des aufrufenden Hosts - Benutzernamer, sofern erforderlich - Passwort, falls erforderlich [24/Jul/2012:12:44: ] 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 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 [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #... [ ' [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" ', ' [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" ',... ] Aufgabe: Welchen Nachteil hätte diese Darstellung der Daten mit Hilfe von Zeichenketten?

61 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 [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #... >>> 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 62 Verwaltung mit geschachtelten Listen Aufgabe: (a) Wie würde man analog den Zeitstempel [21/Jan/2008:12:44: ] 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 [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #...

63 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 [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #... >>> 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 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] = 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

65 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 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? [24/Jul/2012:12:44: ] "GET /informatik/index.html HTTP/1.1" [24/Jul/2012:12:44: ] "GET /informatik/bild.png HTTP/1.1" #... Aufgabe: Ergänze selbst weitere Datensätze. Entwickle geeignete Funktionen zur Analyse der Daten einer Logdatei.

67 67 Teil 5 Fallstudie - Spiel des Lebens

68 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 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 70 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...

71 71 Algorithmus zur Spielsimulation Aufgabe: Wo steckt der Fehler? 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!

72 72 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!

73 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 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 5 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

75 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 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 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 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 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 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 79 Fachkonzept - Datenstruktur Datenstrukturen ermöglichen es, strukturierte Daten als Einheit zu verwalten. 'Losnummer' 'Superzahl' 'Ziehungstage' 'Laufzeit' 'Spiel 77' 'Super 6' 'Gluecksspirale' 'Sa + Mi' 1 False Datenmodellierung mit den Datenstrukturen "Liste" und "Tupel"

80 80 Fachkonzept - Datenstruktur 'Losnummer' 'Superzahl' 'Ziehungstage' 'Laufzeit' 'Spiel 77' 'Super 6' 'Gluecksspirale' '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', ), ('Superzahl', 4), ('Ziehungstage', 'Sa + Mi'), ('Laufzeit', 1), ('Spiel 77', False), ('Super 6', False), ('Gluecksspirale', False) ] Zentrale Datenstrukturen in Python sind Listen und Tupel.

81 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', ), ('Superzahl', 4), ('Ziehungstage', 'Sa + Mi'), ('Laufzeit', 1), ('Spiel 77', False), ('Super 6', False), ('Gluecksspirale', False) ] Datenmodellierung mit den Datenstrukturen "Liste" und "Tupel"

82 82 Übungen - Datenstruktur >>> lottoschein = [ [(3, 6, 19, 21, 38, 41), (4, 9, 17, 37, 38, 39), (18, 23, 28, 36, 38, 46)], ('Losnummer', ), ('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 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 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.


Herunterladen ppt "Datenverwaltung mit Datenstrukturen Klaus Becker 2012."

Ähnliche Präsentationen


Google-Anzeigen