Python元类-JXin的博客

学习笔记说明

这是一篇Python的学习笔记，关于Python元类，仅做记录

类的创建过程
自定义元类
深入：元类的查找顺序
总结
作业
作业答案

类的创建过程

使用 class 关键字定义类时，Python 底层会调用元类来创建类：

class Dog:
    pass

# 等效于
class Dog(metaclass=type):
    pass

# 等效于
Dog = type("Dog", (), {})

# 等效于
Dog = type.__call__(type, "Dog", (), {})

1
2
3
4
5
6
7
8
9
10
11
12

也就是说，class 关键字只是语法糖，底层仍然是通过 type() 创建类。

自定义元类

通过继承 type，可以自定义元类，控制类的创建过程。

class MyMeta(type):
    def __new__(mcs, name, bases, namespace):
        print(f"正在创建类: {name}")
        print(f"父类: {bases}")
        print(f"属性: {list(namespace.keys())}")

        # 必须调用 type.__new__ 来真正创建类
        cls = super().__new__(mcs, name, bases, namespace)
        return cls

# 使用 metaclass 参数指定元类
class Dog(metaclass=MyMeta):
    species = "Canis familiaris"

    def bark(self):
        print("Woof!")

# 等效于
# def bark(self):
#     print("Woof!")

# Dog = type.__call__(MyMeta, "Dog", (), {"species": "Canis familiaris", "bark": bark})

# 输出：
# 正在创建类: Dog
# 父类: ()
# 属性: ['__module__', '__qualname__', 'species', 'bark']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

参数说明：

mcs：元类自身（类似类方法中的 cls）
name：类名字符串
bases：父类元组
namespace：类属性的字典

深入：元类的查找顺序

子类会继承父类的元类：

class MyMeta(type):
    pass

class Base(metaclass=MyMeta):
    pass

class Child(Base):  # 自动继承 MyMeta
    pass

print(type(Child))  # <class '__main__.MyMeta'>

1
2
3
4
5
6
7
8
9
10

如果父类元类不兼容，需要使用更通用的元类：

class MetaA(type):
    pass

class MetaB(type):
    pass

class A(metaclass=MetaA):
    pass

class B(metaclass=MetaB):
    pass

# class C(A, B): pass  # TypeError! 元类冲突

# 解决方法：创建兼容的元类
class CommonMeta(MetaA, MetaB):
    pass

class C(A, B, metaclass=CommonMeta):  # 正常
    pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

总结

概念	说明
元类	创建类的类，默认是 `type`
`__new__`	创建类，返回类对象
`__init__`	初始化类，无返回值
`__call__`	控制类的实例化过程
应用场景	命名检查、自动注册、方法增强、ORM 等

作业

一、实现单例元类

编写一个元类 SingletonMeta，使得任何使用该元类的类都自动成为单例模式：

class SingletonMeta(type):
    # 你的代码
    pass

class Database(metaclass=SingletonMeta):
    def __init__(self, host):
        self.host = host

db1 = Database("localhost")
db2 = Database("remote")
print(db1 is db2)  # 应该输出 True
print(db1.host)    # 应该输出 localhost

1
2
3
4
5
6
7
8
9
10
11
12

二、自动注册子类

编写一个元类 PluginMeta，使得任何继承自 Plugin 的子类都会被自动注册到 PluginMeta.registry 字典中（键为类名，值为类本身）：

class PluginMeta(type):
    # 你的代码
    pass

class Plugin(metaclass=PluginMeta):
    pass

class ImagePlugin(Plugin):
    pass

class TextPlugin(Plugin):
    pass

print(PluginMeta.registry)
# 应该输出类似：{'ImagePlugin': <class '__main__.ImagePlugin'>, 'TextPlugin': <class '__main__.TextPlugin'>}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、为所有方法添加日志

编写一个元类 LogMeta，自动为类中每个非私有方法（即不以 _ 开头的方法）添加执行日志。调用方法时，先打印 [LOG] 调用 {方法名}，再执行原方法：

class LogMeta(type):
    # 你的代码
    pass

class Calculator(metaclass=LogMeta):
    def add(self, a, b):
        return a + b
    
    def sub(self, a, b):
        return a - b

calc = Calculator()
print(calc.add(3, 5))
print(calc.sub(10, 4))

# 应该输出：
# [LOG] 调用 add
# 8
# [LOG] 调用 sub
# 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

作业答案

一、实现单例元类

class SingletonMeta(type):
    _instance = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instance:
            cls._instance[self] = super().__call__(*args, **kwargs)
        return cls._instance[self]
    pass

class Database(metaclass=SingletonMeta):
    def __init__(self, host):
        self.host = host

db1 = Database("localhost")
db2 = Database("remote")
print(db1 is db2)  # 应该输出 True
print(db1.host)  # 应该输出 localhost

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

二、自动注册子类

class PluginMeta(type):
    registry = {}
    def __new__(mcs, name, bases, namespace):
        cls = super().__new__(mcs, name, bases, namespace)
        mcs.registry[name] = cls
        return cls
    pass

class Plugin(metaclass=PluginMeta):
    pass

class ImagePlugin(Plugin):
    pass

class TextPlugin(Plugin):
    pass

print(PluginMeta.registry)
# 应该输出类似：{'ImagePlugin': <class '__main__.ImagePlugin'>, 'TextPlugin': <class '__main__.TextPlugin'>}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

三、为所有方法添加日志

class LogMeta(type):
    def __new__(mcs, name, bases, namespace):
        for name, method in namespace.items():
            if not name.startswith("__") and callable(method):
                namespace[name] = mcs.log_call(method)
        cls = super().__new__(mcs, name, bases, namespace)
        return cls

    @staticmethod
    def log_call(func):
        def wrapper(self, *args, **kwargs):
            print(f"[LOG] 调用 {func.__name__}")
            return func(self, *args, **kwargs)
        return wrapper
    pass

class Calculator(metaclass=LogMeta):
    def add(self, a, b):
        return a + b
    
    def sub(self, a, b):
        return a - b

calc = Calculator()
print(calc.add(3, 5))
print(calc.sub(10, 4))

# 应该输出：
# [LOG] 调用 add
# 8
# [LOG] 调用 sub
# 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32