Naonao Blog

class Person:
    
    def __init__(self):
        self.name = "naonao"

import json

# 创建一个实例
p = Person()

# 尝试序列化
json.dumps(p)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [76], in <module>
      4 p = Person()
      6 # 尝试序列化
----> 7 json.dumps(p)

File /opt/conda/lib/python3.9/json/__init__.py:231, in dumps(obj, skipkeys, ensure_ascii, check_circular, allow_nan, cls, indent, separators, default, sort_keys, **kw)
    226 # cached encoder
    227 if (not skipkeys and ensure_ascii and
    228     check_circular and allow_nan and
    229     cls is None and indent is None and separators is None and
    230     default is None and not sort_keys and not kw):
--> 231     return _default_encoder.encode(obj)
    232 if cls is None:
    233     cls = JSONEncoder

File /opt/conda/lib/python3.9/json/encoder.py:199, in JSONEncoder.encode(self, o)
    195         return encode_basestring(o)
    196 # This doesn't pass the iterator directly to ''.join() because the
    197 # exceptions aren't as detailed.  The list call should be roughly
    198 # equivalent to the PySequence_Fast that ''.join() would do.
--> 199 chunks = self.iterencode(o, _one_shot=True)
    200 if not isinstance(chunks, (list, tuple)):
    201     chunks = list(chunks)

File /opt/conda/lib/python3.9/json/encoder.py:257, in JSONEncoder.iterencode(self, o, _one_shot)
    252 else:
    253     _iterencode = _make_iterencode(
    254         markers, self.default, _encoder, self.indent, floatstr,
    255         self.key_separator, self.item_separator, self.sort_keys,
    256         self.skipkeys, _one_shot)
--> 257 return _iterencode(o, 0)

File /opt/conda/lib/python3.9/json/encoder.py:179, in JSONEncoder.default(self, o)
    160 def default(self, o):
    161     """Implement this method in a subclass such that it returns
    162     a serializable object for ``o``, or calls the base implementation
    163     (to raise a ``TypeError``).
   (...)
    177 
    178     """
--> 179     raise TypeError(f'Object of type {o.__class__.__name__} '
    180                     f'is not JSON serializable')

TypeError: Object of type Person is not JSON serializable

TypeError: Object of type Person is not JSON serializable

class PersonEncoder(json.JSONEncoder):
    
    # 重写该方法, 告诉 json
    # 如何 dumps 指定的对象
    def default(self, _object):
        if isinstance(_object, Person):
            # 这里编写如何序列化 Person
            # 对象的代码
            return dict(name=_object.name)

json.dumps(p, cls=PersonEncoder)

'{"name": "naonao"}'

def default(self, _object):
    if isinstance(_object, Person):
        ...
    elif isinstance(_object, Person1):
        ...
    elif isinstance(_object, Person2):
        ...
    elif isinstance(_object, Person3):
        ...
    elif isinstance(_object, Person4):
        ...
    elif isinstance(_object, Person5):
        ...
    elif isinstance(_object, Person6):
        ...
    elif isinstance(_object, Person7):
        ...

from functools import singledispatch

import json
from functools import singledispatch

class Person:
    
    def __init__(self):
        self.name = "naonao"
        self.age = 18

class Animal:
    
    def __init__(self):
        self.name = "dog"

person = Person()
animal = Animal()

@singledispatch
def serialize(_object):
    return json.dumps(_object)

@serialize.register(Person)
def _(_object):
    return dict(name=_object.name, 
                age=_object.age)

@serialize.register(Animal)
def _(_object):
    return dict(name=_object.name)

class CustomJSONEncoder(json.JSONEncoder):

    def default(self, _object):
        return serialize(_object)

data = {
    "person": person, 
    "animal": animal
}
json.dumps(data, cls=CustomJSONEncoder)

'{"person": {"name": "naonao", "age": 18}, "animal": {"name": "dog"}}'

                    # 目标类
@serialize.register(Person)
def _(_object):
    # 如何序列化这个对象
    return dict(name=_object.name, 
                age=_object.age)

class Person:
    ...

# 实例
p = Person()

# 实例的类
p.__class__

def _register():
    print("register ...")


_register()
_register()
_register()

# 多次调用也只能输出一次
>>> register ...

def _register():
    
    # 这里我们在函数内部定义了一个
    # 内部变量, 表示该函数是否已经
    # 执行过
    _loaded = False
    
    def _load():
        # 这里写该函数的具体执行逻辑
        print("fisrt run, loading ...")
        print("loaded")
        # 当逻辑被执行一次以后
        # 我们需要将设置 _loaded = True
        # 用来表示该函数已经被执行过一次
        # nonlocal 表示该变量不是本地变量
        nonlocal _loaded
        _loaded = True
    
    def _run():
        if not _loaded:
            _load()

    return _run

f = _register()
f()
f()

fisrt run, loading ...
loaded