Informationen zum Buch
Dateien lesen und schreiben
Dateien
Man findet wohl kaum jemanden im 21. Jahrhundert, der nicht wüsste, was eine Datei ist. Auch wenn nicht jeder eine exakte Definition geben könnte, also beispielsweise: Eine Datei ist eine Menge von logisch zusammenhängenden und meist sequentiell geordneten Daten, die auf einem Speichermedium dauerhaft gespeichert werden und mittels eines Bezeichners bzw. Namens wieder identifizierbar und damit ansprechbar sind. Die Daten einer Datei existieren also über die Laufzeit eines Programms hinaus. Deswegen werden sie auch als nicht flüchtig oder persistent bezeichnet.
Auch wenn es so scheinen mag: Das Wort Datei ist kein altes deutsches Wort. Es ist eine künstliche Schöpfung des Deutschen Institutes für Normung (DIN). Die beiden Wörter Daten und Kartei wurden zu dem neuen Wort Datei verschmolzen. Ein solches Kunstwort wird übrigens als Portmanteau oder Kofferwort bezeichnet.
Der Inhalt jeder Datei besteht grundsätzlich aus einer eindimensionalen Aneinanderreihung von Bits, die normalerweise in Byte-Blöcken zusammengefasst interpretiert werden. Die Bytes erhalten erst durch Anwendungsprogramme und das Betriebssystem eine Bedeutung. Sie entscheiden also, ob es sich um eine Textdatei, ein ausführbares Programm oder beispielsweise ein Musikstück oder ein Bild handelt.
Text aus einer Datei lesen
Unser erstes Beispiel zeigt, wie man Daten aus einer Datei ausliest. Um dies tun zu können, muss man zuerst die Datei zum Lesen öffnen. Dazu benötigt man die open()-Funktion. Mit der open-Funktion erzeugt man ein Dateiobjekt und liefert eine Referenz auf dieses Objekt als Ergebniswert zurück. Die open-Funktion erwartet zwei Parameter: Einen Dateinamen, gegebenenfalls mit einem Pfad, und optional kann man den Modus angeben:
open(filename,mode)Im folgenden Beispiel öffnen wir die Datei "yellow_snow.txt" zum Lesen, da der Modus auf "r" (read) gesetzt ist:
fobj = open("yellow_snow.txt", "r")
Alternativ hätte man die obige Anweisung auch ohne die Angabe des "r" schreiben können. Fehlt der Modus, wird automatisch lesen zum Defaultwert:
fobj = open("yellow_snow.txt")
Nach der Bearbeitung einer Datei, muss diese wieder schlossen werden. Dies geschieht mit der Methode close:
fobj.close()
Sehr häufig bearbeitet man eine Datei zeilenweise, d.h. man liest eine Datei Zeile für Zeile. Das folgende Programmstück demonstriert, wie man eine Datei zeilenweise einliest. Jede Zeile wird dann mit print ausgegeben. Die String-Methode rstrip() entfernt vor der Ausgabe etwaige Leerzeichen und Newlines vom rechten Rand:
fobj = open("yellow_snow.txt")
for line in fobj:
print(line.rstrip())
fobj.close()
fobj_in = open("yellow_snow.txt")
fobj_out = open("yellow_snow2.txt","w")
i = 1
for line in fobj_in:
print(line.rstrip())
fobj_out.write(str(i) + ": " + line)
i = i + 1
fobj_in.close()
fobj_out.close()
Es muss darauf geachtet werden, dass die Datei-Objekte immer mit close() ordnungsgemäß geschlossen werden. Man riskiert sonst, dass die Daten in der Datei nicht konsistent sind. Oft begegnet man dem with-Statement. Dies hat den Vorteil, dass das im darauffolgenden Block verwendete Datei-Objekt automatisch geschlossen wird.
with open("example.txt", "w") as fh:
fh.write("To write or not to write\nthat is the question!\n")
Eine Sache ist noch zu beachten: Was ist, wenn wir ein Datei-Objekt versehentlich zum Schreiben, also mit "w", öffnen, und die Datei existiert bereits? Wenn der Inhalt der Datei nicht wichtig ist, oder es eine Sicherungskopie gibt, dann haben Sie Glück. Ansonsten haben Sie ein Problem, denn sobald open(..., "w") ausgeführt wird, wird die bestehende Datei gelöscht. In einigen Fällen ist das so gewollt. Allerdings gibt es auch andere Anwendungsfälle, wie z.B. Log-Files, deren Inhalt einfach erweitert werden soll.
Um den Inhalt zu erweitern muss der Parameter "a" genutzt werden, statt "w". In einem Rutsch lesen Bis jetzt haben wir Dateien Zeile für Zeile mit Schleifen verarbeitet. Aber es kommt öfters vor, dass man eine Datei gerne in eine komplette Datenstruktur einlesen will, z.B. einen String oder eine Liste. Auf diese Art kann die Datei schnell wieder geschlossen werden und man arbeitet anschließend nur noch auf der Datenstruktur weiter:
Gedicht = open("ad_lesbiam.txt").readlines()
print(Gedicht)
print(Gedicht[2])
Im obigen Beispiel wurde das ganze Gedicht in eine Liste namens poem geladen. Wir können nun beispielsweise die dritte Zeile mit poem[2] ansprechen.
Eine andere angenehme Methode eine Datei einzulesen bietet die Methode read() von open. Mit dieser Methode kann man eine ganze Datei in einen String einlesen, wie wir im folgenden Beispiel zeigen:
Gedicht = open("ad_lesbiam.txt").read()
print(Gedicht[16:34])
type(Gedicht)
Persistente Daten
Vermeidung von Datenverlust Im Folgenden geht es darum, Wege zu zeigen wie man Programmdaten über das Programmende oder den Programmabbruch hinaus speichern kann. Man bezeichnet dies in der Informatik als persistente Daten. Darunter versteht man, dass die Daten eines Programmes auch nach dem kontrollierten oder auch unvorhergesehenem Ende bei einem erneuten Programmstart wieder zur Verfügung stehen. Daten, die nur im Hauptspeicher des Computers existieren, werden als flüchtige oder transiente Daten bezeichnet, da sie bei einem erneuten Programmstart nicht mehr zur Verfügung stehen.
Zur Generierung von persistenten Daten gibt es verschiedene Möglichkeiten:
- Manuelle Speicherung in einer Datei.
Nicht zu empfehlen, da man dann die komplette Serialisierung der Daten selbst vornehmen muss. - marshal-Modul
Ähnlich wie das pickle-Modul. Wir werden dieses Modul jedoch nicht behandeln, da allgemein aus verschiedenen Gründen empfohlen wird pickle zu verwenden. - pickle-Modul
Wir werden im folgenden näher auf dieses Modul eingehen. - shelve-Modul
Shelve baut auf pickle auf und bietet eine Dictionary-ähnliche Struktur!
Pickle-Modul
Beim Programmieren kommt es natürlich immer wieder mal vor, dass man in die Klemme gerät, aber bei Python ist das wahrscheinlich - hoffen wir - seltener als in anderen Sprachen der Fall. In die Klemme geraten heißt im Englischen "to get oneself into a pickle". Aber "to pickle" bedeutet eigentlich einlegen oder pökeln, z.B. saure Gurken. Aber was hat nun das Pökeln von sauren Gurken mit Python zu tun? Naja ganz einfach: Python hat ein Modul, was "pickle" heißt und mit dem kann man Python-Objekte gewissermaßen einlegen, um sie später, also in anderen Sitzungen oder anderen Programmläufen wieder zu benutzen. Aber jetzt wollen wir wieder seriös werden: Mit dem Modul pickle (dt. einlegen) lassen sich Objekte serialisiert abspeichern und zwar so, dass sie später wieder deserialisiert werden können. Dazu dient die Methode dump, die in ihrer allgemeinen Syntax wie folgt aussieht:
pickle.dump(obj, file[,protocol, *, fix_imports=True])
dump() schreibt eine gepickelte Darstellung des Objectes obj in das Dateiobjekt file. Das optionale Argument für das Protokollargument steuert die Art der Ausgabe:
Protokollversion 0 ist die originale Ablageart von Python, d.h. vor Python3. Dabei handelt es sich um ein für Menschen lesbares Format. Dieser Modus ist abwärts kompatibel mit früheren Pythonversionen.
Protokollversion 1 benutzt das alte Binärformat. Dieser Modus ist ebenfalls abwärts kompatibel mit früheren Pythonversionen.
Protokollversion 2 wurde mit 2.3. eingeführt. Es stellt ein effizienteres "Pickling" zur Verfügung.
Protokollversion 3 wurde mit Python 3.0 eingeführt. Dieser Modus bietet einen hervorragenden Bytes-Modus. Dateien, die in diesem Modus erzeugt werden, können nicht mehr in Python 2.x mit dem zugehörigen Pickle-Modul bearbeitet werden. Es handelt sich hierbei um den von Python 3.x empfohlenen Modus. Er stellt auch den Defaultwert dar.
Wird der Parameter fix_imports auf True gesetzt und wird als Protokol ein Wert kleiner als 3 verwendet, versucht pickle die neuen Python3-Namen auf die alten Modulnamen, also die von Python2, abzubilden. Ziel ist es, dass dass die gepickelten Daten von Python2 gelesen werden können.
Ein einfaches Beispiel:
import pickle
staedte = ["Bern", "Basel","St. Gallen", "Zürich"]
fh = open("data.pkl","bw")
pickle.dump(staedte,fh)
fh.close()
Objekte, die mit pickle.dump() in eine Datei geschrieben worden sind, können mit der Pickle-Methode pickle.load(file) wieder eingelesen werden. pickle.load erkennt automatisch in welchem Format eine Datei erstellt worden ist. Die Datei data.pkl kann wieder in Python eingelesen werden. Dies kann in der gleichen Session oder dem gleichen Programm geschehen, aber meistens werden die Daten natürlich in einem erneuten Programmlauf oder in einem anderen Programm eingelesen. Wir zeigen die Funktionsweise des Einlesens im folgenden Beispiel:
import pickle
f = open("data.pkl","rb")
staedte = pickle.load(f)
print(staedte)
Da nur die Objekte selbst und nicht ihre Namen gespeichert worden sind, müssen wir das Ergebnis von pickle.load() wieder einer Variablen, - wie in obigem Beispiel gezeigt, - zuweisen.
Es stellt sich die Frage, welche Art von Daten man eigentlich pickeln kann? Im Prinzip alles, was man sich vorstellen kann:
- Alle Python-Basistypen, wie Booleans, Integers, Floats, Komplexe Zahlen, Strings, Byte-Arrays und Byte-Objekte und natürlich None.
- Listen und Tupels, Mengen und Dictionaries
- Beliebige Kombinationen der beiden vorigen Gruppen
- Außerdem können auch Funktionen, Klassen und Instanzen unter gewissen Bedingungen gepickelt werden.
- file-Objekte lassen sich nicht pickeln.
In unserem Beispiel haben wir nur ein Objekt gepickelt, d.h. eine Liste von Städten. Wie sieht es aber aus, wenn wir mehrere Objekte gleichzeitig pickeln wollen? Ganz einfach: Man verpackt sie in ein Objekt, meistens ein Tupel. Im folgenden Beispiel benutzen wir zwei Listen "programmiersprachen" und "python_dialekte":
import pickle
fh = open("data.pkl","bw")
programmiersprachen = ["Python", "Perl", "C++", "Java", "Lisp"]
python_dialekte = ["Jython", "IronPython", "CPython"]
pickle_object = (programmiersprachen, python_dialekte)
pickle.dump(pickle_object,fh)
fh.close()
Obige gepickelte Datei können wir so einlesen, dass wir die beiden Listen wieder trennen können:
import pickle
f = open("data.pkl","rb")
(sprachen, dialekte) = pickle.load(f)
print(sprachen, dialekte)
shelve-Modul
Hat man das shelve-Modul importiert und beginnt die englische Beschreibung unter help(shelve) zu lesen, wundert man sich vielleicht über die Rechtschreibung. Dort steht: ,,A 'shelf' is a persistent, dictionary-like object.'' Wir haben also ein Modul, was sich ,,shelve'' nennt und ein dictionary-ähnliches Objekt, was ,,shelf'' geschrieben wird. Es handelt sich nicht um einen Verschreiber. Das Wort ,,shelf'' ist ein Substantiv und bedeutet,,Regal'' oder ,,Ablage'', während ,,shelve'' als Verb benutzt wird und meistens bedeutet, dass man etwas in ein Regal stellt. Nach dieser kurzen englischen Grammatikauffrischung sind wir auch schon der Aufgabe des shelve-Modules näher gekommen. shelve funktioniert wie ein Bücherregal, nur dass wir statt ,,Büchern'' Daten haben und unser Regal eine Datei ist.
Prinzipiell verhält sich ein shelf-Objekt wie ein Python-Dictionary. Allerdings gibt es zwei wesentliche Unterschiede. Bevor man ein shelf benutzen kann, muss man es öffnen, d.h. man öffnet die Datei, und nach der Benutzung muss man die Datei wieder schließen. Außerdem gibt es eine Einschränkung bzgl. der Schlüssel, die man verwenden kann. Während ein Python-Dictionary beliebige unveränderliche Datentypen als Keys verwenden kann, also beispielsweise Integer, Floats, Strings und Tupel, kann ein shelf nur Strings als Keys verwenden. Dies ist allerdings nur eine geringe Beschränkung der Nutzbarkeit. Für die Werte gibt es allerdings keine Einschränkungen.
Das Shelve-Modul lässt sich sehr einfach benutzen. Man importiert zuerst das Modul selbst, und dann öffnet man eine Datei mit dem zu verwendenden Shelf-Objekt unter Verwendung der shelve-Methode ,,open'':
import shelve
s = shelve.open("MyShelve")
Falls bereits eine Datei "MyShelve" existiert, versucht die open-Methode diese zu öffnen. Falls es sich um eine Datei handelt, die nicht unter Verwendung des shelve-Modules angelegt worden ist, erfolgt eine Fehlermeldung, da es sich dann nicht um Daten im korrekten Format handelt. Falls die Datei noch nicht existiert, wird eine Datei im korrekten Format angelegt.
Jetzt kann man mit s arbeiten wie mit einem Dictionary:
s["strasse"] = "Fleet Str"
s["stadt"] = "London"
for key in s:
print(key)
Bevor man das Programm verlässt, in dem man mit einem shelf-Objekt arbeitet, sollte man das shelf-Objekt wieder schließen.
s.close()
Wir können nun die Shelf-Datei in einem beliebigen Python-Programm oder in der interaktiven Shell wieder benutzen und die alten Daten stehen sofort zur Verfügung:
import shelve
s = shelve.open("MyShelve")
s["strasse"]
s["stadt"]
Man kann ein shelve-Objekt auch einfach mit dem dict-Casting-Operator in ein Dictionary wandeln:
s
dict(s)
Im folgenden Beispiel demonstrieren wir, dass wir in einem Shelf-Eintrag auch komplexe Objekte, wie beispielsweise Dictionaries abspeichern können:
import shelve
tele = shelve.open("MyPhoneBook")
tele["Mike"] = {"Vorname":"Mike", "Nachname":"Miller", "Telefon":"4689"}
tele["Steve"] = {"Vorname":"Stephan", "Nachnale":"Burns", "Telefon":"8745"}
tele["Eve"] = {"Vorname":"Eve", "Nachname":"Naomi", "Telefon":"9069"}
tele["Eve"]["Telefon"]
Die Daten sind auch in diesem Fall persistent gespeichert, d.h. man kann Sie auch wieder in einem späteren Programmlauf benutzen. Alles was man tun muss, ist die Datei MyPhoneBook zu öffnen:
import shelve
tele = shelve.open("MyPhoneBook")
tele["Steve"]["Telefon"]
Übungen
Die Datei cities_and_times.txt enthält Städtenamen und Zeiten. Jede Zeile enthält als ersten Eintrag den Namen einer Stadt, gefolgt von einem Wochentag und einer Zeitangabe in der Form hh:mm. Lesen Sie die Datei ein und erzeugen Sie eine alphabetisch geordnete Liste der Form
[('Amsterdam', 'Sun', (8, 52)), ('Anchorage', 'Sat', (23, 52)), ('Ankara', 'Sun', (10, 52)), ('Athens', 'Sun', (9, 52)), ('Atlanta', 'Sun', (2, 52)), ('Auckland', 'Sun', (20, 52)), ('Barcelona', 'Sun', (8, 52)), ('Beirut', 'Sun', (9, 52)),
...
('Toronto', 'Sun', (2, 52)), ('Vancouver', 'Sun', (0, 52)), ('Vienna', 'Sun', (8, 52)), ('Warsaw', 'Sun', (8, 52)), ('Washington DC', 'Sun', (2, 52)), ('Winnipeg', 'Sun', (1, 52)), ('Zurich', 'Sun', (8, 52))]import pickle
lines = open("cities_and_times.txt").readlines()
lines.sort()
cities = []
for line in lines:
*city, day, time = line.split()
hours, minutes = time.split(":")
cities.append((" ".join(city), day, (int(hours), int(minutes)) ))
fh = open("cities_and_times.pkl", "bw")
pickle.dump(cities, fh)
Städtenamen können mehrere Wörter beinhalten. Aus diesem Grund verwenden wir ein Sternchen an der Stelle, an der eine Zeile aufgeteilt wird. Somit wird city zu einer Liste mit den Wörtern der Stadt. z.B. ["Salt“,"Lake","City"]. " ",join(city) verwandelt die Liste dann in den eigentlichen String. Hier: "Salt Lake City"