J'ai essayé de créer une classe qui peut facilement sérialiser Json en Python

Vous devez gérer Json en Python, et c'est une fonctionnalité intégrée C'était un peu difficile à gérer, il serait donc plus facile de gérer Json avec Python. J'ai créé une classe

C'est la première fois que je touche correctement Python, donc c'est un peu étrange à utiliser Il peut s'agir d'une fonction existante en premier lieu.

Cible

Lorsque vous traitez avec Json en Python Vous ne pouvez pas le faire sans Map entre Python et Json. Dans ce cas, pour en faire une classe, vous devez l'écrire pour chaque classe, De plus, lors de la sortie de Json à partir d'une classe, vous devez écrire un processus pour chaque classe. C'est ** très ennuyeux **

Par conséquent, il est automatiquement sérialisé à partir de la clé et du nom de variable de Json. Créez une classe qui crée Json à partir du nom de la variable

Code source

Cette classe ressemble à ceci.

JsonAdapter.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import json


class JsonAdapter(object):
	#Sérialiser depuis json
	def Serialize(self, argJsonData) :

		jsonData = argJsonData
		if isinstance(argJsonData, basestring ) :
			jsonData = json.loads(argJsonData)

		for key in self.__dict__.keys():
			if isinstance(getattr(self,key), JsonAdapter ) or getattr(self,key) == None :
				valclass = getattr(self,key)
				if valclass == None :
					valclass = getattr(sys.modules["Classes.DataPDO"],key)()

				valclass.Serialize(jsonData[key])
				setattr(self,key, valclass)

			elif isinstance(getattr(self,key), int ) :
				setattr(self,key, int(jsonData[key]))
			else :
				setattr(self,key, jsonData[key])

	#Sortie Json
	def ToJson(self):
		jsonDict = self.__ToDictionary()
		jsonstring = json.dumps(jsonDict, ensure_ascii=False)
		return jsonstring

	#Créer une carte
	def __ToDictionary(self):
		jsonDict = {}
		for key in self.__dict__.keys():
			if isinstance(getattr(self,key), JsonAdapter ) :
				jsonDict.update({key : getattr(self,key).__ToDictionary()})
			else :
				jsonDict.update({key : getattr(self,key)})
		return jsonDict

Si vous expliquez légèrement

def Serialize(self, argJsonData) : Maintenant, créez un dictionnaire à partir de json une fois, La valeur est prise avec le nom de la variable comme clé. Dans le cas d'une classe, la classe est générée et sérialisée à nouveau.

ToJson(self): Ensuite, au contraire, créez un Dictionnaire avec le nom de la variable comme clé, Json

Comment utiliser

L'exemple de code est ci-dessous.

sample.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import JsonAdapter

class Test(JsonAdapter.JsonAdapter):
    def __init__(self):
        self.num = 0
        self.str = ""
        self.test2 = Test2()

class Test2(JsonAdapter.JsonAdapter):
    def __init__(self):
        self.num = 0
        self.str = ""


if __name__ == "__main__":
    json = """{"test2": {"num": 200, "str": "def"}, "num": 100, "str": "abc"}"""
    test = Test()
    #Etat initial
    print test.ToJson()

    test.Serialize(json)

    #Après sérialisation
    print test.ToJson()

Résultat de sortie

{"test2": {"num": 0, "str": ""}, "num": 0, "str": ""}
{"test2": {"num": 200, "str": "def"}, "num": 100, "str": "abc"}

L'état initial et le résultat après la sérialisation sont affichés. Vous pouvez confirmer qu'il peut être sérialisé normalement et qu'il n'y a aucun problème avec la sortie.

En guise de mise en garde, il doit être hérité par la classe PDO. Le fait est que le nom de la variable et le nom de la clé doivent être unifiés.

c'est tout. Je pensais l'avoir touché correctement Python est intéressant, non?