A través de dos formas de introducir el formato de datos JSON para convertir a los objetos de clase Python, este papel ejemplos de código para le dicen con gran detalle, tiene un cierto valor para las referencias, un amigo en necesidad puede referirse
JOSN convertir una cadena de definir un objeto de instancia de clase
A veces tenemos que esta demanda es una cadena JSON en una pitón ejemplos específicos de clase, tales como reciba una cadena JSON tal es el siguiente:
{"Name": "Tom", "Sex": "Male", "BloodType": "A", "Hobbies": ["篮球", "足球"]}
Necesito convertir este caso particular de la clase persona, para ser operado por medio de un objeto. Hay muchas implementaciones como Gson o FastJosn en Java. Como se muestra en el siguiente código (aquí no todo el código, el valor principal de la parte de identificación):
import com.alibaba.fastjson.JSONObject;
import com.example.demo.entity.Product;
String a = "{\"gmtCreate\":1559009853000,\"dataFormat\":1,\"deviceCount\":1,\"nodeType\":0,\"productKey\":\"a1U85pSQrAz\",\"productName\":\"温度计\"}";
//JSON字符串反序列化为一个Product对象
Product product = JSONObject.parseObject(a, Product.class);
Esto ocurre generalmente en los requisitos anteriormente descritos cuando pasan sobre la cadena de pre-etapa JSON u otros sistemas se transmite también a través de la comunicación cadena RPC JSON, como un receptor requiere deserializar en objetos a tratar, pero todavía hay un JSONArray.parseArray método Fastjson se puede convertir a una lista de objetos. Pero en Java, Python no le gustaba una cosa tan conveniente.
De Los grupos también visto algunos, pero muchos son allí, pero el efecto del uso de crear problemas, por lo que estoy aquí por mis ideas.
Modo 1: realizado por josn.loads
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import json
class Person:
def __init__(self, data=None):
self._name = "1"
self._sex = ""
self._blood_type = "O"
self._hobbies = []
self._date_of_birth = "1900/1/1"
if data:
self.__dict__ = data
# 通过属性的方式来获取和设置实例变量的值，如果不这样那么就只能通过set或者get方法来做
@property
def date_of_brith(self):
return self._date_of_birth
@date_of_brith.setter
def date_of_brith(self, date_of_brith):
self._date_of_birth = date_of_brith
def main():
try:
str1 = '{"name": "Tom", "sex": "male", "blood_type": "A", "hobbies": ["篮球", "足球"]}'
person1 = json.loads(str1, object_hook=Person)
print(isinstance(person1, Person))
# 这里你会发现没有date_of_brith这个内容
print(person1.__dict__)
# 获取date_of_brith属性值报错，因为JSON字符串不包含这个键，但是类中的实例变量有这个，正常来讲你应该可以获取默认值，但是由于
# 替换了__dict__，所以就没有了，因为__dict__原本就是实例变量的字典形式，你替换了自然也就找不到原来的了。
# print(person.date_of_brith)
# 下面我们通过正常的方式实例化一个对象
person2 = Person()
print(person2.__dict__)
print(person2.date_of_brith)
except Exception as err:
print(err)
if __name__ == "__main__":
try:
main()
finally:
sys.exit()
object_hook lo que significa que los json.loads por defecto () devuelve un diccionario, puede utilizar object_hook se le permita regresar a otros tipos de valores, que es el principio aquí es darse cuenta de que ha aprobado en cadena JSON pasado al método especificado object_hook o clase (si es el tipo de cosas que se ejecutará el método __init__ es en realidad una instancia), esta vez en la clase de método __init asignado a nosotros por self.dict__, de hecho, que es igual a las variables de instancia de clase Person hacer sustitución, a menos que el nombre y número de teclas y variables de instancia de su cadena JSON de la constante de lo contrario no pueden pasar la variable de instancia nombre definido en la clase para obtener el valor pasado a través de una cadena JSON. La figura siguiente manera: 
Por lo tanto, se puede ver de lo anterior, este proceso no se ha asignado para procesar las variables de instancia, sino un proceso alternativo, Python es un lenguaje dinámico y JAVA esto diferente. Si trabaja para una empresa privada (sólo especificaciones en lugar de la verdadera privada) en el programa están subrayados con una sola variable que se pasa cadena JSON teclas también subrayaron la necesidad, para que pueda obtener a través de una instancia de método. Dado que el subrayado adicional no es realista, entonces no hay otra manera de hacerlo? Mira la forma 2
Forma de realización 2: reflexión logrado por
Mira la definición de la clase
#!/usr/bin/env python
# -*- coding: utf-8 -*-
class Person:
def __init__(self):
self._name = "1"
self._sex = ""
self._blood_type = "O"
self._hobbies = []
self._date_of_birth = "1900/1/1"
def __str__(self):
"""
输出实例的类名字，而不是一个地址
:return: 该实例的类名字
"""
return self.__class__.__name__
# 当一个方法加上这个装饰器之后，hasattr()中的属性要写成这个方法的名称，而不是实例变量的名称。
# 如果不加这个装饰器，那么hasattr()中的属性名称要和实例变量的名称保持一致
@property
def Name(self):
return self._name
@Name.setter
def Name(self, name):
self._name = name
@property
def Sex(self):
return self._sex
@Sex.setter
def Sex(self, sex):
self._sex = sex
@property
def BloodType(self):
return self._blood_type
@BloodType.setter
def BloodType(self, blood_type):
self._blood_type = blood_type
@property
def Hobbies(self):
return self._hobbies
@Hobbies.setter
def Hobbies(self, hobbies):
self._hobbies = hobbies
@property
def date_of_brith(self):
return self._date_of_birth
@date_of_brith.setter
def date_of_brith(self, date_of_brith):
self._date_of_birth = date_of_brith
Echemos un vistazo en el método de conversión
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import json
import importlib
def get_instance(str_stream, class_full_path=None):
"""
:param str_stream: json的字符串形式 '{"Name": "Tom", "Sex": "Male", "BloodType": "A"}'
:param class_full_path: package.module.class
:return:
"""
try:
json_obj = json.loads(str_stream)
except Exception as err:
print("输入的字符串不符合JSON格式，请检查。")
return None
if class_full_path is None:
return json_obj
else:
try:
# 获取模块路径
module_path = ".".join(class_full_path.split(".")[0:-1])
# 获取类名称
class_name = class_full_path.split(".")[-1]
# 通过模块名加载模块
CC = importlib.import_module(module_path)
# 判断是否有class_name所代表的属性
if hasattr(CC, class_name):
# 获取模块中属性
temp_obj = getattr(CC, class_name)
# 实例化对象
obj = temp_obj()
for key in json_obj.keys():
obj.__setattr__(key, json_obj[key])
return obj
else:
pass
except Exception as err:
print(err)
return None
def main():
try:
str1 = '{"Name": "Tom", "Sex": "Male", "BloodType": "A", "Hobbies": ["篮球", "足球"]}'
person1 = get_instance(str1, class_full_path="AAA.Classes.Person")
# 查看类型
print(type(person1))
# 查看属性
print(person1.__dict__)
# 查看指定属性
print(person1.Name)
except Exception as err:
print(err)
if __name__ == "__main__":
try:
main()
finally:
sys.exit()
Importación () tiene dos parámetros, uno es la primera clase, el segundo es fromlist, fromlist si no escritura, la escritura se introducirá en el siguiente paquete de AAA solamente, se introducirá el valor si hay fromlist siguientes clases módulo AAA CC = importación ( "AAA.Classes", fromlist = True) no escriba fromlist equivalente a importar AAA, si la escritura es equivalente a importar clases son de AAA cuando se programa con importlib.import_module recomendada de carga dinámica (), en lugar de __import __ () .
Echemos un vistazo a los resultados 
se puede ver, después de esta operación es dar una asignación variable de instancia de esa manera, pero no antes de la sustitución, pero conservó las variables de instancia de clase de especificaciones particulares. Pero cadena JSON es la clave para el nombre del atributo y el nombre de la clase definida dentro de la misma debe tenerse en cuenta, que es el nombre clave de la @property clase y métodos de decoración del mismo nombre. También podemos ver que este uso es también el significado predeterminado JSONObject.parseObject.
Pero esto es sólo una implementación sencilla, no sólo para generar una lista de objetos generados por un solo objeto cadena JSON. Por supuesto, los amigos interesados pueden extenderse sobre la base de esta idea.
Además, ya que tanto las cargas o mis propios métodos de búsqueda necesitan para asegurar una clave de cadena JSON y nombres de variables consistentes no lo hacemos maraña en el nombre del mismo problema, pero mi enfoque hice mantenemos la variable de instancia con nombre prácticas atributo de instancia de la época, mientras que la clase no demasiada diferencia de cargas método invasivo es también una necesidad de aumentar el contenido en el que un método init clase innecesaria. En este método, si puedo lograr ignoran universales caso mejor. Bienvenidos a todos a aportar ideas.
Me dirijo a usted, para todo el mundo para recomendar una muy amplia recolección de recursos de aprendizaje pitón, haga clic para entrar , hay un programador senior antes de aprender a compartir experiencias, notas de estudio, hay una posibilidad de experiencia en los negocios, y para todo el mundo para organizar cuidadosamente un cero pitón la base de los datos reales del proyecto, Python diariamente para que en la última tecnología, las perspectivas, los pequeños detalles de aprendizaje tiene que dejar un mensaje
resumen
Lo anterior es una pequeña serie para introducir a convertir el formato de datos JSON para la clase de métodos de objeto Python Hola, queremos ayudar, si tiene alguna pregunta, por favor dame un mensaje, Xiao Bian responderá inmediatamente a su
