18. Lektion: Das Filesystem

18. Lektion: Das Filesystem

Micropython richtet im Flash ein Filesystem ein, auf das genau so zugegriffen werden kann wie auf die Festplatte im PC.
Um auf eine Datei zugreifen zu können muss erst die Funktion open aufgerufen werden. Diese liefert einen Handler (hier f) zurück über den der Zugriff auf die Datei erfolgt. Welche Methoden stehen uns hier zur Verfügung?

>>> f = open('test_datei_01.txt', 'r')
>>> dir(f)
    ['__class__', '__enter__', '__exit__', '__next__', 'close', 'read', 'readinto', 'readline', 'write', '__del__', 'flush', 'readlines', 'seek', 'tell']
>>> f.close()

Die Methoden von f.

f.close()

Schließt eine geöffnete Datei. Ist unbedingt erforderlich!

f.read()

Liest die ganze Datei ein.

f.readinto()

Liest die Datei in ein Bytearray.

f.readline()

Liest eine Zeile der Datei ein.

f.write(n)

Schreibt n in die Datei.

f.flush()

Schreibt gepufferte Werte sofort in die Datei.

f.readlines()

Liest alle Zeilen einer Datei in eine Liste.

f.seek(n)

Ändert die Schreib-/Leseposition um n Position relativ zur aktuellen Position.

f.tell()

Zurück zur aktuellen Schreib-/Leseposition.

Nun aber wieder in die Praxis:

f = open('Dateiname', 'Zugriftsart')
...
f.close()

Wenn der Zugriff auf eine Datei erfolgt ist muss diese wieder geschlossen werden. Das geschieht mit der Methode .close().

In eine Datei schreiben

Wir werden uns zuerst ansehen, wie man eine Datei erzeugt und etwas hinein schreibt.

Zugriffsart

'r' = lesen
'w' = schreiben, löscht eine vorhandene Datei mit dem Namen
'a' = anhängen

# leere Datei anlegen

f = open('testdatei', 'w')
f.close()


# eine Datei anlegen und gleich etwas hinein schreiben

f = open('testdatei_01.txt', 'w')
f.write('Meine erste Datei im Filesystem')
f.close()

# Es können auch mehrere Zeilen geschrieben werden

f = open('testdatei_2.txt', 'w')
f.write('Meine erste Datei im Filesystem\n')
f.write('Ich kann auch mehrere Zeilen in die Datei schreiben\n')
f.write('Damit es wirklich Zeilen werden muss ich aber \\n an die Zeilen anhängen!')
f.close()

# Inhalte zu einer bestehenden Datei hinzufügen

f = open('testdatei_01.txt', 'a')
f.write('Jetzt steht noch mehr drin!')
f.close()

Übung:

Probiert den oben vorgestellt Code in der REPL selbst aus.

Aus einer Datei lesen

Der Prototyp des lesens aus einer Datei:

>>> f = open('testdatei', 'r')
>>> text = f.read()
>>> f.close()

Hier eine praktische Version:

>>> f = open('testdatei_2.txt','r')
>>> f.read()
    'Meine erste Datei im Filesystem\nIch kann auch mehrere Zeilen in die    # von mir umgebrochen
    Datei schreiben\nDamit es wirklich Zeilen werden muss ich aber \\n an die Zeilen anh\xe4ngen!'

>>> f.readlines()
[]                   # Der Lesezeiger zeigt auf das Ende der Datei
>>> f.close()

Mal sehen was f.readlines() so macht:

