[Einführung in Python3, Tag 17] Kapitel 8 Datenziele (8.1-8.2.5)

8.1 Dateieingabe / -ausgabe

--Öffnen Sie die Datei mit fileobj = open (Dateiname, Modus). --fileobj ist das Objekt der Datei, die von open () zurückgegeben wird. --Dateiname ist der Dateiname --Wählen Sie, was Sie mit der Datei machen möchten. --r wird gelesen, w wird geschrieben und kann überschrieben und neu erstellt werden, x wird geschrieben, aber nur, wenn die Datei nicht vorhanden ist. Das zweite Zeichen von --mode gibt den Dateityp an. t bedeutet Text und b bedeutet Binär.

8.1.1 Schreiben in eine Textdatei mit write ()

>>> poem = """There was a young lady named Bright,
... Whose speed was far faster than light,
... She started one day,
... In a relative way,
... And returned on the previous night."""
>>> len(poem)
151

#write()Die Funktion gibt die Anzahl der geschriebenen Bytes zurück.
>>> f=open("relatibity","wt")
>>> f.write(poem)
151
>>> f.close()

#print()Sie können jedoch in eine Textdatei schreiben.
#print()Fügt nach jedem Argument ein Leerzeichen und am Ende des Ganzen einen Zeilenumbruch hinzu.
>>> f=open("relatibity","wt")
>>> print(poem,file=f)
>>> f.close()

#print()Schreiben()So arbeiten wie sep,Verwenden Sie end.
#sep:Separator. Standardmäßig Leerzeichen(" ")werden.
#end:Die letzte Zeichenfolge. Pausen werden standardmäßig unterbrochen("\n")werden.
>>> f=open("relatibity","wt")
>>> print(poem,file=f,sep="",end="")
>>> f.close()

#Wenn die Quellzeichenfolge sehr groß ist, kann sie in Blöcke aufgeteilt und in die Datei geschrieben werden.
>>> f=open("relatibity","wt")
>>> size=len(poem)
>>> offset=0
>>> chunk=100
>>> while True:
...     if offset>size:
...         break
...     f.write(poem[offset:offset+chunk])
...     offset+=chunk
... 
100
51
>>> f.close()

