Python元类

1、概念

在Python中，一切皆对象。你定义的类（即使是内置类型）本身也是一种对象。既然类是对象，那么它们也必然由某个“东西”创建。这个创建类的“东西”就是元类（Metaclass）。

• 元类是创建类的类。普通类定义了实例对象的行为，而元类定义了类的行为。
  
• 默认情况下，Python中所有的类都是由内置元类type创建的
  

1. class MyClass:
2.     pass
4. print(type(MyClass))  # 输出：<class 'type'>
5. print(type(1))         # 输出：<class 'int'>
6. print(type("hello"))   # 输出：<class 'str'>

复制代码

2、元类的工作原理：类创建过程

当你使用 class关键字定义一个类时，Python在幕后执行了以下几步，只要理解类本身就是元类的实例，就容易理解调用__new__和__init__的时机：

• 收集类定义内容：解析类定义体，获取类名、基类和包含属性/方法的字典。
  
• 确定元类：检查是否指定了自定义元类（通过metaclass关键字），若无则使用默认的type。
  
• 执行元类的__new__方法：元类的__new__方法负责创建并返回这个类对象。这是干预类创建、修改类属性（如方法、类变量）的关键阶段。
  
• 执行元类的__init__方法：元类的__init__方法负责对创建好的类对象进行初始化。
  
• 将类对象绑定到类名：最终，创建的类对象被赋值给类定义头中的类名。
  

type函数除了可以查看对象的类型，还可以动态地创建类，其语法如下：

1. MyClass = type('MyClass', (BaseClass,), {'attribute': value, 'method': my_method})

复制代码

3、定义自定义元类

自定义元类通常通过继承type并重写其__new__或 __init__方法来实现，元类的__new__和 __init__方法在类定义阶段就被调用了
3.1 基本元类结构

1. class MyMeta(type):
2.     """自定义元类，继承自 type"""
3.    
4.     def __new__(cls, name, bases, attrs):
5.         """
6.         在类创建时调用
7.         - cls: 元类本身
8.         - name: 要创建的类名
9.         - bases: 父类元组
10.         - attrs: 类属性字典
11.         """
12.         print(f"创建类: {name}")
13.         print(f"父类: {bases}")
14.         print(f"属性: {list(attrs.keys())}")
15.         
16.         # 必须调用 type.__new__ 来实际创建类
17.         return super().__new__(cls, name, bases, attrs)
18.    
19.     def __init__(self, name, bases, attrs):
20.         """类初始化时调用"""
21.         super().__init__(name, bases, attrs)
22.         print(f"初始化类: {name}")
24. # 使用元类
25. class MyClass(metaclass=MyMeta):
26.     x = 42
27.    
28.     def method(self):
29.         return "hello"
31. # 输出:
32. # 创建类: MyClass
33. # 父类: ()
34. # 属性: ['__module__', '__qualname__', 'x', 'method']
35. # 初始化类: MyClass

复制代码

3.2 修改类定义

元类可以在类创建时修改其属性：

1. class UpperCaseMeta(type):
2.     """将类中所有非特殊属性名改为大写"""
3.    
4.     def __new__(cls, name, bases, attrs):
5.         # 过滤出需要修改的属性
6.         uppercase_attrs = {}
7.         for attr_name, attr_value in attrs.items():
8.             if not attr_name.startswith('__'):  # 不处理特殊方法
9.                 uppercase_attrs[attr_name.upper()] = attr_value
10.             else:
11.                 uppercase_attrs[attr_name] = attr_value
12.         
13.         return super().__new__(cls, name, bases, uppercase_attrs)
15. class MyClass(metaclass=UpperCaseMeta):
16.     my_attr = "value"
17.     another_attr = 42
18.    
19.     def my_method(self):
20.         return "original"
22. # 测试
23. obj = MyClass()
24. print(hasattr(obj, 'my_attr'))      # False
25. print(hasattr(obj, 'MY_ATTR'))      # True
26. print(hasattr(obj, 'my_method'))    # False  
27. print(hasattr(obj, 'MY_METHOD'))    # True

复制代码

4、使用场景

4.1 单例模式实现

由于类是元类的对象，因此实例化对象就类似于普通对象直接加()，就会调用元类的__call__方法

1. class SingletonMeta(type):
2.     """单例元类"""
3.     _instances = {}
5.     def __call__(cls, *args, **kwargs):
6.         if cls not in cls._instances:
7.             cls._instances[cls] = super().__call__(*args, **kwargs)
8.         return cls._instances[cls]
11. class DatabaseConnection(metaclass=SingletonMeta):
12.     def __init__(self, connection_string):
13.         self.connection_string = connection_string
14.         print(f"连接到数据库: {connection_string}")
15.    
16.     def query(self, sql):
17.         return f"执行查询: {sql}"
19. # 测试单例
20. db1 = DatabaseConnection("mysql://localhost:3306/mydb")
21. db2 = DatabaseConnection("mysql://localhost:3306/mydb")
23. print(db1 is db2)  # True
24. print(db1.query("SELECT * FROM users"))

复制代码

4.2 ORM（对象关系映射）框架

1. class Field:
2.     """字段基类"""
3.     def __init__(self, field_type, required=True, default=None):
4.         self.field_type = field_type
5.         self.required = required
6.         self.default = default
8. class CharField(Field):
9.     def __init__(self, max_length=255, **kwargs):
10.         super().__init__(str, **kwargs)
11.         self.max_length = max_length
13. class IntegerField(Field):
14.     def __init__(self, **kwargs):
15.         super().__init__(int, **kwargs)
17. class ModelMeta(type):
18.     """ORM 元类，用于收集字段信息"""
19.    
20.     def __new__(cls, name, bases, attrs):
21.         # 收集字段信息
22.         fields = {}
23.         for attr_name, attr_value in attrs.items():
24.             if isinstance(attr_value, Field):
25.                 fields[attr_name] = attr_value
26.                 # 从类属性中移除字段，避免干扰实例属性
27.                 attrs[attr_name] = None
28.         
29.         # 添加_fields属性保存字段信息
30.         attrs['_fields'] = fields
31.         
32.         return super().__new__(cls, name, bases, attrs)
34. class Model(metaclass=ModelMeta):
35.     """模型基类"""
36.    
37.     def __init__(self, **kwargs):
38.         for field_name, field in self._fields.items():
39.             value = kwargs.get(field_name, field.default)
40.             setattr(self, field_name, value)
41.    
42.     def validate(self):
43.         """验证字段值"""
44.         errors = []
45.         for field_name, field in self._fields.items():
46.             value = getattr(self, field_name)
47.             if value is None and field.required:
48.                 errors.append(f"{field_name} is required")
49.             elif value is not None and not isinstance(value, field.field_type):
50.                 errors.append(f"{field_name} must be {field.field_type.__name__}")
51.         return errors
53. # 使用元类创建模型，子类的创建会继承父类的元类
54. class User(Model):
55.     name = CharField(max_length=100)
56.     age = IntegerField(required=False, default=0)
57.     email = CharField(max_length=255)
59. # 测试
60. user = User(name="Alice", age=25, email="alice@example.com")
61. print(user.name)        # Alice
62. print(user.age)         # 25
63. print(user.validate())  # []
65. user2 = User(name="Bob")
66. print(user2.validate())  # ['email is required']

复制代码

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除