https://www.cnblogs.com/ybjourney/p/14295872.html https://zhuanlan.zhihu.com/p/378294204 https://zhuanlan.zhihu.com/p/311160583 https://mp.weixin.qq.com/s/FsjFt7ZHG5AXhChghKn8qQ

对象是类的实例 类是type的实例 type() 接收三个参数：类的名称、父类(tuple形式传入)、绑定的方法或者属性

MetaClass

元类可以理解为是type的子类，继承type，重载call方法，目的是可以在创建类对象的时候作出一些修改 元类的作用过程：

  1. 拦截类的创建
  2. 拦截后，进行修改
  3. 修改完后，返回修改后的类

示例1:创建类时修改类的属性为大写

  1. class TestMetaClass(type):
  3.     # def __init__(self, name, class_bases, class_dict):
  4.     #     logger("this is metaclass __init__ func")
  5.     #     logger(f"class name: {name}")
  6.     #     logger(f"class parents as a tuple: {class_bases}")
  7.     #     logger(f"包含类主体定义的命名空间并且会被复制到一个标准字典成为 __dict__ 属性:{class_dict}")
  9.     #     super().__init__(name, class_bases, class_dict)
  11.     # # metaclass中__call__方法负责对象的创建，这就是为什么要重新定义的原因
  12.     # def __call__(cls, *args, **kwargs):
  13.     #     logger("this is metaclass __call__ func")
  14.     #     self = super().__call__(*args, **kwargs)
  15.     #     return self
  17.     def __new__(cls, class_name, class_parents, class_attr):
  18.         logger("this meteclass __new__ func")
  20.         # 将类中非__开头的属性修改为大写
  21.         new_attr = {}
  22.         for name, value in class_attr.items():
  23.             logger(f"name={name}, value={value}")
  24.             if not name.startswith("__"):
  25.                 new_attr[name.upper()] = value
  26.         logger(f"new_attr:{new_attr}")
  27.         # 调用超类的 __new__() 并返回
  28.         return super(TestMetaClass, cls).__new__(cls, class_name, class_parents, new_attr)
  32. class B(metaclass=TestMetaClass):
  34.     def __init__(self, *args, **kwargs):
  35.         logger("this is class __init__ func")
  36.         super().__init__()
  38.     def __new__(cls, *args, **kwargs):
  39.         logger("this is class __new__ func")
  40.         self = super().__new__(cls)
  41.         return self
  43.     def func1(self):
  44.         logger("this is class instance func")
  46. B()
  47. B().FUNC1()
  50. # [I 220520 18:03:01 debug:47] this meteclass __new__ func
  51. # [I 220520 18:03:01 debug:50] name=__module__, value=__main__
  52. # [I 220520 18:03:01 debug:50] name=__qualname__, value=B
  53. # [I 220520 18:03:01 debug:50] name=__init__, value=<function B.__init__ at 0x7f6107b77ae8>
  54. # [I 220520 18:03:01 debug:50] name=__new__, value=<function B.__new__ at 0x7f6107b77b70>
  55. # [I 220520 18:03:01 debug:50] name=func1, value=<function B.func1 at 0x7f6107b77bf8>
  56. # [I 220520 18:03:01 debug:50] name=__classcell__, value=<cell at 0x7f6108413198: empty>
  57. # [I 220520 18:03:01 debug:53] new_attr:{'FUNC1': <function B.func1 at 0x7f6107b77bf8>}
  58. # [I 220520 18:03:01 debug:72] this is class instance func

示例2: ORM框架设计

