Tuần tự hóa cá thể lớp thành JSON

Tôi đang cố gắng tạo một biểu diễn chuỗi JSON của một thể hiện của lớp và gặp khó khăn. Giả sử lớp được xây dựng như thế này:

class testclass:
    value1 = "a"
    value2 = "b"

Một cuộc gọi đến json.dumps được thực hiện như thế này:

t = testclass()
json.dumps(t)

Đó là thất bại và nói với tôi rằng lớp thử nghiệm không phải là tuần tự hóa JSON.

TypeError: <__main__.testclass object at 0x000000000227A400> is not JSON serializable

Tôi cũng đã thử sử dụng mô-đun dưa chua:

t = testclass()
print(pickle.dumps(t, pickle.HIGHEST_PROTOCOL))

Và nó cung cấp thông tin cá thể lớp nhưng không phải là một nội dung nối tiếp của thể hiện lớp.

b'\x80\x03c__main__\ntestclass\nq\x00)\x81q\x01}q\x02b.'

Tôi đang làm gì sai?

Vấn đề cơ bản là bộ mã hóa JSON json.dumps()chỉ biết cách tuần tự hóa một tập hợp các loại đối tượng giới hạn theo mặc định, tất cả các kiểu dựng sẵn. Danh sách tại đây: https://docs.python.org/3.3/l Library / json.html # encoders-and-decoders

Một giải pháp tốt sẽ là làm cho lớp của bạn kế thừa từ JSONEncoderđó và sau đó thực hiện JSONEncoder.default()hàm và làm cho hàm đó phát ra JSON chính xác cho lớp của bạn.

Một giải pháp đơn giản sẽ được gọi json.dumps()vào .__dict__thành viên của trường hợp đó. Đó là một Python chuẩn dictvà nếu lớp của bạn đơn giản, nó sẽ là tuần tự hóa JSON.

class Foo(object):
    def __init__(self):
        self.x = 1
        self.y = 2

foo = Foo()
s = json.dumps(foo) # raises TypeError with "is not JSON serializable"

s = json.dumps(foo.__dict__) # s set to: {"x":1, "y":2}

Cách tiếp cận trên được thảo luận trong bài đăng blog này:

    Tuần tự hóa các đối tượng Python tùy ý sang JSON bằng cách sử dụng __dict__

Có một cách phù hợp với tôi mà bạn có thể thử:

json.dumps()có thể lấy mặc định tham số tùy chọn trong đó bạn có thể chỉ định chức năng tuần tự hóa tùy chỉnh cho các loại không xác định, trong trường hợp của tôi trông giống như

def serialize(obj):
    """JSON serializer for objects not serializable by default json code"""

    if isinstance(obj, date):
        serial = obj.isoformat()
        return serial

    if isinstance(obj, time):
        serial = obj.isoformat()
        return serial

    return obj.__dict__

Hai if đầu tiên là cho tuần tự hóa ngày và thời gian và sau đó có một obj.__dict__trả lại cho bất kỳ đối tượng khác.

cuộc gọi cuối cùng trông giống như:

json.dumps(myObj, default=serialize)

Điều này đặc biệt tốt khi bạn sắp xếp tuần tự một bộ sưu tập và bạn không muốn gọi __dict__rõ ràng cho mọi đối tượng. Ở đây nó được thực hiện cho bạn tự động.

Cho đến nay làm việc rất tốt cho tôi, mong chờ những suy nghĩ của bạn.

Bạn có thể chỉ định defaulttham số được đặt tên trong json.dumps()hàm:

json.dumps(obj, default=lambda x: x.__dict__)

Giải trình:

Hình thành các tài liệu ( 2.7 , 3.6 ):

``default(obj)`` is a function that should return a serializable version
of obj or raise TypeError. The default simply raises TypeError.

(Hoạt động trên Python 2.7 và Python 3.x)

Lưu ý: Trong trường hợp này, bạn cần instancecác biến và không phải classcác biến, như ví dụ trong câu hỏi cố gắng thực hiện. (Tôi giả sử người hỏi có nghĩa class instancelà một đối tượng của một lớp)

Tôi đã học được điều này đầu tiên từ câu trả lời của @ phihag ở đây . Tìm thấy nó là cách đơn giản nhất và sạch nhất để thực hiện công việc.

Tôi vừa làm:

data=json.dumps(myobject.__dict__)

Đây không phải là câu trả lời đầy đủ và nếu bạn có một số loại đối tượng phức tạp, bạn chắc chắn sẽ không nhận được mọi thứ. Tuy nhiên tôi sử dụng điều này cho một số đối tượng đơn giản của tôi.

Một thứ mà nó hoạt động thực sự tốt là lớp "tùy chọn" mà bạn nhận được từ mô-đun OptionParser. Đây là cùng với yêu cầu JSON.

  def executeJson(self, url, options):
        data=json.dumps(options.__dict__)
        if options.verbose:
            print data
        headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
        return requests.post(url, data, headers=headers)