>>> f = open('testdatei_2.txt','r')
>>> datei_inhalt = f.readlines()
>>> datei_inhalt
    ['Meine erste Datei im Filesystem\n', 'Ich kann auch mehrere Zeilen in die     # von mir umgebrochen
    Datei schreiben\n', 'Damit es wirklich Zeilen werden muss ich aber \\n an die Zeilen anh\xe4ngen!']
>>> f.close()

Jetzt zeilenweise auslesen:

>>> f = open('testdatei_2.txt','r')
>>> for zeile in f:
        print(zeile)
    
    Meine erste Datei im Filesystem

    Ich kann auch mehrere Zeilen in die Datei schreiben

    Damit es wirklich Zeilen werden muss ich aber \n an die Zeilen anhängen!
>>> f.close()

So kann man es mit f.readline() falsch machen:

>>> f = open('testdatei_2.txt','r')
>>> for zeile in f:
        print(f.readline())     # So wird nur jede 2. Zeile gelesen!
    
    Ich kann auch mehrere Zeilen in die Datei schreiben


>>> f.close()

Aber so ist es richtig:

>>> f = open('testdatei_2.txt','r')
>>> while True:
        text = f.readline()
        if not text:
            break
        print(text)
    
    Meine erste Datei im Filesystem

    Ich kann auch mehrere Zeilen in die Datei schreiben

    Damit es wirklich Zeilen werden muss ich aber \n an die Zeilen anhängen!
>>> f.close()

Übung:

1. Vollzieht das Beispiel zum Lesen aus der Datei 'testdatei' nach.
2. Lege eine Datei mit dem Namen 'test_001.txt' an.
3. Füge den Text 'Hallo Micropython.' in die Datei ein.
4. Lese den Inhalt der Datei aus und zeige ihn an.
5. Füge zur Datei weiter den Text 'Schön, dass es Dich gibt!' so hinzu, das er als neue Zeile ausgegeben wird.
6. Lese die Datei aus und gebe den Inhalt aus.

Methoden zur Bearbeitung des Filesystems

Die Funktionen zum Umgang mit dem Filesystem befinden sich im Modul os:

os.chdir(path)

wechselt das aktuelle Verzeichnis

os.getcwd()

Zeigt das aktuelle Verzeichnis an

os.ilistdir([dir])

Diese Funktion gibt einen Iterator zurück, der dann Tupel liefert, die den Einträgen in dem Verzeichnis entsprechen, das sie auflistet. Ohne Argument listet sie das aktuelle Verzeichnis auf, andernfalls das durch dir angegebene Verzeichnis.
Die Tupel haben die Form (Name, Typ, Inode[, Größe]):

• name ist eine Zeichenkette (oder Bytes, wenn dir ein Bytes-Objekt ist) und ist der Name des Eintrags;
• type ist eine ganze Zahl, die den Typ des Eintrags angibt, mit 0x4000 (16384) für Verzeichnisse und 0x8000 (32768) für normale Dateien;
• inode ist eine ganze Zahl, die dem Inode der Datei entspricht und bei Dateisystemen, die keinen solchen Begriff haben, 0 sein kann.
  Einige Plattformen können ein 4-Tupel zurückgeben, das die Größe des Eintrags enthält. Bei Dateieinträgen ist size eine Ganzzahl, die die Größe der Datei angibt, oder -1, wenn sie unbekannt ist.
  Für Verzeichniseinträge ist ihre Bedeutung derzeit nicht definiert.

os.listdir([dir])

Wenn kein Argument angegeben wird, wird das aktuelle Verzeichnis aufgelistet. Andernfalls wird das angegebene Verzeichnis aufgelistet.

os.mkdir(path)

erzeugt ein neues Verzeichnis.

os.remove(path)

Entfernt eine Datei.

os.rmdir(path)

Entfernt ein Verzeichnis.

os.rename(old_path, new_path)

Ändert den Namen einer Datei.

Übung:

1. lege ein neues Verzeichnis 'Kurs' an.
2. wechsel in das Verzeichnis Kurs.
3. lege dort eine neue Datei an.
4. schreibe etwas in diese Datei.
5. lese den Inhalt aus und zeige ihn an.
6. wechsel wieder in das Verzeichnis darüber.
7. prüfe ob Du wirklich in dem Verzeichnis gelandet bist.
8. erstelle eine Variable die das Inhaltsverzeichnis enthält und gebe dieses aus.
9. wechsel wieder in das Verzeichnis Kurs.
10. lösche die dort angelegte Datei wieder
11. lösche das Verzeichnis Kurs.

Kontextmanager

with open('testdatei', 'w') as f:
    f.write('Text')

Die .close()-Methode ist hier nicht erforderlich. Das übernimmt with.

Variablen in einer Datei speichern

Es können nur Strings in einer Datei gespeichert werden.
Es gibt auch die Möglichkeit binäre Dateien anzulegen. Das behandeln wir hier aber nicht.
Wir wollen hier gleich mit einer Übung beginnen:

Übung:

1. lege einige Variablen verschiedenen Typs an.
2. versuche diese Variablen in eine Datei zu schreiben.

Das hat nur bei Stringvariablen funktioniert. Es gibt dafür aber eine Lösung:

Json

JSON (JavaScript Object Notation) ist aufgrund seiner Einfachheit und Kreuzkompatibilität mit mehreren Programmiersprachen ein weit verbreiteter Standard für den Datenaustausch. Aufgrund seiner menschlichen und maschinenlesbaren Natur ist es für viele Entwickler eine ideale Wahl.

In Micropython gibt es das Modul json.

>>> import json
>>> dir(json)
    ['__class__', '__name__', '__dict__', 'dump', 'dumps', 'load', 'loads']
>>> 

Python -> JSON

Ein Python Objekt wird so aufbereitet, dass es seriell in eine Datei geschrieben, oder über ein Netzwerk übertragen werden kann.

json.dump(obj, stream)

konvertiert ein Python-Objekt in ein Json-Objekt und gibt dieses direkt als Stream aus.

>>> import json

>>> test_dict = {'name': 'Peter', 'alter': 74, 'zustand': 'zufriedenstellend'}

>>> with open('json_test_01.json', 'w') as f:
        json.dump(test_dict, f)
    
>>> 

json.dumps(obj)

konvertiert ein Python-Objekt in ein Json-String.

>>> json_test_02 = json.dumps(test_dict)
>>> json_test_02
    '{"name": "Peter", "alter": 74, "zustand": "zufriedenstellend"}'
>>>

Hier wurde aus dem Dictionary ein String erstellt.

>>> type(test_dict)
<class 'dict'>
>>> type(json_test_02)
<class 'str'>
>>> 

Nachdem der Inhalt unseres Dictionaries als String vorliegt können wir diesen String z.B. in eine Datei schreiben.

JSON -> Python

Nachdem wir unser Dictionary in einen String verwandelt oder direkt in eine Datei geschrieben haben ist es interessant zu erfahren wie wir den Inhalt wieder für Micropython nutzbar machen können. Dazu dienen die Methoden load() und loads():

json.load(stream)

Holt ein Json-Objekt vom Stream und gibt ihn als Python-Objekt zurück.

>>> with open('json_test_01.json', 'r') as f:
        return_dict = json.load(f)
    
>>> return_dict
    {'zustand': 'zufriedenstellend', 'name': 'Peter', 'alter': 74}
>>> type(return_dict)
    <class 'dict'> 

json.loads(str)

Erzeugt aus einem Json-String ein Dictionary

>>> return_jason_test_02 = json.loads(json_test_02)
>>> return_jason_test_02
    {'zustand': 'zufriedenstellend', 'name': 'Peter', 'alter': 74}
>>> type(return_jason_test_02)
    <class 'dict'>
>>> type(json_test_02)
    <class 'str'>
>>> 

Einschränkungen

Json funktioniert mit Komplexen Zahlen (Typ complex). Mengen (Typ set) werden in dictionaries umgewandelt, sind also unbrauchbar. Tupel (Typ tuple) werden als Listen zurückgegeben.

>>> test_tuple_01 = (1,2,3)
>>> json_tuple_01 = json.dumps(test_tuple_01)
>>> type(test_tuple_01)
    <class 'tuple'>
>>> type(json_tuple_01)
    <class 'str'>
>>> return_tuple_01 = json.loads(json_tuple_01)
>>> return_tuple_01
    [1, 2, 3]
>>> type(return_tuple_01)
    <class 'list'>
>>> 

Jetzt versuchen wir es mal mit einer Menge:

>>> test_menge = {1,2,3}
>>> test_menge
    {3, 1, 2}
>>> type(test_menge)
    <class 'set'>
>>> json_menge = json.dumps(test_menge)
>>> json_menge
    '{3, 1, 2}'
>>> type(json_menge)
    <class 'str'>
>>> return_menge = json.loads(json_menge)
>>> return_menge
    {3: 1}
>>> type(return_menge)
    <class 'dict'>
>>> 

Navigation

Zurück zu Micropython Kurs 2023 - Teil 1
Zurück zur "Micropython Kurs 2023" Startseite
Zurück zur Programmieren Startseite
Zurück zur Wiki Startseite