想要实现如下通过将关系数据库的一行映射为一个对象的操作，如下：

  1. class Field(object):
  2.     """定义Field类，它负责保存数据库表的字段名和字段类型"""
  4.     def __init__(self, name, column_type):
  5.         self.name = name
  6.         self.column_type = column_type
  9.     def __str__(self):
  10.         return "<%s: %s>" % (self.__class__.__name__, self.name)
  13. class IntegerField(Field):
  15.     def __init__(self, name):
  16.         super(IntegerField, self).__init__(name, "bigint")
  19. class StringField(Field):
  21.     def __init__(self, name):
  22.         super(StringField, self).__init__(name, "varchar(100)")
  25. class ModelMetaClass(type):
  26.     """orm模型元类"""
  28.     def __new__(cls, name, bases, attrs):
  29.         if name == "Model":
  30.             return type.__new__(cls, name, bases, attrs)
  31.         logger(f"Found model: {name}")
  32.         logger(f"attrs:{attrs}")
  34.         mappings = {}
  35.         for k, v in attrs.items():
  36.             # 如果找到一个Field属性，就把它保存到一个__mappings__的dict中，同时从类属性中删除该Field属性（避免实例的属性遮盖类的同名属性）
  37.             if isinstance(v, Field):
  38.                 logger(f"Found mappings : {k} ==> {v}")
  39.                 mappings[k] = v
  40.         for k in mappings.keys():
  41.             attrs.pop(k)
  42.         attrs["__mappings__"] = mappings    # 保存属性和列的映射关系
  43.         attrs.setdefault('__table__', name) # 当未定义__table__属性时，表名直接使用类名
  45.         return type.__new__(cls, name, bases, attrs)
  48. class Model(dict, metaclass=ModelMetaClass):
  49.     """Model 模型"""
  51.     def __init__(self, **kw):
  52.         """一个基类如果有 __init__() 方法，则其所派生的类如果也有 __init__() 方法，
  53.         就必须显式地调用它以确保实例基类部分的正确初始化；例如: super().__init__([args...])."""
  54.         super(Model, self).__init__(**kw)
  56.     def __getattr__(self, key):
  57.         """当对象的属性不存在时调用"""
  58.         try:
  59.             logger(f"{key}, call __getattr__ func")
  60.             return self[key]
  61.         except KeyError:
  62.             return AttributeError(f"'Model' object has no attribute {key}")
  64.     def __setattr__(self, key, value):
  65.         """属性被赋值时调用"""
  67.         logger(f"{key}={value}, call __setattr__ func")
  68.         self[key] = value
  70.     def save(self):
  72.         fields = []
  73.         params = []
  74.         args = []
  75.         for k, v in self.__mappings__.items():
  76.             fields.append(v.name)
  77.             params.append("?")
  78.             args.append(getattr(self, k, None))
  79.         sql = f"insert into {self.__table__} ({','.join(fields)}) values ({','.join(params)})"
  80.         logger(f"sql={sql}")
  81.         logger(f"args={args}")
  82.         logger(f"params={params}")
  85. class User(Model):
  87.     # 定义类的属性到列的映射
  88.     id = IntegerField("id")
  89.     name = StringField('username')
  91. # 创建一个实例
  92. user = User(id=123456, name="zaygee")
  94. # 保存到数据库
  95. user.save()
  98. # [I 220520 18:57:05 debug:123] Found model: User
  99. # [I 220520 18:57:05 debug:124] attrs:{'__module__': '__main__', '__qualname__': 'User', 'id': <__main__.IntegerField object at 0x7fb6fc19c7f0>, 'name': <__main__.StringField object at 0x7fb6fc19c828>}
  100. # [I 220520 18:57:05 debug:130] Found mappings : id ==> <IntegerField: id>
  101. # [I 220520 18:57:05 debug:130] Found mappings : name ==> <StringField: username>
  102. # [I 220520 18:57:05 debug:151] id, call __getattr__ func
  103. # [I 220520 18:57:05 debug:151] name, call __getattr__ func
  104. # [I 220520 18:57:05 debug:172] sql=insert into User (id,username) values (?,?)
  105. # [I 220520 18:57:05 debug:173] args=[123456, 'zaygee']
  106. # [I 220520 18:57:05 debug:174] params=['?', '?']

使用init_subclass 替换元类

1、当所在类派生子类时此方法就会被调用。cls 将指向新的子类。如果定义为一个普通实例方法，此方法将被隐式地转换为类方法 2、 传入一个新类的关键字参数会被传给父类的 init_subclass。为了与其他使用 init_subclass 的类兼容，应当根据需要去掉部分关键字参数再将其余的传给基类 3、 这个方法隐式地被 @classmethod 装饰

  1. class Validator:
  2.     """校验器基类： 统一注册所有校验器类"""
  4.     _validators = {}
  6.     def __init_subclass__(cls, **kwargs):
  7.         print('{} 注册额外参数: {}'.format(cls.__name__, kwargs))
  8.         Validator._validators[cls.__name__] = cls
  10. # 派生子类
  11. class StringValidator(Validator, foo='bar'):
  12.     name = 'string'
  14. # StringValidator 注册额外参数: {'foo': 'bar'}
  15. # {'StringValidator': <class '__main__.StringValidator'>}
  16. print(Validator._validators)
  18. # {'StringValidator': <class '__main__.StringValidator'>}
  19. print(StringValidator()._validators)
  24. class Philosopher:
  25.     """当有子类继承了 Philosopher ，那么 __init_subclass__ 就会调用"""
  27.     def __init_subclass__(cls, default_name, **kwargs):
  28.         print("call __init_subclass__ func, default_name is", default_name)
  30.         for k, v in kwargs.items():
  31.             type.__setattr__(cls, k, v)
  33. class AustralianPhilosopher(Philosopher, default_name="Bruce", name="zaygee"):
  34.     pass
  36. # call __init_subclass__ func, default_name is Bruce
  37. # <class '__main__.Philosopher'>
  38. print(Philosopher)
  39. print(AustralianPhilosopher.name)   # zaygee