Sử dụng jsonpickle

import jsonpickle

object = YourClass()
json_object = jsonpickle.encode(object)

JSON không thực sự có nghĩa là để tuần tự hóa các đối tượng Python tùy ý. Thật tuyệt vời khi tuần tự hóa dictcác đối tượng, nhưng picklemô-đun thực sự là những gì bạn nên sử dụng nói chung. Đầu ra từ picklekhông thực sự có thể đọc được, nhưng nó sẽ giải nén tốt. Nếu bạn khăng khăng sử dụng JSON, bạn có thể kiểm tra jsonpicklemô-đun, đây là một cách tiếp cận lai thú vị.

https://github.com/jsonpickle/jsonpickle

Dưới đây là hai hàm đơn giản để tuần tự hóa bất kỳ lớp không phức tạp nào, không có gì lạ mắt như được giải thích trước đây.

Tôi sử dụng điều này cho các loại cấu hình bởi vì tôi có thể thêm thành viên mới vào các lớp mà không cần điều chỉnh mã.

import json

class SimpleClass:
    def __init__(self, a=None, b=None, c=None):
        self.a = a
        self.b = b
        self.c = c

def serialize_json(instance=None, path=None):
    dt = {}
    dt.update(vars(instance))

    with open(path, "w") as file:
        json.dump(dt, file)

def deserialize_json(cls=None, path=None):
    def read_json(_path):
        with open(_path, "r") as file:
            return json.load(file)

    data = read_json(path)

    instance = object.__new__(cls)

    for key, value in data.items():
        setattr(instance, key, value)

    return instance

# Usage: Create class and serialize under Windows file system.
write_settings = SimpleClass(a=1, b=2, c=3)
serialize_json(write_settings, r"c:\temp\test.json")

# Read back and rehydrate.
read_settings = deserialize_json(SimpleClass, r"c:\temp\test.json")

# results are the same.
print(vars(write_settings))
print(vars(read_settings))

# output:
# {'c': 3, 'b': 2, 'a': 1}
# {'c': 3, 'b': 2, 'a': 1}

Có một số câu trả lời tốt về cách bắt đầu làm điều này. Nhưng có một số điều cần lưu ý:

• Điều gì xảy ra nếu thể hiện được lồng trong một cấu trúc dữ liệu lớn?
• Điều gì nếu cũng muốn tên lớp?
• Điều gì sẽ xảy ra nếu bạn muốn giải tuần tự hóa?
• Nếu bạn đang sử dụng __slots__thay vì __dict__thì sao?
• Điều gì nếu bạn không muốn tự làm điều đó?

json-trick là một thư viện (mà tôi đã tạo ra và những người khác đã đóng góp) đã có thể làm điều này trong một thời gian dài. Ví dụ:

class MyTestCls:
    def __init__(self, **kwargs):
        for k, v in kwargs.items():
            setattr(self, k, v)

cls_instance = MyTestCls(s='ub', dct={'7': 7})

json = dumps(cls_instance, indent=4)
instance = loads(json)

Bạn sẽ lấy lại ví dụ của bạn. Ở đây json trông như thế này:

{
    "__instance_type__": [
        "json_tricks.test_class",
        "MyTestCls"
    ],
    "attributes": {
        "s": "ub",
        "dct": {
            "7": 7
        }
    }
}

Nếu bạn muốn đưa ra giải pháp của riêng mình, bạn có thể xem xét nguồn gốc json-tricksđể không quên một số trường hợp đặc biệt (như __slots__).

Nó cũng thực hiện các loại khác như mảng numpy, datetimes, số phức; nó cũng cho phép bình luận

Python3.x

Aproach tốt nhất tôi có thể đạt được với kiến ​​thức của mình là điều này.
Lưu ý rằng mã này xử lý set () quá.
Cách tiếp cận này là chung chung chỉ cần mở rộng lớp (trong ví dụ thứ hai).
Lưu ý rằng tôi chỉ làm việc đó với các tệp, nhưng thật dễ dàng để sửa đổi hành vi theo sở thích của bạn.

Tuy nhiên đây là một CoDec.

Với một chút công việc hơn, bạn có thể xây dựng lớp của mình theo những cách khác. Tôi giả sử một hàm tạo mặc định để thể hiện nó, sau đó tôi cập nhật dict lớp.

import json
import collections


