Il s'agit d'une introduction à un fichier JSON pratique pour résumer les résultats de sortie créés en Python. Comme je l'expliquerai plus tard, car vous pouvez enregistrer la liste Python et le format du dictionnaire tels quels. Presque aucune conversion d'entrée et de sortie n'est requise. De plus, comme l'importation json pour les entrées / sorties est incluse, il n'est pas nécessaire d'installer une autre bibliothèque.
Tout d'abord, c'est douloureux si vous ne connaissez pas les listes et les dictionnaires, alors je vais les écrire. Si vous dites «Je sais!», Veuillez l'ignorer.
Pensez à une liste comme un tableau en C ++ (d'après ce que je comprends). En Python, la variable est traitée comme une liste lorsqu'elle est initialisée avec []. Dans l'exemple ci-dessous, la variable a est initialisée sous forme de liste. Dans l'instruction for, la valeur de i est ajoutée à la fin de la liste. Vous pouvez accéder à chaque élément en spécifiant le numéro dans la liste entre [].
a = [] #Initialiser sous forme de liste
# 0~Stocke des valeurs jusqu'à 9
for i in range(10):
a.append(i)
print(a)
#production:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#Référence d'élément
print(a[0]) #Sortie: 0
print(a[1]) #Sortie: 1
print(a[2]) #Sortie: 2
Un dictionnaire est comme std :: map en C ++, et gère chaque élément par une valeur associée à un élément stocké appelé clé au lieu du numéro d'élément de la liste. C'est compliqué, mais si vous l'initialisez avec {}, la variable sera traitée comme un dictionnaire. Dans l'exemple ci-dessous, la variable b est initialisée en tant que dictionnaire.
b = {} #Initialiser en tant que dictionnaire
#Avec j comme clé, j*Valeur en magasin de 10
for j in range(10):
b[j] = j * 10
print(b)
#production:{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
Vous pouvez également utiliser une chaîne pour la clé. De plus, vous pouvez créer un dictionnaire dans le dictionnaire. Cependant, veuillez noter que vous ne pouvez pas utiliser la même clé plus d'une fois.
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)
#production:{'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"])
#Sortie: 59
Ce à quoi vous devez faire attention dans l'exemple ci-dessus est que les résultats de sortie ne sont pas dans l'ordre de stockage. En effet, le dictionnaire Python ne conserve pas l'ordre dans lequel ils ont été stockés. Je pense que l'ordre n'a pas d'importance car il est accessible par la clé. Par conséquent, si vous souhaitez conserver l'ordre de stockage, apportez quelques ajustements à l'initialisation.
import collections as cl #Importer des collections
#ys = {}
#{}Au lieu de collections.OrderedDict()Initialiser avec
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)
#Sortie: 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)]))])
Les collections ci-dessus.OrderedDict () est une fonction qui crée un dictionnaire ordonné. En initialisant avec ceci, un dictionnaire qui conserve l'ordre d'entrée est terminé.
À propos, quel est le format JSON essentiel est le même format que le format de dictionnaire ci-dessus. Le contenu du fichier est
{(Clé 1)：(Élément 1),(Clé 2)：(Élément 2)，…}
Le format étant organisé dans l'ordre de, on peut dire que le dictionnaire ≒ format JSON. Si vous souhaitez gérer les fichiers JSON en Python, vous devez importer la bibliothèque pour les fichiers JSON.
import json
Voici un exemple. Je vais expliquer en utilisant le fichier JSON suivant.
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')
#Ici, c'est important! !!
json_data = json.load(f) #Lire au format JSON
name_list = ["honoka","eri","kotori","umi","rin","maki","nozomi","hanayo","niko"]
for name in name_list:
print("{0:6s}la taille:{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()
Résultat de sortie
honoka Hauteur: 157cm BWH: 78 58 82
eri Hauteur: 162cm BWH: 88 60 84
kotori Hauteur: 159 cm BWH: 80 58 80
umi Hauteur: 159 cm BWH: 76 58 80
Hauteur de rin: 155cm BWH: 75 59 80
maki Hauteur: 161cm BWH: 78 56 83
nozomi Hauteur: 159 cm BWH: 90 60 82
hanayo Hauteur: 156cm BWH: 82 60 83
niko Hauteur: 154cm BWH: 74 57 79
En passant, lors de la lecture du fichier, j'ai lu chaque élément et formaté l'affichage par moi-même. Cependant, lorsque vous souhaitez vérifier rapidement le contenu du fichier JSON lu, Il est difficile d'afficher comme ci-dessus (bien que cela soit nécessaire pour le traitement).
Dans un tel cas, il existe une fonction json.dumps qui le formate et l'affiche.
import json
def main():
f = open("myu_s.json", 'r')
json_data = json.load(f)
#Ici, c'est important! !!
#Affichage avec retrait
print("{}".format(json.dumps(json_data,indent=4)))
if __name__=='__main__':
main()
Résultat de sortie Il sera affiché séparé par l'espace spécifié par le retrait de la fonction de vidage. Notez que si vous ne spécifiez aucun retrait, il sera affiché sur une ligne. De plus, comme il est lu dans le format normal du dictionnaire, l'ordre changera.
{
"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
]
}
}
Le dernier concerne l'écriture de fichiers. Lors de l'écriture dans un fichier, si le fichier est lu à partir d'un autre programme, l'ordre peut être modifié, ce qui peut entraîner un problème. Par conséquent, créez un dictionnaire avec l'ordre spécifié par collections.OrderedDict et écrivez-le.
Cette fois, par souci de clarté, les données divisées en trois listes, la liste des noms, la liste des hauteurs et la liste à trois tailles, sont écrites dans une structure JSON.
Lors de l'écriture dans un fichier, utilisez la fonction json.dump. Lorsqu'il est affiché, vider "s" est. Veuillez noter que c'est différent. Placez le dictionnaire à écrire dans le premier argument et spécifiez le fichier dans lequel écrire dans le second.
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')
#Ici, c'est important! !!
# json.Ecrire dans un fichier avec la fonction de vidage
json.dump(ys,fw,indent=4)
if __name__=='__main__':
main()
Résultat de sortie
Ce qui précède explique comment gérer les fichiers JSON. Veuillez noter qu'il peut y avoir des erreurs car il s'agit presque d'auto-apprentissage. S'il y a des erreurs ou de nouvelles découvertes, nous les corrigerons et les ajouterons une par une.
[1] Introduction aux listes, taples et dictionnaires Python [2] [python] Format et vidage du fichier JSON [3] [Introduction à Python] Comment gérer les données au format JSON [4] Enregistrer l'ordre d'ajout des éléments dans le dictionnaire python
Recommended Posts