Datenverwaltung mit Datenstrukturen

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

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

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

8. 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 die Elemente durchlaufen # Initialisierung ziehung = [25, 40, 44, 1, 45, 21] # Verarbeitung und Ausgabe for z in ziehung: print(z) Aufgabe:Teste auch dieses Programm. Was leistet es?

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

10. 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 = [ True , False, False, False, False, False, False, False, False, False, False, True , False, False, ... ] # Verarbeitung richtige = 0 # ... # Ausgabe print(richtige)

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 Der folgende Python-Dialog zeigt, wie man eine Liste zur Verwaltung der Zahlen eines Tipps schrittweise aufbauen kann. Listen aneinanderhängen >>> 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 ... Aufgabe: Analysiere den gezeigten Python-Dialog. Stelle Vermutungen auf, was an Stelle der drei Punkte ... steht. Überprüfe deine Vermutung.

13. 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?

14. 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 for i in range(49): 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?

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.de To: alex2101@web.de Subject: 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 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()

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

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

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

27. 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[:] ...

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

29. 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 = liste + ['t'] >>> liste ... >>> liste = ['o'] + liste >>> liste ... >>> liste = liste + ['a', 'g'] >>> liste ... >>> liste = ['M'] + liste >>> liste ...

30. 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 ['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'] erzeugt eine neue Liste verändert die Liste

31. 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] >>> 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'] erzeugt eine neue Liste verändert die Liste

32. 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] >>> listeAdressen ['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de'] erzeugt eine neue Liste verändert die Liste

33. 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] >>> listeAdressen ['amueller@gmx.de', 'herbert.fluhr@web.de', 'petra@dahm.de'] erzeugt eine neue Liste verändert die Liste

34. 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. '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' ] 'carla_meier@online.de' 'mia@miaweb.de'

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

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

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

47. 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 40 1 45 21 25 44 ziehung 1 3 4 5 0 2 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 >>> L [10, 15, 21, 33, 36, 40] lesender Zugriff schreibender Zugriff

48. Liste als sequentieller Datentyp 40 1 45 21 25 44 ziehung 1 3 4 5 0 2 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

49. Liste als sequentieller Datentyp 40 1 45 21 25 44 ziehung 1 3 4 5 0 2 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. >>> 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([]) 0 Länge Konkatenation

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