序列化：

“序列化”最终就是把对象在内存中的 状态（通常是 __dict__ 里的键值对）
映射成纯文本（JSON 字符串）。

1. 对象 → 取 公开属性（__dict__）
2. 属性值 → 递归拆成 基本类型（str、int、list、dict…）
3. 基本类型 → 按 JSON 语法 → 纯文本

• __dict__ 里可能混有 datetime、Decimal、嵌套对象 —— 需要 钩子函数 或 类型判断 把它们“洗”成可 JSON 化的东西。
• 方法、私有属性、文件句柄等 不会也不能 进 JSON。
• “序列化” ≈ 把 __dict__ 洗干净后变成 JSON，但“洗”这一步才是工作量所在。
• • json 模块：跟我们自己手写一样，完全不保存方法、闭包、作用域——它只认“可 JSON 化的数据”。
  • pickle / marshal：这才是 Python 真正的“二进制序列化”库，它们会保存字节码、闭包、模块引用，但不再是文本，且跨版本/跨解释器有风险。

    • json（文本序列化）
      官方文档明确：
      “JSON can represent subsets of Python built-in types: dict, list, str, int, float, bool, None.”
      任何 function、method、lambda、code object、frame、generator、file、socket 都会直接 raise TypeError。
      对自定义类，只认 __dict__（或你提供的 default 钩子），不保存方法、闭包、局部变量。
      import json 
      def foo(): pass 
      json.dumps(foo) # TypeError: Object of type function is not JSON serializable
      
      
      

      pickle（二进制序列化）

      • 会保存函数、类、闭包、模块名、字节码、全局变量引用。
      • 反序列化时会重新 import 模块、重建闭包、绑定全局变量，因此能完整还原运行状态。
      • 代价：
        • 不是人类可读文本；
        • 只能由 相同 Python 版本、相同库环境 反序列化；
        • 存在安全风险（可执行代码）。

      • 想要 纯文本、跨语言、跨版本——用 json，就得接受“只存数据，不存代码”。
      • 想要 连函数、闭包、运行时状态一起打包——用 pickle，但要接受二进制和兼容性限制。

      在“把对象变成 JSON 文本”的语境下，方法、闭包、局部作用域 本来就 不应该、也无法 被序列化。

      ---

      为什么方法和闭包不序列化？
      1. 方法只是代码
         Python 里的函数、方法都是 代码对象（PyCodeObject），包含字节码、常量表、局部变量名……
         这些依赖于 解释器运行时环境（文件路径、依赖库、全局变量等）。
         把字节码塞到 JSON 里，别的进程甚至同一台机子下一次启动都还原不了。
      2. 闭包本质是“代码 + 捕获的外部变量”
         闭包捕获的变量可能在 栈帧 或 模块全局空间，它们的生命周期、地址在运行结束后就失效。
         想完整保存闭包，需要把 整段代码 + 外部变量快照 都打包——这已经超出 JSON 的范畴，进入 pickle / cloudpickle 这类二进制序列化领域。
      3. JSON 设计目标就是“数据”
         JSON 只支持：
         • 基本类型（str、int、float、bool、null）
         • 数组 []
         • 对象 {}
           它天生不包含“可执行代码”语义。
           因此方法、闭包、生成器、文件句柄、锁、socket 等 运行时资源 都 不可 JSON 化。
         • 如果你确实需要“连代码一起带走”
           • 用 pickle / cloudpickle / dill（二进制）
             它们能把函数、闭包、类、模块引用打包，但不再可读，且 版本/环境敏感。

             • 手写 JSON 序列化器。
               import json
               from datetime import datetime
               from decimal import Decimal
               
               def default(obj, _seen=None):
                   if _seen is None:
                       _seen = set()
                   oid = id(obj)
                   if oid in _seen:                       # 防循环
                       return f"<CircularRef:{type(obj).__name__}>"
                   _seen.add(oid)
               
                   # 1) 基本可 JSON 类型
                   if isinstance(obj, (str, int, float, bool)) or obj is None:
                       return obj
               
                   # 2) 日期 / Decimal 等常用扩展
                   if isinstance(obj, datetime):
                       return obj.isoformat()
                   if isinstance(obj, Decimal):
                       return float(obj)
               
                   # 3) list / tuple → 递归列表
                   if isinstance(obj, (list, tuple)):
                       return [default(x, _seen) for x in obj]
               
                   # 4) dict → 递归键值
                   if isinstance(obj, dict):
                       return {default(k, _seen): default(v, _seen) for k, v in obj.items()}
               
                   # 5) 其它任何对象 → 反射取公开字段
                   #    过滤掉私有属性（以 _ 开头）和方法
                   fields = {
                       k: default(v, _seen)
                       for k, v in vars(obj).items()
                       if not (k.startswith("_") or callable(v))
                   }
                   # 顺便把类名放进去，方便调试
                   fields["__class__"] = type(obj).__name__
                   return fields
               
               
               # ------------------ 测试 ------------------
               class Address:
                   def __init__(self, city, street):
                       self.city, self.street = city, street
               
               class User:
                   def __init__(self, id_, name, addr, score):
                       self.id = id_
                       self.name = name
                       self.addr = addr
                       self.score = Decimal(score)
                       self.created = datetime.now()
               
               addr = Address("北京", "长安街")
               user = User(1, "张三", addr, "99.5")
               
               print(json.dumps(user, default=default, ensure_ascii=False, indent=2))
               
               核心思路
               反射拿到实例的所有 公开字段（vars(obj) 或 __dict__）。
               递归时：
               遇到 基本类型 → 直接返回
               遇到 list / dict / tuple → 继续递归
               遇到 自定义类实例 → 再次反射它的 __dict__
               防循环引用 用 id(obj) 集合。
               遇到无法 JSON 化的类型（datetime、Decimal…）→ 统一钩子处理。