18. Lektion: Das FilesystemAus Attraktor WikiInhaltsverzeichnis18. Lektion: Das FilesystemMicropython richtet im Flash ein Filesystem ein, auf das genau so zugegriffen werden kann wie auf die Festplatte im PC.
>>> 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.
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 In eine Datei schreibenWir werden uns zuerst ansehen, wie man eine Datei erzeugt und etwas hinein schreibt.
# 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 lesenDer 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:
Methoden zur Bearbeitung des FilesystemsDie Funktionen zum Umgang mit dem Filesystem befinden sich im Modul
Übung:
Kontextmanager
with open('testdatei', 'w') as f:
f.write('Text')
Die .close()-Methode ist hier nicht erforderlich. Das übernimmt with. Variablen in einer Datei speichernEs können nur Strings in einer Datei gespeichert werden. Übung:
Das hat nur bei Stringvariablen funktioniert. Es gibt dafür aber eine Lösung: JsonJSON (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 -> JSONEin Python Objekt wird so aufbereitet, dass es seriell in eine Datei geschrieben, oder über ein Netzwerk übertragen werden kann.
>>> 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_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 -> PythonNachdem 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():
>>> 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'>
>>> 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änkungenJson 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'>
>>>
Zurück zu Micropython Kurs 2023 - Teil 1 |