使用Python元类（metaclass）创建Python类

冷不防 2022-11-20 13:59 183阅读 0赞

Python类的定义再简单不过了。不过你有想过动态定义一个Python类吗？What？动态定义，是动态解析Python代码吗？不，这仍然是静态定义。我是说，干预类的创建过程，在类的创建过程中，对类中的一切东西动态干预，这个听起来很酷，那么到底是怎么做到的呢？继续看文章吧！

1. Python中的类

在理解元类之前，首先需要掌握Python的类。Python从Smalltalk语言中借用了一个非常特殊的类概念。

在大多数语言中，类只是描述如何产生对象的代码段。在Python中也是如此：

class ObjectCreator(object):
        pass
    my_object = ObjectCreator()
    print(my_object)

输出：<\_\_main\_\_.ObjectCreator object at 0x1055b03c8>

但在Python中，类本身也是对象。

当你使用class关键字时，Python就会执行class代码块中的代码，并创建一个对象。

class ObjectCreator(object):
        pass

这段代码在内存中创建了一个名为ObjectCreator的对象。这个对象（类）本身具有创建对象（实例）的能力，这就是为什么它是一个类。

但不管怎样，ObjectCreator仍然是一个对象，因此我们可以做如下事情：

（1）将ObjectCreator赋给一个变量；

（2）复制ObjectCreator；

（3）为ObjectCreator添加属性

（4）将ObjectCreator作为值参传入函数；

下面演示了ObjectCreator作为对象和类的使用过程:

class ObjectCreator(object):
        pass
    
    
    # 由于ObjectCreator是一个对象，所以可以打印ObjectCreator
    print(ObjectCreator)
    
    
    def echo(obj):
        print(obj)
    # 可以将ObjectCreator作为值参传入函数
    echo(ObjectCreator)
    
    
    # 判断ObjectCreator是否存在new_attribute属性
    print(hasattr(ObjectCreator, 'new_attribute'))
    # 为ObjectCreator动态添加属性
    ObjectCreator.new_attribute = 'value'
    # 判断ObjectCreator是否存在new_attribute属性
    print(hasattr(ObjectCreator, 'new_attribute'))
    
    
    # 将ObjectCreator赋给另一个变量
    ObjectCreatorMirror = ObjectCreator
    print(ObjectCreatorMirror.new_attribute)
    
    
    print(ObjectCreatorMirror())

执行这段代码，会输出如下结果：

<class '__main__.ObjectCreator'>
    <class '__main__.ObjectCreator'>
    False
    True
    value
    <__main__.ObjectCreator object at 0x105053780>

2. 动态创建Python类

由于类是对象，因此可以像创建任何对象一样动态创建类。

首先，可以使用class在函数中创建一个类：

# 将ObjectCreator赋给另一个变量
    ObjectCreatorMirror = ObjectCreator
    print(ObjectCreatorMirror.new_attribute)
    print(ObjectCreatorMirror())
    def choose_class(name):
        if name == 'foo':
            class Foo(object):
                pass
            return Foo # return the class, not an instance
        else:
            class Bar(object):
                pass
            return Bar
    
    
    MyClass = choose_class('foo')
    print(MyClass) # 函数返回一个类，而不是一个类的实例
    print(MyClass()) # 创建一个类实例

输出结果如下：

<class '__main__.choose_class.<locals>.Foo'>
    <__main__.choose_class.<locals>.Foo object at 0x10e905438>

尽管这段代码可以根据choose\_class函数的参数值返回不同的Python类，但这并不是动态的，因为仍然必须自己编写整个类。

由于类是对象，因此它们必须由某种东西生成。当使用class关键字时，Python会自动创建此对象。但与Python中大多数场景一样，为我们提供了一种手动进行操作的方法。

使用class关键字时，Python会自动创建此对象。但是，与Python中的大多数事情一样，它为您提供了一种手动进行操作的方法。

还记得type函数吗？该函数可以让你知道对象的类型。

# 获取函数的类型
    print(type(1))  # <type 'int'>
    print(type("1")) # <type 'str'>
    print(type(ObjectCreator))  # <type 'type'>
    print(type(ObjectCreator())) # <class '__main__.ObjectCreator'>

type函数的功能很多，giant函数可以动态创建类。type函数可以将类的描述作为参数，并返回一个类。

好吧，类型具有完全不同的能力，它也可以动态创建类。type可以将类的描述作为参数，并返回一个类。

type函数的原型如下：

type(name, bases, attrs)

参数的含义如下：

*  name: 类名；
 *  bases: 父类的元组（用于继承，可以为空）；
 *  attrs: 包含属性名称和值的字典；

例如，下面是一个Python类：

class MyShinyClass(object):
        pass

如果用动态的方法创建该类，可以使用下面的代码：

MyShinyClass = type('MyShinyClass', (), {}) # 返回类对象
    print(MyShinyClass) # 输出结果：<class '__main__.MyShinyClass'>
    print(MyShinyClass()) # 创建类的实例，输出结果：<__main__.MyShinyClass object at 0x8997cec>

你会注意到，我们使用“ MyShinyClass”作为类的名称和变量来保存类引用。它们可以不同，但是没有理由使事情复杂化。

type函数可以使用字典来定义类的属性：

class Foo(object):
        bar = True

可以使用下面的代码动态创建Foo类，并动态为该类添加名为bar的属性。

