Dateien lesen und schreiben

Dateien

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 Zeil. 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()
Die Methode rstrip() im obigen Beisiel dient dazu Leerzeichen (Whitespaces) am rechten Ende des Strings zu entfernen.

Schreiben in eine Datei

Schreiben in eine Datei lässt sich analog bewerkstelligen. Beim Öffnen der Datei benutzt man lediglich "w" statt "r" als Modus. Zum Schreiben der Daten in die Datei benutzt man die Methode write des Dateiobjektes.
Beispiel:

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

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:
>>> poem = open("ad_lesbiam.txt").readlines()
>>> print(poem)
['V. ad Lesbiam \n', '\n', 'VIVAMUS mea Lesbia, atque amemus,\n', 'rumoresque senum severiorum\n', 'omnes unius aestimemus assis!\n', 'soles occidere et redire possunt:\n', 'nobis cum semel occidit breuis lux,\n', 'nox est perpetua una dormienda.\n', 'da mi basia mille, deinde centum,\n', 'dein mille altera, dein secunda centum,\n', 'deinde usque altera mille, deinde centum.\n', 'dein, cum milia multa fecerimus,\n', 'conturbabimus illa, ne sciamus,\n', 'aut ne quis malus inuidere possit,\n', 'cum tantum sciat esse basiorum.\n', '(GAIUS VALERIUS CATULLUS)']
>>> print(poem[2])
VIVAMUS mea Lesbia, atque amemus,
Im obigen Beispiel wurde das ganze Gedicht in eine Liste namens poem geladen. Wir können nun biespielsweise 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:
>>> poem = open("ad_lesbiam.txt").read()
>>> print(poem[16:34])
VIVAMUS mea Lesbia
>>> type(poem)

>>> 



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:

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:
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
>>> cities = ["Bern", "Basel","St. Gallen", "Zürich"]
>>> fh = open("data.pkl","bw")
>>> pickle.dump(cities,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 eingelen. Wir zeigen die Funktionsweise des Einlesens im folgenden Beispiel:
>>> import pickle
>>> f = open("data.pkl","rb")
>>> staedte = pickle.load(f)
>>> print(staedte)
['Bern', 'Basel', 'St. Gallen', 'Zürich']
>>> 
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: 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)
['Python', 'Perl', 'C++', 'Java', 'Lisp'] ['Jython', 'IronPython', 'CPython']
>>> 


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 sie ,,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["street"] = "Fleet Str"
>>> s["city"] = "London"
>>> for key in s:
...     print(key)
... 
city
street


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:

$ python3
Python 3.2.3 (default, Feb 28 2014, 00:22:33) 
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import shelve
>>> s = shelve.open("MyShelve")
>>> s["street"]
'Fleet Str'
>>> s["city"]
'London'
>>> 


Man kann ein shelve-Objekt auch einfach mit dem dict-Casting-Operator in ein Dictionary wandeln:

>>> s
≤shelve.DbfilenameShelf object at 0xb7133dcc>
>>> dict(s)
{'city': 'London', 'street': 'Fleet Str'}
>>> 


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"] = {"first":"Mike", "last":"Miller", "phone":"4689"}
>>> tele["Steve"] = {"first":"Stephan", "last":"Burns", "phone":"8745"}
>>> tele["Eve"] = {"first":"Eve", "last":"Naomi", "phone":"9069"}
>>> tele["Eve"]["phone"]
'9069'


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:

$ python3
Python 3.2.3 (default, Feb 28 2014, 00:22:33) 
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import shelve
>>> tele = shelve.open("MyPhoneBook")
>>> tele["Steve"]["phone"]
'8745'
>>> 



Übungen



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


    Anschließend soll die Liste zur späteren Benutzung mit Hilfe des Pickle-Modules abgespeichert werden. Wir werden diese Datei in unserem Kapitel über numpyNumpy dtype benutzen.


Lösungen zu unseren Übungen


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