class JsonClassSerializable(json.JSONEncoder):

    REGISTERED_CLASS = {}

    def register(ctype):
        JsonClassSerializable.REGISTERED_CLASS[ctype.__name__] = ctype

    def default(self, obj):
        if isinstance(obj, collections.Set):
            return dict(_set_object=list(obj))
        if isinstance(obj, JsonClassSerializable):
            jclass = {}
            jclass["name"] = type(obj).__name__
            jclass["dict"] = obj.__dict__
            return dict(_class_object=jclass)
        else:
            return json.JSONEncoder.default(self, obj)

    def json_to_class(self, dct):
        if '_set_object' in dct:
            return set(dct['_set_object'])
        elif '_class_object' in dct:
            cclass = dct['_class_object']
            cclass_name = cclass["name"]
            if cclass_name not in self.REGISTERED_CLASS:
                raise RuntimeError(
                    "Class {} not registered in JSON Parser"
                    .format(cclass["name"])
                )
            instance = self.REGISTERED_CLASS[cclass_name]()
            instance.__dict__ = cclass["dict"]
            return instance
        return dct

    def encode_(self, file):
        with open(file, 'w') as outfile:
            json.dump(
                self.__dict__, outfile,
                cls=JsonClassSerializable,
                indent=4,
                sort_keys=True
            )

    def decode_(self, file):
        try:
            with open(file, 'r') as infile:
                self.__dict__ = json.load(
                    infile,
                    object_hook=self.json_to_class
                )
        except FileNotFoundError:
            print("Persistence load failed "
                  "'{}' do not exists".format(file)
                  )


class C(JsonClassSerializable):

    def __init__(self):
        self.mill = "s"


JsonClassSerializable.register(C)


class B(JsonClassSerializable):

    def __init__(self):
        self.a = 1230
        self.c = C()


JsonClassSerializable.register(B)


class A(JsonClassSerializable):

    def __init__(self):
        self.a = 1
        self.b = {1, 2}
        self.c = B()

JsonClassSerializable.register(A)

A().encode_("test")
b = A()
b.decode_("test")
print(b.a)
print(b.b)
print(b.c.a)

Biên tập

Với một số nghiên cứu nữa, tôi đã tìm ra một cách để khái quát hóa mà không cần phải gọi phương thức đăng ký SUPERCLASS , sử dụng siêu dữ liệu

import json
import collections

REGISTERED_CLASS = {}

class MetaSerializable(type):

    def __call__(cls, *args, **kwargs):
        if cls.__name__ not in REGISTERED_CLASS:
            REGISTERED_CLASS[cls.__name__] = cls
        return super(MetaSerializable, cls).__call__(*args, **kwargs)


class JsonClassSerializable(json.JSONEncoder, metaclass=MetaSerializable):

    def default(self, obj):
        if isinstance(obj, collections.Set):
            return dict(_set_object=list(obj))
        if isinstance(obj, JsonClassSerializable):
            jclass = {}
            jclass["name"] = type(obj).__name__
            jclass["dict"] = obj.__dict__
            return dict(_class_object=jclass)
        else:
            return json.JSONEncoder.default(self, obj)

    def json_to_class(self, dct):
        if '_set_object' in dct:
            return set(dct['_set_object'])
        elif '_class_object' in dct:
            cclass = dct['_class_object']
            cclass_name = cclass["name"]
            if cclass_name not in REGISTERED_CLASS:
                raise RuntimeError(
                    "Class {} not registered in JSON Parser"
                    .format(cclass["name"])
                )
            instance = REGISTERED_CLASS[cclass_name]()
            instance.__dict__ = cclass["dict"]
            return instance
        return dct

    def encode_(self, file):
        with open(file, 'w') as outfile:
            json.dump(
                self.__dict__, outfile,
                cls=JsonClassSerializable,
                indent=4,
                sort_keys=True
            )

    def decode_(self, file):
        try:
            with open(file, 'r') as infile:
                self.__dict__ = json.load(
                    infile,
                    object_hook=self.json_to_class
                )
        except FileNotFoundError:
            print("Persistence load failed "
                  "'{}' do not exists".format(file)
                  )


class C(JsonClassSerializable):

    def __init__(self):
        self.mill = "s"


class B(JsonClassSerializable):

    def __init__(self):
        self.a = 1230
        self.c = C()


class A(JsonClassSerializable):

    def __init__(self):
        self.a = 1
        self.b = {1, 2}
        self.c = B()


A().encode_("test")
b = A()
b.decode_("test")
print(b.a)
# 1
print(b.b)
# {1, 2}
print(b.c.a)
# 1230
print(b.c.c.mill)
# s

Tôi tin thay vì thừa kế như đề xuất trong câu trả lời được chấp nhận, tốt hơn là sử dụng đa hình. Nếu không, bạn phải có một câu lệnh lớn nếu khác để tùy chỉnh mã hóa của mọi đối tượng. Điều đó có nghĩa là tạo một bộ mã hóa mặc định chung cho JSON như:

def jsonDefEncoder(obj):
   if hasattr(obj, 'jsonEnc'):
      return obj.jsonEnc()
   else: #some default behavior
      return obj.__dict__

và sau đó có một jsonEnc()chức năng trong mỗi lớp bạn muốn tuần tự hóa. ví dụ

class A(object):
   def __init__(self,lengthInFeet):
      self.lengthInFeet=lengthInFeet
   def jsonEnc(self):
      return {'lengthInMeters': lengthInFeet * 0.3 } # each foot is 0.3 meter

Sau đó, bạn gọi json.dumps(classInstance,default=jsonDefEncoder)