#Eine Dateibeschädigung kann verhindert werden, indem ein Überschreiben im x-Modus verhindert wird.
>>> f=open("relatibity","xt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: 'relatibity'

#Es kann auch als Ausnahmebehandlungsroutine verwendet werden.
>>> try:
...     f=open("relatibity","xt")
...     f.write("stomp stomp stomp")
... except FileExistsError:
...     print("relativity already exists!. That was a close one.")
... 
relativity already exists!. That was a close one.

8.1.2 Lesen von Textdateien mit read (), readline (), headlines ()

#Die gesamte Datei kann auf einmal gelesen werden.
>>> fin=open("relatibity","rt")
>>> poem=fin.read()
>>> fin.close()
>>> len(poem)
151

#read()Sie können die Menge der gleichzeitig zurückgegebenen Daten begrenzen, indem Sie die Anzahl der Zeichen in das Argument von eingeben.
#Lesen Sie mehr, nachdem Sie alle Dateien gelesen haben()Wenn Sie aufrufen, eine leere Zeichenfolge("")Ist zurück gekommen. → wenn nicht f:Wird als falsch bewertet.
>>> poem=""
>>> fin=open("relatibity","rt")
>>> chunk=100
>>> while True:
...     f=fin.read(chunk)
...     if not f:
...         break
...     poem+=f
... 
>>> fin.close()
>>> len(poem)
151

#readline()Sie können die Datei zeilenweise lesen.
#Lesen Sie alle Dateien()Ebenso wird eine leere Zeichenfolge zurückgegeben und als False ausgewertet.
>>> poem=""
>>> fin=open("relatibity","rt")
>>> while True:
...     line=fin.readline()
...     if not line:
...         break
...     poem+=line
... 
>>> fin.close()
>>> len(poem)
151

#Es kann leicht gelesen werden, indem es mit einem Iterator verwendet wird.
>>> poem=""
>>> fin=open("relatibity","rt")
>>> for line in fin:
...     poem+=line
... 
>>> fin.close()
>>> len(poem)
151

#readlines()Liest jeweils eine Zeile und gibt eine Liste einzeiliger Zeichenfolgen zurück.
>>> fin=open("relativity","rt")
>>> lines=fin.readlines()
>>> fin.close()
>>> for line in lines:
...      print(line,end="")
... 
There was a young lady named Bright,
Whose speed was far faster than light,
She started one day,
In a relative way,
And returned on the previous night.>>> 

8.1.3 Schreiben einer Binärdatei mit write ()

• Wenn Sie der Moduszeichenfolge "b" hinzufügen, wird die Datei im Binärmodus geöffnet. In diesem Fall lesen und schreiben Sie Bytes anstelle von Zeichenfolgen.

#Lassen Sie uns 256 Bytes von 0 bis 255 generieren.
>>> bdata=bytes(range(0,256))
>>> len(bdata)
256
>>> f=open("bfile","wb")
>>> f.write(bdata)
256
>>> f.close()

#Es ist auch möglich, in Blockeinheiten zu schreiben, wie im Fall von Text.
>>> f=open("bfile","wb")
>>> size=len(bdata)
>>> offset=0
>>> chunk=100
>>> while True:
...     if offset>size:
...         break
...     f.write(bdata[offset:offset+chunk])
...     offset+=chunk
... 
100
100
56
>>> f.close

8.1.4 Binärdatei mit read () lesen

#"rb"Öffnen Sie es einfach als.
>>> f=open("bfile","rb")
>>> bdata=f.read()
>>> len(bdata)
256
>>> f.close()

8.1.5 mit automatischem Schließen von Dateien

--with Wenn der folgende Kontextblock endet, wird die Datei automatisch geschlossen. --Verwenden Sie in Form eines Ausdrucks als Variable.

>>> with open("relatibity","wt") as f:
...     f.write(poem)
... 
151

8.1.6 Neupositionierung mit seek ()

• Die Funktion tell () gibt den Offset vom Anfang der Datei an Ihren aktuellen Speicherort in Bytes zurück.

• Die Funktion seek () kann die Position eines Dateiobjekts ändern. --Verwenden Sie f.seek (Offset, woher), um die Position des Dateiobjekts zu ändern. Es ist auch im Standard-Betriebssystemmodul definiert.

• Die Dateiposition wird berechnet, indem der Versatzwert zum Referenzpunkt hinzugefügt wird. --Wählen Sie den Referenzpunkt mit dem Argument woher. Wenn es 0 ist, bewegt es sich vom Anfang zur Versatzposition, wenn es 1 ist, bewegt es sich von der aktuellen Position zur Versatzbyteposition, und wenn es 2 ist, bewegt es sich vom Ende zur Versatzbyteposition. --whence ist optional und der Standardwert ist 0, was bedeutet, dass der Anfang der Datei als Referenzpunkt verwendet wird.

>>> f=open("bfile","rb")
>>> f.tell()
0

#seek()Verwenden Sie diese Option, um zum letzten Byte der Datei zu wechseln.
#Ort(255)Ich ging zu und las von dort die Rückseite. → Das letzte 1 Byte wurde gelesen.
#Ein Bild, das sich zwischen 254 und 255 befindet und beim letzten Laden 255 geladen hat.
>>> f.seek(255)
255
>>> b=f.read()
>>> len(b)
1
#seek()Gibt auch den Versatz nach dem Verschieben zurück.
>>> b[0]
255


>>> import os
>>> os.SEEK_SET
0
>>> os.SEEK_CUR
1
>>> os.SEEK_END
2


>>> f=open("bfile","rb")
#Vom Ende-In eine um 1 versetzte Position verschoben.
>>> f.seek(-1,2)
255
#Gibt den Offset in Bytes vom Anfang der Datei zurück.
>>> f.tell()
255
>>> b=f.read()
>>> len(b)
1
>>> b[0]
255

#Verschieben Sie vom Anfang der Datei zu den letzten 2 Bytes
#Bild zwischen 253 und 254
>>> f=open("bfile","rb")
>>> f.seek(254,0)
254
>>> f.tell()
254
#Verschieben Sie von 2 Byte vor dem Ende der Datei auf 1 Byte vor
#Bild zwischen 254 und 255
>>> f.seek(1,1)
255
>>> f.tell()
255
>>> b=f.read()
>>> len(b)
1
>>> b[0]
255

8.2 Strukturierte Textdatei

• Es gibt die folgenden Methoden zum Erstellen von Strukturdaten.
• Separator, Separator. Trennen Sie mit Tabulatoren ("\ t"), Kommas (","), vertikalen Balken ("|") usw. CSV-Format.
• Trennen Sie Tags mit "<" und ">". XML und HTML entsprechen dem. ――Dinge, die Symbole voll ausnutzen. JSON ist so. --Einzug. Zum Beispiel YAML.

CSV

--Die durch Trennzeichen in Felder getrennten Dateien werden als Datenaustauschformat für Tabellenkalkulationen und Datenbanken verwendet.

• Einige Dateien verwenden Escape-Sequenzen. Wenn das Trennzeichen wahrscheinlich innerhalb des Feldes verwendet wird, schließen Sie das gesamte Feld in Anführungszeichen ein oder stellen Sie dem Trennzeichen ein Escapezeichen voran.

>>> import csv
>>> villains=[
...     ["Doctor","No"],
...     ["R","K"],
...     ["Mister","Big"],
...     ["Auric","Goldfinger"],
...     ["E","B"],
...     ]

>>> with open ("villains","wt") as fout:
#writer()Schreibe mit
...     csvout=csv.writer(fout)
#Eine CSV-Datei namens Bösewichte wurde erstellt.
...     csvout.writerows(villains)

Ausführungsergebnis

Docter,No
R,K
Miser,Big
Auric,Goldfinger
E,B

>> import csv
>>> with open("villains","rt") as fin:
#reader()Lesen Sie mit
...     cin=csv.reader(fin)
...     villains=[row for row in cin]
... 
>>> print(villains)
[['Doctor', 'No'], ['R', 'K'], ['Mister', 'Big'], ['Auric', 'Goldfinger'], ['E', 'B']]

#DictReader()Geben Sie den Spaltennamen mit an.
>>> import csv
>>> with open("villains","rt") as fin:
...     cin=csv.DictReader(fin,fieldnames=["first","last"])
...     villains=[row for row in cin]
... 
>>> print(villains)
[{'first': 'Docter', 'last': 'No'}, {'first': 'R', 'last': 'K'}, {'first': 'Miser', 'last': 'Big'}, {'first': 'Auric', 'last': 'Goldfinger'}, {'first': 'E', 'last': 'B'}]


>>> import csv
>>> villains= [
...     {"first":"Docter","last":"No"},
...     {"first":"R","last":"K"},
...     {"first":"Miser","last":"Big"},
...     {"first":"Auric","last":"Goldfinger"},
...     {"first":"E","last":"B"},
...     ]
>>> with open("villains","wt") as fout:
...     cout=csv.DictWriter(fout,["first","last"])
#writeheader()Sie können den Spaltennamen auch am Anfang der CSV-Datei mit schreiben.
...     cout.writeheader()
...     cout.writerows(villains)
... 

Ausführungsergebnis

first,last
Docter,No
R,K
Miser,Big
Auric,Goldfinger
E,B

#Lesen Sie die Daten aus der Datei erneut.
#DictReader()Wenn Sie das Argument fieldnames im Aufruf weglassen, wird der Wert in der ersten Zeile der Datei angezeigt(first,last)Mittel, die als Wörterbuchschlüssel für Spaltenbeschriftungen verwendet werden können.
>>> import csv
>>> with open("villains","rt") as fin:
...     cin=csv.DictReader(fin)
...     villains=[row for row in cin]
... 
>>> print(villains)
[OrderedDict([('first', 'Docter'), ('last', 'No')]), OrderedDict([('first', 'R'), ('last', 'K')]), OrderedDict([('first', 'Miser'), ('last', 'Big')]), OrderedDict([('first', 'Auric'), ('last', 'Goldfinger')]), OrderedDict([('first', 'E'), ('last', 'B')])]

8.2.2 XML

• Verwenden Sie ElementTree, um XML einfach zu lesen.

menu.xml

<?xml version="1.0"?>
<menu>
#Optionale Attribute können in das Start-Tag eingebettet werden.
    <breakfast hours="7-11">
        <item price="$6.00">breakfast burritos</item>
        <item price="$4.00">pancakes</item>
    </breakfast>
    <lunch hours="11-3">
        <item price="$5.00">hamburger</item>
    </lunch>
    <dinner hours="3-10">
        <item price="$8.00">spaghetti</item>
    </dinner>
</menu>

>>> import xml.etree.ElementTree as et
>>> tree=et.ElementTree(file="menu.xml")
>>> root=tree.getroot()
>>> root.tag
'menu'
#tag ist eine Folge von Tags und attrib ist ein Wörterbuch seiner Attribute.
>>> for child in root:
...     print("tag:",child.tag,"attributes:",child.attrib)
...     for grandchild in child:
...         print("\ttag:",grandchild.tag,"attributes:",grandchild.attrib)
... 
tag: breakfast attributes: {'hours': '7-11'}
	tag: item attributes: {'price': '$6.00'}
	tag: item attributes: {'price': '$4.00'}
tag: lunch attributes: {'hours': '11-3'}
	tag: item attributes: {'price': '$5.00'}
tag: dinner attributes: {'hours': '3-10'}
	tag: item attributes: {'price': '$8.00'}
#Anzahl der Menübereiche
>>> len(root)
3
#Anzahl der Frühstücksartikel
>>> len(root[0])
2

8.2.3 JSON

• Es ist ein Datenaustauschformat, das über den Rahmen von JavaSciript hinaus sehr beliebt ist.
• Das JSON-Format ist eine Teilmenge von JavaSciript und wird häufig in Python verwendet. --Json im JSON-Modul codiert (speichert) Python-Daten in JSON-Zeichenfolgen und decodiert (lädt) JSON-Zeichenfolgen in Python-Daten.

#Datenstruktur erstellen
>>> menu=\
... {
... "breakfast":{
...     "hours":"7-11",
...     "items":{
...             "breakfast burritos":"$6.00",
...             "pancakes":"$4.00"
...             }
...         },
... "lunch":{
...         "hours":"11-3",
...         "items":{
...             "hamburger":"$5.00"
...                 }
...         },
... "dinner":{
...     "hours":"3-10",
...     "items":{
...             "spaghetti":"$8.00"
...             }
...     }
... }

#dumps()Diese Datenstruktur mit(menu)Zu JSON-Zeichenfolge(menu_json)Codieren Sie zu.
>>> import json
>>> menu_json=json.dumps(menu)
>>> menu_json
`{"breakfast": {"hours": "7-11", "items": {"breakfast burritos": "$6.00", "pancakes": "$4.00"}}, "lunch": {"hours": "11-3", "items": {"hamburger": "$5.00"}}, "dinner": {"hours": "3-10", "items": {"spaghetti": "$8.00"}}}`

#loads()Verwenden des JSON-Zeichenfolgenmenüs_Kehren Sie json zum Python-Datenstrukturmenü2 zurück.
>>> menu2=json.loads(menu_json)
>>> menu2
{'breakfast': {'hours': '7-11', 'items': {'breakfast burritos': '$6.00', 'pancakes': '$4.00'}}, 'lunch': {'hours': '11-3', 'items': {'hamburger': '$5.00'}}, 'dinner': {'hours': '3-10', 'items': {'spaghetti': '$8.00'}}}

#Beim Versuch, einige Objekte wie datetime zu codieren oder zu decodieren, tritt die folgende Ausnahme auf.
#Dies liegt daran, dass der JSON-Standard keine Datums- und Uhrzeittypen definiert.
>>> import datetime
>>> now=datetime.datetime.utcnow()
>>> now
datetime.datetime(2020, 1, 23, 1, 59, 51, 106364)
>>> json.dumps(now)
#...Kürzung
TypeError: Object of type datetime is not JSON serializable

#Sie können datetime in eine Zeichenfolge oder Unix-Zeit konvertieren.
>>> now_str=str(now)
>>> json.dumps(now_str)
'"2020-01-23 01:59:51.106364"'
>>> from time import mktime
>>> now_epoch=int(mktime(now.timetuple()))
>>> json.dumps(now_epoch)
'1579712391'

#Wenn der normalerweise konvertierte Datentyp einen Wert für den Datums- / Uhrzeittyp enthält, ist die Konvertierung jedes Mal mühsam.
#Also json.Erstellen Sie eine Klasse, die JSONEncoder erbt.
#Überschreiben Sie die Standardmethode.
#isinstance()Die Funktion ist obj ist datetime.Überprüfen Sie, ob es sich um ein Objekt der Datetime-Klasse handelt.
>>> class DTEncoder(json.JSONEncoder):
...     def default(self,obj):
...     #isinstance()Überprüft die Art des Objekts.
...         if isinstance(obj,datetime.datetime):
...             return int(mktime(obj.timetuple()))
...         return json.JSONEncoder.default(self,obj)
... 
#now=datetime.datetime.utcnow()Ist definiert, wird True zurückgegeben.
>>> json.dumps(now,cls=DTEncoder)
`1579712391`

>>> type(now)
<class `datetime.datetime`>
>>> isinstance(now,datetime.datetime)
True
>>> type(234)
<class `int`>
>>> type("hey")
<class `str`>
>>> isinstance("hey",str)
True
>>> isinstance(234,int)
True

8.2.4 YAML

• Wie JSON verfügt YAML über Schlüssel und Werte, kann jedoch mehr Datentypen als JSON verarbeiten, einschließlich Datum und Uhrzeit.

• Um YAML verarbeiten zu können, müssen Sie eine Bibliothek namens PyYAML installieren.

mcintyre.yaml

name:
  first:James
  last:McIntyre
dates:
  birth:1828-05-25
  death:1906-03-31
details:
  bearded:true
  themes:[cheese,Canada]
books:
  url:http://www.gutenberg.org/files/36068/36068-h/36068-h.htm
poems:
  - title: "Motto" #Ein Fehler ist aufgetreten, weil kein Platz mit halber Breite vorhanden war.
    text: |
        Politeness,perseverance and pluck,
        To their possessor will bring good luck.
  - title: "Canadian Charms" #Ein Fehler ist aufgetreten, weil kein Platz mit halber Breite vorhanden war.
    text: |
        Here industry is not in vain,
        For we have bounteous crops of grain,
        And you behold on every field
        Of grass and roots abundant yield,
        But after all the greatest charm
        Is the snug home upon the farm,
        And stone walls now keep cattle warm.

>>> import yaml
>>> with open("mcintyre.yaml","rt") as fin:
...     text=fin.read()
... 
>>> data=yaml.load(text)
>>> data["details"]
'bearded:true themes:[cheese,Canada]'
>>> len(data["poems"])
2

8.2.5 Serialisierung mit Gurke

• Das Aufnehmen der Python-Datenhierarchie und das Konvertieren in eine Zeichenfolgendarstellung wird als ** Serialisierung ** bezeichnet. Das Rekonstruieren von Daten aus einer Zeichenfolgendarstellung wird als ** Deserialisierung ** bezeichnet.
• Von der Serialisierung bis zur Deserialisierung kann die Zeichenfolgendarstellung eines Objekts in Form von Dateien oder Daten gespeichert oder über das Netzwerk an einen Remotecomputer gesendet werden.

--Python ist ein spezielles Binärformat, das ein Pickle-Modul bereitstellt, mit dem jedes Objekt gespeichert und wiederhergestellt werden kann.

>>> import pickle
>>> import datetime
>>> now1=datetime.datetime.utcnow()
>>> pickled=pickle.dumps(now1)
>>> now2=pickle.loads(pickled)
>>> now1
datetime.datetime(2020, 1, 23, 5, 30, 56, 648873)
>>> now2
datetime.datetime(2020, 1, 23, 5, 30, 56, 648873)

#pickle kann auch proprietäre Klassen und Objekte verarbeiten, die im Programm definiert sind.
>>> import pickle
>>> class Tiny():
...     def __str__(self):
...         return "tiny"
... 
>>> obj1=Tiny()
>>> obj1
<__main__.Tiny object at 0x10af86910>
>>> str(obj1)
'tiny'
#pickled ist eine binäre Sequenz, die mit pickle von einem obj1-Objekt serialisiert wurde.
#dump()Serialisieren Sie in eine Datei mit.
>>> pickled=pickle.dumps(obj1)
>>> pickled
b'\x80\x03c__main__\nTiny\nq\x00)\x81q\x01.'
#Ich habe es wieder in obj2 konvertiert und eine Kopie von obj1 erstellt.
#loads()Deserialisieren Sie Objekte aus Dateien mit.
>>> obj2=pickle.loads(pickled)
>>> obj2
<__main__.Tiny object at 0x10b21cdd0>
>>> str(obj2)
'tiny'

Impressionen

Endlich neben RDBMS.

Verweise

"Einführung in Python3 von Bill Lubanovic (veröffentlicht von O'Reilly Japan)"

"Python Tutorial 3.8.1 Dokument 7. Eingabe und Ausgabe" https://docs.python.org/ja/3/tutorial/inputoutput.html#old-string-formatting