Foo = type('Foo', (), {'bar':True})

我们可以使用下面的代码正常使用Foo类：

# 使用Foo类
    print(Foo)  # 输出：<class '__main__.Foo'>
    print(Foo.bar)  # 输出：True
    f = Foo()
    print(f) # 输出：<__main__.Foo object at 0x8a9b84c>
    print(f.bar) # 输出：True

当然，Foo类同样可以被继承，代码如下：

class FooChild(Foo):
        pass

使用下面的代码可以动态创建继承至Foo类的FooChild类。

# 动态继承Foo
    FooChild = type('FooChild', (Foo,), {})
    print(FooChild) # 输出：<class '__main__.FooChild'>
    # bar属性来至于Foo类
    print(FooChild.bar)  # 输出：True

最后，你需要向类中添加方法。只需定义具有适当签名的函数并将其分配为属性即可。

# 向FooChild类动态添加echo_bar函数
    FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
    print(hasattr(Foo, 'echo_bar'))  # 输出：False
    print(hasattr(FooChild, 'echo_bar'))  # 输出：True
    my_foo = FooChild()
    my_foo.echo_bar()  # 输出：True

在动态创建类之后，可以向该类中添加更多方法，就像将方法添加到正常创建的类对象中一样。

def echo_bar_more(self):
        print('yet another method')
    FooChild.echo_bar_more = echo_bar_more
    print(hasattr(FooChild, 'echo_bar_more')) # 输出：True

看到这里，你应该了解了Python类的本质。类就是对象，可以像动态创建对象一样创建Python类。Python在使用class关键字时通过使用元类来完成创建类的过程。

3. 什么是元类（metaclass）

元类是创建类的“原料”。我们定义类是为了创建对象，而我们知道，Python类是对象，所以定义元类，就是为了创建类，也就是说，元类是类的类，可以通过下面的伪代码来描绘元类和类：

# 通过元类创建类
    MyClass = MetaClass()
    # 通过类创建类实例
    my_object = MyClass()

第1行代码其实相当于使用type函数动态创建MyClass类（或其他的类）

MyClass = type('MyClass', (), {})

之所以可以这么用，是因为type函数是Python用于在幕后创建所有类的元类。所以type是一个类，而不是一个普通的函数。

现在还有一个疑问，Python类的命名规则都是首字母大写，那么为什么type类是首字母小写呢？

我想这与str类创建字符串对象和int类创建整数对象一致性有关。type只是创建类对象的类。

在Python中一切都是对象，其中包括整数，字符串，函数和类。它们都是对象。通过检查\_\_class\_\_属性可以看到这一点。

age = 35
    print(age.__class__)  # 输出：<type 'int'>
    name = 'bob'
    print(name.__class__) # 输出：<type 'str'>
    def foo():
        pass
    print(foo.__class__) # 输出：<type 'function'>
    class Bar(object):
        pass
    b = Bar()
    print(b.__class__) # 输出：<class '__main__.Bar'>

那么\_\_class\_\_的\_\_class\_\_是什么呢？

print(age.__class__.__class__)  # 输出：<type 'type'>
    print(name.__class__.__class__) # 输出：<type 'type'>
    print(foo.__class__.__class__)  # 输出：<type 'type'>
    print(b.__class__.__class__) # 输出：<type 'type'>

我们可以看到，\_\_class\_\_的\_\_class\_\_都是同一个东西，那就是type，所以Python中的所有类都是用type创建的。如果愿意，可以将type称为“类工厂”

type只是Python中的内建元类，当然，我们可以创建自己的元类。

4. 自定义元类（metaclass）

我们还可以自定义元类，一个元类可以是一个函数，函数的参数与type函数相同。现在给出一个使用元类的例子。假设已经有一个Foo类，该类中有若干个属性，都是小写，如bar等。现在要求将Foo类中所有的属性名都改成大写。要实现这个需求，当然可以一个一个地修改Foo类中属性的名，不过这简直太愚蠢了。万一以后领导又说，还是都是小写好，那岂不是又要改回来了。所以要实现这个需求，最好的方式就是使用元类。在Python2中，需要设置\_\_metaclass\_\_变量，不过在Python3中，使用元类的方式有所改变，需要在MyClass(metaclass=...)中使用metaclass指定元类函数，代码如下：

# 元类（metaclass）将自动为该函数传递与type函数相同的参数值
    def upper_attr(class_name, class_parents, class_attrs):
        """
          返回一个类对象，将该对象的所有属性的名称都变成大写
        """
        # 除了以"__"开头的属性外，其他的属性都变成大写
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in class_attrs.items()
        }
    
        # 使用type动态创建类对象
        return type(class_name, class_parents, uppercase_attrs)
    
    # 使用metaclass指定元类函数，系统会自动调用元类函数（upper_attr）
    # 为该函数传递的参数值与调用type函数动态创建Foo类时传入的参数值相同
    class Foo(metaclass=upper_attr):
        bar = 'bip'
    
    
    print(hasattr(Foo, 'bar'))  # 输出：False
    print(hasattr(Foo, 'BAR'))  # 输出：True
    # bar已经被元类函数自动改成了BAR
    print(Foo.BAR)              # 输出：bip

我们可以看到，通过metaclass指定upper\_attr函数后，在创建Foo类时将不再调用type函数，而是调用upper\_attr函数，为该函数传入的参数值与type函数相同。