Python中子对象初始化及子类实例继承父类实例的实现方法

嘿，这两个问题都是Python面向对象编程里很实用的场景，我来给你详细拆解一下～

这里说的“子对象”，其实就是指某个类的实例属性是另一个类的实例。根据不同的场景，有几种常见的初始化方式：

• 在构造方法中直接创建子对象
  如果子对象的创建逻辑固定，或者不需要外部干预，可以直接在当前类的__init__方法里实例化子对象。举个例子：

  class Address:
      def __init__(self, street, city):
          self.street = street
          self.city = city
  
  class User:
      def __init__(self, name, street, city):
          self.name = name
          # 直接初始化Address类型的子对象
          self.address = Address(street, city)
  

• 通过参数传入已初始化的子对象
  这种方式更灵活，允许外部控制子对象的创建逻辑（比如复用已有实例、注入不同实现）：

  class User:
      def __init__(self, name, address):
          self.name = name
          self.address = address  # 接收外部传入的Address实例
  
  # 使用时先创建子对象，再传给父对象
  my_addr = Address("Sunset Blvd", "Los Angeles")
  my_user = User("Bob", my_addr)
  

• 延迟初始化（懒加载）
  如果子对象创建开销大，或者不一定会被用到，可以在第一次访问时才初始化，节省资源：

  class User:
      def __init__(self, name, street, city):
          self.name = name
          self._street = street
          self._city = city
          self._address = None  # 先占位，暂不初始化
  
      @property
      def address(self):
          if self._address is None:
              # 第一次访问时才创建子对象
              self._address = Address(self._street, self._city)
          return self._address
  

这个需求的核心是把A实例x的所有状态（包括私有字段）完整复制到B实例y的父类部分。需要注意的是：Python的私有字段（以__开头）会被自动重命名为_类名__字段名（名字修饰），所以直接复制属性时要考虑这一点。

Python 3.x 实现方式 #

1. 通过__dict__复制属性
   直接把x的属性字典复制到y的属性字典里，同时初始化子类自己的属性：

   class A:
       def __init__(self, a):
           self.a = a
           self.__private = "top-secret"  # 私有字段，会被修饰为_A__private
   
   class B(A):
       def __init__(self, x, b):
           # 复制x的所有属性到当前实例
           self.__dict__.update(x.__dict__)
           # 初始化子类专属属性
           self.b = b
   
   # 测试
   x = A(100)
   y = B(x, 200)
   print(y.a)  # 输出 100
   print(y._A__private)  # 输出 "top-secret"（注意私有字段的访问方式）
   

2. 深拷贝处理可变属性
   如果x的属性包含可变对象（比如列表、字典），为了避免y和x共享同一可变状态，可以用深拷贝：

   import copy
   
   class B(A):
       def __init__(self, x, b):
           self.__dict__ = copy.deepcopy(x.__dict__)
           self.b = b
   

3. 处理带__slots__的类
   如果A类使用了__slots__（没有__dict__属性），需要遍历__slots__来逐个复制属性：

   class A:
       __slots__ = ('a', '__private')
       def __init__(self, a):
           self.a = a
           self.__private = "secret"
   
   class B(A):
       __slots__ = ('b',)
       def __init__(self, x, b):
           # 遍历A的槽位，复制属性
           for slot in A.__slots__:
               setattr(self, slot, getattr(x, slot))
           self.b = b
   

Python 2.x 实现方式 #

Python 2.x分新式类（继承自object）和经典类（不继承object），核心逻辑和Python3一致，只是语法细节略有不同：

1. 新式类场景

   class A(object):  # 必须显式继承object
       def __init__(self, a):
           self.a = a
           self.__private = "top-secret"
   
   class B(A):
       def __init__(self, x, b):
           self.__dict__.update(x.__dict__)
           self.b = b
   
   x = A(100)
   y = B(x, 200)
   print(y.a)  # 100
   print(y._A__private)  # "top-secret"
   

2. 经典类场景
   经典类没有__dict__的特殊限制，同样可以用__dict__.update或者遍历属性的方式复制状态，用法和新式类一致，只是类定义不需要继承object。

内容的提问来源于stack exchange，提问作者porton