Dies ist eine Einführung in eine JSON-Datei, mit der Sie die in Python erstellten Ausgabeergebnisse zusammenfassen können. Wie ich später erklären werde, weil Sie die Python-Liste und das Wörterbuchformat so speichern können, wie sie sind. Es ist fast keine Konvertierung für Eingabe und Ausgabe erforderlich. Da der Import von json für die Ein- / Ausgabe enthalten ist, muss keine weitere Bibliothek installiert werden.
Zuallererst ist es schmerzhaft, wenn Sie nichts über Listen und Wörterbücher wissen, also werde ich sie aufschreiben. Wenn Sie "Ich weiß!" Sagen, überspringen Sie es bitte.
Stellen Sie sich eine Liste als Array in C ++ vor (nach meinem Verständnis). In Python wird die Variable bei der Initialisierung mit [] als Liste behandelt. Im folgenden Beispiel wird die Variable a als Liste initialisiert. In der for-Anweisung wird der Wert von i am Ende der Liste hinzugefügt. Sie können auf jedes Element zugreifen, indem Sie die Nummer in der Liste in [] angeben.
a = [] #Als Liste initialisieren
# 0~Speichert Werte bis zu 9
for i in range(10):
a.append(i)
print(a)
#Ausgabe:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#Elementreferenz
print(a[0]) #Ausgabe: 0
print(a[1]) #Ausgabe: 1
print(a[2]) #Ausgabe: 2
Ein Wörterbuch ähnelt std :: map in C ++ und verwaltet jedes Element durch einen Wert, der mit einem gespeicherten Element namens Schlüssel anstelle der Elementnummer der Liste gepaart ist. Es ist kompliziert, aber wenn Sie es mit {} initialisieren, wird die Variable als Wörterbuch behandelt. Im folgenden Beispiel wird die Variable b als Wörterbuch initialisiert.
b = {} #Als Wörterbuch initialisieren
#Mit j als Schlüssel, j*Speicherwert von 10
for j in range(10):
b[j] = j * 10
print(b)
#Ausgabe:{0: 0, 1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80, 9: 90}
print(b[0]) #0
print(b[1]) #10
print(b[2]) #20
Sie können auch eine Zeichenfolge für den Schlüssel verwenden. Darüber hinaus können Sie ein Wörterbuch im Wörterbuch erstellen. Beachten Sie jedoch, dass Sie denselben Schlüssel nicht mehr als einmal verwenden können.
ys = {}
ys["honoka"] = {"B": 78, "W": 58, "H": 82}
ys["eri"] = {"B": 88, "W": 60, "H": 84}
ys["kotori"] = {"B": 80, "W": 58, "H": 80}
ys["umi"] = {"B": 76, "W": 58, "H": 80}
ys["rin"] = {"B": 75, "W": 59, "H": 80}
ys["maki"] = {"B": 78, "W": 56, "H": 83}
ys["nozomi"] = {"B": 90, "W": 60, "H": 82}
ys["hanayo"] = {"B": 82, "W": 60, "H": 83}
ys["niko"] = {"B": 74, "W": 57, "H": 79}
print(ys)
#Ausgabe:{'nozomi': {'H': 82, 'B': 90, 'W': 60}, 'umi': {'H': 80, 'B': 76, 'W': 58}, 'niko': {'H': 79, 'B': 74, 'W': 57}, 'kotori': {'H': 80, 'B': 80, 'W': 58}, 'maki': {'H': 83, 'B': 78, 'W': 56}, 'eri': {'H': 84, 'B': 88, 'W': 60}, 'hanayo': {'H': 83, 'B': 82, 'W': 60}, 'rin': {'H': 80, 'B': 75, 'W': 59}, 'honoka': {'H': 82, 'B': 78, 'W': 58}}
print(ys["rin"]["W"])
#Ausgabe: 59
Was Sie im obigen Beispiel beachten sollten, ist, dass die Ausgabeergebnisse nicht in der Speicherreihenfolge sind. Dies liegt daran, dass das Python-Wörterbuch die Reihenfolge, in der sie gespeichert wurden, nicht beibehält. Ich denke, dass es nicht auf die Reihenfolge ankommt, da der Schlüssel darauf zugreift. Wenn Sie die Speicherreihenfolge beibehalten möchten, nehmen Sie daher einige Anpassungen an der Initialisierung vor.
import collections as cl #Sammlungen importieren
#ys = {}
#{}Anstelle von Sammlungen.OrderedDict()Initialisieren mit
ys = cl.OrderedDict()
ys["honoka"] = cl.OrderedDict({"B": 78, "W": 58, "H": 82})
ys["eri"] = cl.OrderedDict({"B": 88, "W": 60, "H": 84})
ys["kotori"] = cl.OrderedDict({"B": 80, "W": 58, "H": 80})
ys["umi"] = cl.OrderedDict({"B": 76, "W": 58, "H": 80})
ys["rin"] = cl.OrderedDict({"B": 75, "W": 59, "H": 80})
ys["maki"] = cl.OrderedDict({"B": 78, "W": 56, "H": 83})
ys["nozomi"] = cl.OrderedDict({"B": 90, "W": 60, "H": 82})
ys["hanayo"] = cl.OrderedDict({"B": 82, "W": 60, "H": 83})
ys["niko"] = cl.OrderedDict({"B": 74, "W": 57, "H": 79})
print(ys)
#Ausgabe: OrderedDict([('honoka', OrderedDict([('B', 78), ('H', 82), ('W', 58)])), ('eri', OrderedDict([('B', 88), ('H', 84), ('W', 60)])), ('kotori', OrderedDict([('B', 80), ('H', 80), ('W', 58)])), ('umi', OrderedDict([('B', 76), ('H', 80), ('W', 58)])), ('rin', OrderedDict([('B', 75), ('H', 80), ('W', 59)])), ('maki', OrderedDict([('B', 78), ('H', 83), ('W', 56)])), ('nozomi', OrderedDict([('B', 90), ('H', 82), ('W', 60)])), ('hanayo', OrderedDict([('B', 82), ('H', 83), ('W', 60)])), ('niko', OrderedDict([('B', 74), ('H', 79), ('W', 57)]))])
Die oben genannten Sammlungen.OrderedDict () ist eine Funktion, die ein geordnetes Wörterbuch erstellt. Durch diese Initialisierung wird ein Wörterbuch vervollständigt, das die Eingabereihenfolge beibehält.
Das wesentliche JSON-Format ist übrigens das gleiche Format wie das obige Wörterbuchformat. Der Inhalt der Datei ist
{(Schlüssel 1):(Element 1),(Schlüssel 2):(Element 2),…}
Da das Format in der Reihenfolge angeordnet ist, kann gesagt werden, dass das Wörterbuch ≒ JSON-Format. Wenn Sie JSON-Dateien in Python verarbeiten möchten, müssen Sie die Bibliothek für JSON-Dateien importieren.
import json
Das Folgende ist ein Beispiel. Ich werde anhand der folgenden JSON-Datei erklären.
myu_s.json
{
"honoka": {
"BWH": [
78,
58,
82
],
"height": 157
},
"eri": {
"BWH": [
88,
60,
84
],
"height": 162
},
"kotori": {
"BWH": [
80,
58,
80
],
"height": 159
},
"umi": {
"BWH": [
76,
58,
80
],
"height": 159
},
"rin": {
"BWH": [
75,
59,
80
],
"height": 155
},
"maki": {
"BWH": [
78,
56,
83
],
"height": 161
},
"nozomi": {
"BWH": [
90,
60,
82
],
"height": 159
},
"hanayo": {
"BWH": [
82,
60,
83
],
"height": 156
},
"niko": {
"BWH": [
74,
57,
79
],
"height": 154
}
}
import json
def main():
f = open("myu_s.json", 'r')
#Hier ist wichtig! !!
json_data = json.load(f) #Lesen Sie im JSON-Format
name_list = ["honoka","eri","kotori","umi","rin","maki","nozomi","hanayo","niko"]
for name in name_list:
print("{0:6s}Höhe:{1}cm BWH: ".format(name,json_data[name]["height"]),end="\t")
for i in range(len(json_data[name]["BWH"])):
print("{}".format(json_data[name]["BWH"][i]),end="\t")
print()
if __name__=='__main__':
main()
Ausgabeergebnis
Honoka Höhe: 157cm BWH: 78 58 82
eri Höhe: 162cm BWH: 88 60 84
kotori Höhe: 159cm BWH: 80 58 80
umi Höhe: 159cm BWH: 76 58 80
Spülhöhe: 155cm BWH: 75 59 80
maki Höhe: 161cm BWH: 78 56 83
nozomi Höhe: 159cm BWH: 90 60 82
Hanayo Höhe: 156 cm BWH: 82 60 83
niko Höhe: 154cm BWH: 74 57 79
Übrigens habe ich beim Lesen der Datei jedes Element gelesen und die Anzeige selbst formatiert. Wenn Sie jedoch den Inhalt der gelesenen JSON-Datei schnell überprüfen möchten, Die Anzeige wie oben ist schwierig (obwohl dies für die Verarbeitung erforderlich ist).
Für einen solchen Fall gibt es eine json.dumps-Funktion, die sie formatiert und anzeigt.
import json
def main():
f = open("myu_s.json", 'r')
json_data = json.load(f)
#Hier ist wichtig! !!
#Anzeige mit Einzug
print("{}".format(json.dumps(json_data,indent=4)))
if __name__=='__main__':
main()
Ausgabeergebnis Es wird getrennt durch das durch den Einzug der Dump-Funktion angegebene Leerzeichen angezeigt. Beachten Sie, dass wenn Sie keinen Einzug angeben, dieser in einer Zeile angezeigt wird. Da es im normalen Wörterbuchformat gelesen wird, ändert sich auch die Reihenfolge.
{
"umi": {
"height": 159,
"BWH": [
76,
58,
80
]
},
"hanayo": {
"height": 156,
"BWH": [
82,
60,
83
]
},
"honoka": {
"height": 157,
"BWH": [
78,
58,
82
]
},
"rin": {
"height": 155,
"BWH": [
75,
59,
80
]
},
"maki": {
"height": 161,
"BWH": [
78,
56,
83
]
},
"nozomi": {
"height": 159,
"BWH": [
90,
60,
82
]
},
"niko": {
"height": 154,
"BWH": [
74,
57,
79
]
},
"eri": {
"height": 162,
"BWH": [{
"umi": {
"height": 159,
"BWH": [
76,
58,
80
]
},
"hanayo": {
"height": 156,
"BWH": [
82,
60,
83
]
},
"honoka": {
"height": 157,
"BWH": [
78,
58,
82
]
},
"rin": {
"height": 155,
"BWH": [
75,
59,
80
]
},
"maki": {
"height": 161,
"BWH": [
78,
56,
83
]
},
"nozomi": {
"height": 159,
"BWH": [
90,
60,
82
]
},
"niko": {
"height": 154,
"BWH": [
74,
57,
79
]
},
"eri": {
"height": 162,
"BWH": [
88,
60,
84
]
},
"kotori": {
"height": 159,
"BWH": [
80,
58,
80
]
}
}
88,
60,
84
]
},
"kotori": {
"height": 159,
"BWH": [
80,
58,
80
]
}
}
Das letzte ist über das Schreiben von Dateien. Wenn beim Schreiben in eine Datei die Datei aus einem anderen Programm gelesen wird, kann die Reihenfolge geändert werden, was zu Problemen führen kann. Erstellen Sie daher ein Wörterbuch mit der in collection.OrderedDict angegebenen Reihenfolge und schreiben Sie es.
Aus Gründen der Übersichtlichkeit werden die Daten, die in drei Listen unterteilt sind, die Namensliste, die Höhenliste und die Liste mit drei Größen, diesmal in einer JSON-Struktur geschrieben.
Verwenden Sie beim Schreiben in eine Datei die Funktion json.dump. Wenn angezeigt, "s" ausgeben ist. Bitte beachten Sie, dass es anders ist. Fügen Sie das zu schreibende Wörterbuch in das erste Argument ein und geben Sie die zu schreibende Datei im zweiten an.
import json
import collections as cl
def main():
name_list = ["honoka", "eri", "kotori", "umi", "rin", "maki", "nozomi", "hanayo", "niko"]
height = [157,162,159,159,155,161,159,156,154]
BWH = [[78, 58, 82],[88, 60, 84],[80, 58, 80],[76, 58, 80],
[75, 59, 80],[78, 56, 83],[90, 60, 82],[82, 60, 83],[74, 57, 79]]
ys = cl.OrderedDict()
for i in range(len(name_list)):
data = cl.OrderedDict()
data["BWH"] = BWH[i]
data["height"] = height[i]
ys[name_list[i]] = data
#print("{}".format(json.dumps(ys,indent=4)))
fw = open('myu_s.json','w')
#Hier ist wichtig! !!
# json.In Datei mit Dump-Funktion schreiben
json.dump(ys,fw,indent=4)
if __name__=='__main__':
main()
Ausgabeergebnis
Im Folgenden wird beschrieben, wie Sie mit JSON-Dateien umgehen. Bitte beachten Sie, dass es einige Fehler geben kann, da es sich fast um ein Selbststudium handelt. Wenn es Fehler oder neue Entdeckungen gibt, werden wir diese nacheinander korrigieren und hinzufügen.
[1] Einführung in Python-Listen, Taples, Wörterbücher [2] [Python] JSON-Datei formatieren und sichern [3] [Einführung in Python] Umgang mit Daten im JSON-Format [4] Speichern Sie die Reihenfolge des Hinzufügens von Elementen zum Python-Wörterbuch
Recommended Posts