如何使dict子类json可序列化？

我可以用

json.dumps

表示我的

Simple_Dict_子类

和

List_子类

，但不能用

自定义_Dict_子类

。当在

List\u子类上调用
json.dumps
时，调用了它的
\uu iter\uuuu
方法，因此我推断
json.dumps
将调用字典的
items
方法。而
项
在
简单Dict\u子类
中调用，但在
自定义Dict\u子类
中不调用。如何使我的
Custom_Dict_子类
json
像
Simple_Dict_子类
一样可序列化

import json

class Custom_Dict_Subclass(dict):
    def __init__(self):
        self.data = {}

    def __setitem__(self, key, value):
        self.data[key] = value

    def __getitem__(self, key):
        return self.data[key]

    def __str__(self):
        return str(self.data)

    def items(self):
        print("'Items' called from Custom_Dict_Subclass")
        yield from self.data.items()

class Simple_Dict_Subclass(dict):
    def __setitem__(self, key, value):
        super().__setitem__(key, value)

    def __getitem__(self, key):
        return super().__getitem__(key)

    def __str__(self):
        return super().__str__()

    def items(self):
        print("'Items' called from Simple_Dict_Subclass")
        yield from super().items()

class List_Subclass(list):
    def __init__(self):
        self.data = []

    def __setitem__(self, index, value):
        self.data[index] = value

    def __getitem__(self, index):
        return self.data[index]

    def __str__(self):
        return str(self.data)

    def __iter__(self):
        yield from self.data

    def append(self, value):
        self.data.append(value)

d = Custom_Dict_Subclass()
d[0] = None
print(d)             # Works
print(json.dumps(d)) # Does't work

d = Simple_Dict_Subclass()
d[0] = None
print(d)             # Works
print(json.dumps(d)) # Works

l = List_Subclass()
l.append(None)
print(l)             # Works
print(json.dumps(l)) # Works

输出：

{0: None}   # Custom dict string     working
{}          # Custom dict json.dumps not working

{0: None}   # Simple dict string     working
'Items' called from Simple_Dict_Subclass
{"0": null} # Simple dict json.dumps working

[None]      # List string            working
[null]      # List json.dumps        working

一般来说，假设
json.dumps
将
触发字典的
items
方法。事情就是这样
但你不能依赖它

在您的情况下，不会调用
Custom\u Dict\u子类.items
，因为
（键、值）对不会添加到
dict
对象，而是添加到其
数据
属性

要解决这个问题，您需要在
自定义Dict子类
：

class自定义Dict子类（Dict）：
定义初始化（自）：
口述（自我）
self.data={}
定义设置项（自身、键、值）：
self.data[键]=值
超级（）

对象被正确转储，但当然，（键，值）将
可以存储两次：在
dict
对象及其
数据
属性中

在这种情况下，最好定义一个子类
json.jsonecoder
来实现
Custom_Dict_Subclass
对象到json可序列化对象和
将此类作为
json.dumps
的关键字参数
cls
：

导入json
类自定义命令子类：
定义初始化（自）：
self.data={}
定义设置项（自身、键、值）：
self.data[键]=值
def _u获取项目（自身，密钥）：
返回self.data[键]
定义（自我）：
返回str（self.data）
def项目（自身）：
打印（“从自定义目录子类调用的“项”）
self.data.items（）的收益率
类CustomDictEncoder（json.JSONEncoder）：
def默认值（自身、obj）：
“”“由json.dumps调用以将对象obj转换为
json可序列化的数据类型“”
如果是实例（obj，自定义命令子类）：
返回对象数据
返回json.JSONEncoder.default（self，obj）
d=自定义命令子类（）
d[0]=无
打印（json.dumps（d，cls=CustomDictEncoder））