1. 问题根源为什么type对象无法被序列化在Python里json.dumps()函数就像是一个严格的“翻译官”它的工作是把Python世界里的各种对象比如字典、列表、字符串、数字翻译成JSON世界能理解的格式。JSON标准只支持几种基本类型字符串、数字、布尔值、数组对应Python列表、对象对应Python字典以及null对应Python的None。当你尝试序列化一个type对象时比如json.dumps(int)或者json.dumps(list)问题就来了。这里的int和list并不是一个具体的整数1或者列表[1,2,3]它们是类对象是创建具体实例的蓝图。json.dumps()的默认翻译器根本不认识这种“蓝图”它不知道该如何把“整数这个概念”或者“列表这个概念”表示成JSON里的一个字符串或数字所以它只能抛出一个TypeError告诉你“对不起这玩意儿我翻译不了。”这个错误的本质是数据类型不匹配。json模块的默认序列化器JSONEncoder只能处理上述有限的几种基本类型。当你传入一个它不认识的对象时它会尝试调用对象的__dict__属性如果对象有的话但对于像type这样的内置类型__dict__要么不存在要么其内容也无法被默认序列化器处理最终导致失败。2. 核心场景你会在哪里遇到这个错误这个错误通常不会在你显式地序列化int或str时发生因为很少有人会直接这么做。它更多地隐藏在更复杂的操作中以下是几个典型的高发场景2.1 场景一函数或类作为数据的一部分被意外传递这是最常见的情况。假设你写了一个配置字典里面混入了函数或者类引用。import json def my_callback(): return Done config { name: AppConfig, version: 1.0, callback_function: my_callback, # 这里是一个函数对象 data_type: list # 这里是一个类对象 } # 尝试序列化这个配置字典去保存或传输 json_str json.dumps(config) # 这里会抛出 TypeError在上面的例子中my_callback是一个函数对象list是一个类对象它们都是type的实例在Python中函数和类都是对象它们的类型是type或types.FunctionType。当json.dumps()遍历config字典时遇到这两个值它就束手无策了。2.2 场景二从数据库或复杂对象中提取的元数据当你使用一些ORM对象关系映射框架比如SQLAlchemy或者处理一些带有复杂类型注解的对象时类型信息可能会作为对象的属性被保存下来。import json from dataclasses import dataclass from typing import List dataclass class User: id: int name: str tags: List[str] # 这个类型注解在某些反射操作中可能会被获取到 user User(id1, nameAlice, tags[admin, active]) # 假设某个库的内部操作错误地收集了字段的类型对象而不是值 some_metadata { field_types: { id: int, # 类对象 name: str, # 类对象 tags: List # 类对象注意这里是 typing.List也是一个类型对象 } } json.dumps(some_metadata) # 报错2.3 场景三调试或日志记录时包含上下文信息在写调试信息或日志时为了提供完整上下文你可能会把当前作用域的所有局部变量locals()或全局变量globals()打包记录。这些字典里几乎必然包含大量的模块、类、函数对象。import json def process_data(data): local_vars locals().copy() # 这里会包含函数参数、以及本作用域定义的所有对象 # ... 一些处理逻辑 ... # 错误地尝试记录所有局部变量 log_entry { timestamp: 2023-10-27, level: DEBUG, context: local_vars # local_vars 里可能包含 data 参数如果data是复杂对象其类型信息可能导致问题 } # 如果 data 本身是一个类或者 local_vars 包含了其他不可序列化的对象这里就会失败 # json.dumps(log_entry)2.4 场景四使用__dict__序列化自定义类对象这是另一个经典误区。很多人知道可以用obj.__dict__来获取对象的属性字典然后序列化这个字典。但是如果这个对象的某个属性值恰好是一个类型、函数或其他不可序列化的对象呢import json class Plugin: def __init__(self, name, processor): self.name name self.processor processor # processor 可能是一个函数 def custom_processor(x): return x * 2 plugin Plugin(Multiplier, custom_processor) # 尝试序列化 plugin 对象 data plugin.__dict__ # {name: Multiplier, processor: function custom_processor at 0x...} json_str json.dumps(data) # 报错因为 processor 的值是一个函数对象。3. 解决方案定制你的JSON编码器知道了原因解决办法的核心思路就是扩展或替换默认的“翻译官”教会它如何处理type对象或者在遇到无法翻译的对象时提供一个安全的替代品如转换成字符串或直接跳过。3.1 方法一使用default参数进行简单处理json.dumps()函数有一个default参数它接受一个函数。当序列化器遇到无法处理的对象时就会调用这个函数并传入该对象。这个函数需要返回一个可以被JSON序列化的值如字典、列表、字符串、数字或者抛出一个TypeError。方案A将类型对象转换为其名称字符串这是最直观的方法把int变成class int或简单的int。import json def default_serializer(obj): # 如果对象是类型类 if isinstance(obj, type): return obj.__name__ # 返回类名如 int, list, MyClass # 如果对象是函数或方法 elif callable(obj): return ffunction {obj.__name__} # 如果对象是模块 elif hasattr(obj, __name__): return fmodule {obj.__name__} # 对于其他无法处理的对象按默认行为抛出 TypeError raise TypeError(fObject of type {type(obj).__name__} is not JSON serializable) # 测试用例 config { name: Test, type_field: int, func_field: default_serializer, normal_field: [1, 2, 3] } try: json_str json.dumps(config, defaultdefault_serializer, indent2) print(json_str) except TypeError as e: print(fSerialization failed: {e})输出结果{ name: Test, type_field: int, func_field: function default_serializer, normal_field: [ 1, 2, 3 ] }注意这种方法的缺点是丢失了原始对象的引用。反序列化后你得到的是字符串int而不是真正的int类。这通常只适用于日志记录、显示等不需要还原原始对象的场景。方案B过滤掉不可序列化的对象有时你只关心那些可以被序列化的数据对于不可序列化的部分直接忽略可能比转换更合适。import json def filter_serializable(obj): 尝试序列化如果失败则返回一个标记或None try: # 尝试用默认编码器序列化如果成功则原样返回 json.dumps(obj) return obj except TypeError: # 序列化失败返回一个占位符 return None # 或者 return [Unserializable Object] def default_skip(obj): # 对于不可序列化的对象直接返回 Nonejson.dumps 会将其序列化为 null # 更激进的做法是抛出一个特定的异常然后在外层循环中过滤但这样更简单 if isinstance(obj, (type, types.FunctionType, types.ModuleType)): return None # 对于其他复杂对象也可以选择返回其字符串表示 return str(obj) # 但是default函数需要处理单个值过滤整个结构需要递归。 # 更通用的做法是在序列化之前先递归地清理你的数据结构。 def clean_for_json(data): if isinstance(data, dict): return {k: clean_for_json(v) for k, v in data.items() if not isinstance(v, (type, types.FunctionType))} elif isinstance(data, list): return [clean_for_json(item) for item in data if not isinstance(item, (type, types.FunctionType))] else: # 如果是可序列化的基本类型原样返回 try: json.dumps(data) return data except TypeError: return str(data) # 或者 return None config { name: Test, type_field: int, func_field: filter_serializable, list_field: [str, bool, 100] } clean_config clean_for_json(config) json_str json.dumps(clean_config, indent2) print(json_str)3.2 方法二继承json.JSONEncoder创建自定义编码器对于更复杂、需要复用的序列化逻辑继承json.JSONEncoder并重写其default方法是更规范、更强大的做法。import json import types import datetime class ExtendedJSONEncoder(json.JSONEncoder): 扩展的JSON编码器支持处理类型、函数、日期等常见不可序列化对象。 def default(self, obj): # 处理类型类对象 if isinstance(obj, type): # 返回一个包含模块和类名的字典便于识别 return { __class__: obj.__name__, __module__: obj.__module__ } # 处理函数和方法对象 elif isinstance(obj, (types.FunctionType, types.MethodType)): return { __callable__: obj.__name__, __module__: obj.__module__ if hasattr(obj, __module__) else builtin } # 处理日期时间对象这是一个常见的扩展需求 elif isinstance(obj, (datetime.date, datetime.datetime)): return obj.isoformat() # 处理集合set对象 elif isinstance(obj, set): return list(obj) # 处理numpy数组等如果需要 # elif hasattr(obj, tolist): # 例如 numpy.ndarray # return obj.tolist() # 对于其他类型调用父类的default方法最终会抛出TypeError return super().default(obj) # 使用自定义编码器 encoder ExtendedJSONEncoder() data { project: Demo, allowed_types: [int, str, list], processor: filter_serializable, # 前面定义的函数 created_at: datetime.datetime.now(), unique_ids: {1, 2, 2, 3} } try: json_str encoder.encode(data) # 或者使用 json.dumps(data, clsExtendedJSONEncoder) print(json_str) except TypeError as e: print(fSerialization failed: {e})输出示例{ project: Demo, allowed_types: [ { __class__: int, __module__: builtins }, { __class__: str, __module__: builtins }, { __class__: list, __module__: builtins } ], processor: { __callable__: filter_serializable, __module__: __main__ }, created_at: 2023-10-27T10:30:00.123456, unique_ids: [ 1, 2, 3 ] }提示这种方法的优势在于结构清晰且可以通过在反序列化时实现对应的object_hook函数尝试将{__class__: int, __module__: builtins}这样的标记字典还原回对象尽管对于内置类型和函数完全还原通常很困难或不可能但至少保留了信息。这对于配置文件的保存和读取非常有用。4. 实战排查与调试技巧当错误发生时仅仅看到TypeError: Object of type ‘type‘ is not JSON serializable是不够的你需要快速定位是数据结构中的哪个具体字段出了问题。4.1 技巧一使用递归检查器定位罪魁祸首写一个小工具递归遍历你的数据结构并尝试对每个叶子节点进行序列化测试。import json def find_offending_item(obj, path): 递归查找导致JSON序列化失败的具体项及其路径。 # 先尝试序列化当前对象本身 try: json.dumps(obj) # 如果当前对象可序列化且是容器则继续检查其子项 if isinstance(obj, dict): for k, v in obj.items(): new_path f{path}.{k} if path else k find_offending_item(v, new_path) elif isinstance(obj, (list, tuple, set)): for i, item in enumerate(obj): new_path f{path}[{i}] find_offending_item(item, new_path) except TypeError as e: # 如果当前对象不可序列化且不是容器或者容器内所有元素都检查过了则打印路径 if not isinstance(obj, (dict, list, tuple, set)): print(fFound offending item at path: {path} - Type: {type(obj)}, Value: {obj}) else: # 对于容器错误信息可能指向容器本身但根本原因在内部。上面的递归会找到具体项。 # 如果容器本身因为其他原因如自定义类不可序列化也会在这里被捕获。 print(fContainer at path {path} is not serializable. Reason: {e}) # 可以选择重新抛出异常以停止或者继续查找其他分支 # raise # 使用示例 problematic_data { ok_field: value, nested: { number: 42, dangerous: int, # 问题在这里 list_ok: [1, 2, 3] }, another_bad: [str, dict] } find_offending_item(problematic_data)运行上述代码你会得到清晰的输出直接指出问题所在的路径Found offending item at path: nested.dangerous - Type: class type, Value: class int Found offending item at path: another_bad[0] - Type: class type, Value: class str Found offending item at path: another_bad[1] - Type: class type, Value: class dict4.2 技巧二在自定义编码器的default方法中添加调试信息在开发自定义编码器时可以在default方法中打印日志记录它处理了哪些非常规对象。import json import logging logging.basicConfig(levellogging.DEBUG) class DebugJSONEncoder(json.JSONEncoder): def default(self, obj): logging.debug(fJSONEncoder.default called with object: {obj}, type: {type(obj)}) if isinstance(obj, type): logging.info(fConverting type object {obj} to string.) return obj.__name__ # ... 其他处理逻辑 ... return super().default(obj) # 这样在序列化时你就能在日志中看到编码器每一步的处理过程。4.3 技巧三使用try-except包裹并输出更友好的错误信息在生产环境中你可能不希望程序因为一个序列化错误而崩溃而是希望记录错误并可能返回一个降级的结果。import json import traceback def safe_json_dumps(data, default_handlerNone, indentNone): 安全的JSON序列化函数。 Args: data: 要序列化的数据。 default_handler: 自定义的default处理函数。 indent: 缩进格式。 Returns: 成功则返回JSON字符串失败则返回包含错误信息的字典字符串。 try: if default_handler: return json.dumps(data, defaultdefault_handler, indentindent) else: return json.dumps(data, indentindent) except TypeError as e: # 记录详细的错误日志 error_detail { error: JSON serialization failed, message: str(e), traceback: traceback.format_exc() } # 返回一个包含错误信息的JSON字符串而不是让程序崩溃 return json.dumps(error_detail) result safe_json_dumps({bad: int}) print(result) # 输出{error: JSON serialization failed, message: Object of type type is not JSON serializable, ...}5. 进阶处理更复杂的对象与架构设计建议5.1 处理带有循环引用的对象图有时你的对象之间可能存在循环引用A引用BB又引用A。json.dumps()默认无法处理这种情况会引发RecursionError。自定义编码器需要能够检测并打破这种循环。import json class ComplexEncoder(json.JSONEncoder): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._seen set() # 记录已序列化对象的id def default(self, obj): obj_id id(obj) if obj_id in self._seen: # 如果已经见过这个对象返回一个引用标记避免无限递归 return {$ref: str(obj_id)} self._seen.add(obj_id) if isinstance(obj, type): return {__type__: obj.__name__} elif hasattr(obj, __dict__): # 对于普通对象序列化其 __dict__并递归处理 # 注意这里简化处理实际中需要更精细的控制 return {k: self.encode(v) for k, v in obj.__dict__.items()} # 使用self.encode进行递归 else: return super().default(obj) def encode(self, obj): # 重写encode在每次编码前清空或重置_seen集合 # 注意这个简单实现不适用于嵌套多次调用encode的情况。 self._seen set() return super().encode(obj) # 注意上面的实现是一个简化示例处理循环引用和复杂对象序列化是一个深水区 # 通常需要借助如 jsonpickle 或 dill 等第三方库。强烈建议如果你的数据结构非常复杂包含循环引用、自定义类实例、函数等并且需要完整的序列化/反序列化即能还原成原来的Python对象不要重新发明轮子。考虑使用专门的对象序列化库例如pickle/dill Python标准库pickle及其扩展dill可以序列化几乎任何Python对象但生成的格式是Python特有的不安全且不同Python版本间可能不兼容。jsonpickle 一个将复杂对象序列化为JSON的库可以处理循环引用和许多内置类型。 选择哪种方案取决于你的需求是否需要跨语言JSON、是否需要安全性避免执行任意代码、是否需要保存完整的对象状态。5.2 架构设计建议数据层与逻辑层分离从根本上避免此类问题的最佳实践是在软件设计时进行清晰的关注点分离。定义纯数据对象DTO, Data Transfer Object用于网络传输、磁盘存储、配置文件的数据结构应该只包含JSON原生支持的数据类型字典、列表、字符串、数字、布尔、None。可以使用dataclasses、pydantic或attrs库来定义和验证这些结构。from dataclasses import dataclass, asdict from typing import List, Optional import json dataclass class AppConfig: name: str version: float features: List[str] timeout: Optional[int] None config AppConfig(nameMyApp, version2.1, features[auth, api], timeout30) # 转换为纯字典然后序列化 config_dict asdict(config) json_str json.dumps(config_dict) # 安全因为所有字段都是基本类型将逻辑对象函数、类与配置数据分开存储不要将函数引用、类对象直接放在配置字典里。而是存储它们的“标识符”如字符串名称然后在代码中通过映射registry来查找和调用。# 不好的做法 config { action: open # 函数对象 } # 好的做法 ACTION_REGISTRY { open: open, read: lambda f: f.read(), custom: my_custom_function } config { action: open # 字符串标识符 } # 使用时 action_name config[action] if action_name in ACTION_REGISTRY: func ACTION_REGISTRY[action_name] # 调用 func(...) else: raise ValueError(fUnknown action: {action_name})使用专门的配置格式对于复杂的配置考虑使用YAML或TOML格式它们对数据类型的表达能力比JSON稍强如日期并且有成熟的Python库如pyyaml,toml支持。但这些格式同样无法直接存储Python对象。6. 总结与个人经验处理TypeError: Object of type ‘type‘ is not JSON serializable的关键在于理解JSON的局限性以及你数据的复杂性。在多年的开发中我总结出以下几点心得预防优于治疗在架构设计初期就明确哪些数据是需要持久化或传输的并严格使用只包含基本类型的数据结构DTO来表示它们。使用pydantic进行数据验证和解析能在早期发现类型不匹配的问题。自定义编码器是利器但要慎用default参数和自定义JSONEncoder非常强大可以优雅地处理边缘情况。但过度使用会让序列化/反序列化逻辑变得复杂且难以维护。通常将其用于处理有限的几种已知类型如datetime,Decimal,UUID是理想的。对于任意的类或函数最好考虑将其转换为纯数据表示。调试时一定要定位到具体字段不要对着庞大的数据结构发愁。使用类似上面find_offending_item的递归检查函数可以瞬间 pinpoint 问题的根源节省大量时间。区分“展示”和“还原”如果你序列化的目的只是为了日志记录、前端展示或调试那么将不可序列化对象转换成字符串如class int是完全可接受的。但如果后续还需要从JSON中还原出完整的Python对象状态那么你需要一个更完善的方案如jsonpickle或者重新设计你的数据流。第三方库是你的朋友当问题超出json模块的基本能力时不要犹豫去寻找成熟的第三方库。marshmallow、pydantic用于验证和序列化、jsonpickle用于复杂对象图等库都经过了大量实战检验能帮你处理更复杂的场景。最后记住这个错误本身是一个“保护机制”它迫使你思考数据的边界和系统的设计。每一次解决它都可能让你对程序的数据流有更深的理解。