Ich habe versucht, eine Klasse zu erstellen, mit der Json in Python problemlos serialisiert werden kann

Sie müssen Json in Python verarbeiten, und es ist eine integrierte Funktion Es war etwas schwierig zu handhaben, daher wäre es einfacher, Json mit Python zu handhaben. Ich habe eine Klasse erstellt

Es ist das erste Mal, dass ich Python richtig berührt habe, daher ist die Verwendung etwas seltsam Es kann sich in erster Linie um ein vorhandenes Feature handeln.

Ziel

Beim Umgang mit Json in Python Sie können es nicht ohne Map zwischen Python und Json tun. In diesem Fall müssen Sie es für jede Klasse schreiben, um es zu einer Klasse zu machen. Wenn Sie Json aus einer Klasse ausgeben, müssen Sie für jede Klasse einen Prozess schreiben. Das ist ** sehr nervig **

Daher wird es automatisch aus Jsons Schlüssel- und Variablennamen serialisiert. Erstellen Sie eine Klasse, die Json aus dem Variablennamen erstellt

Quellcode

Diese Klasse sieht so aus.

JsonAdapter.py

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

import sys
import json


class JsonAdapter(object):
	#Von json serialisieren
	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])

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

	#Karte erstellen
	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

Wenn Sie leicht erklären

def Serialize(self, argJsonData) : Erstellen Sie jetzt einmal ein Wörterbuch aus json. Der Wert wird mit dem Variablennamen als Schlüssel verwendet. Im Fall einer Klasse wird die Klasse erneut generiert und serialisiert.

ToJson(self): Erstellen Sie dann im Gegenteil ein Wörterbuch mit dem Variablennamen als Schlüssel. Json

Wie benutzt man

Der Beispielcode ist unten.

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()
    #Ausgangszustand
    print test.ToJson()

    test.Serialize(json)

    #Nach der Serialisierung
    print test.ToJson()

Ausgabeergebnis

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

Der Ausgangszustand und das Ergebnis nach der Serialisierung werden ausgegeben. Sie können bestätigen, dass es normal serialisiert werden kann und dass es kein Problem mit der Ausgabe gibt.

Als Einschränkung muss es von der PDO-Klasse geerbt werden. Der Punkt ist, dass der Variablenname und der Schlüsselname vereinheitlicht werden müssen.

das ist alles. Ich dachte, ich hätte es richtig angefasst Python ist interessant, nicht wahr?