使用元类进行 Python 元编程

2025年3月17日 | 阅读 8 分钟

元编程（Metaprogramming）听起来可能很新，但如果用户曾经使用过装饰器（Decorators）或元类（metaclasses），那么他们就已经在项目中使用了元编程。因此，我们可以说元编程就是用于操作程序的程序。

在本教程中，我们将讨论元类及其用途，以及它们的替代方案。由于这是 Python 的一个高级主题，建议用户在开始本教程之前复习一下“Python 装饰器”和“Python OOPS 概念”的基础知识。

元类（Metaclasses）

在 Python 中，每个模块或函数都与某种类型相关联。例如，如果用户有一个整数值的变量，那么它就与“int”类型相关联。用户可以通过 type() 方法了解任何事物的类型。

示例

number = 13
print("Type of number is:", type(num))
 
list = [3, 7, 8]
print("Type of list is:", type(list))
 
name = "Mark Jackson"
print("Type of name is:", type(name))

输出

Type of number is: <class 'int'>
Type of list is: <class 'list'>
Type of name is: <class 'str'>

解释 -

Python 中的每种类型都是由类定义的。因此，在上面的例子中，它们是 'int'、'list' 或 'str' 类的对象，这与 C 语言或 Java 语言不同，在这些语言中，int、char 和 float 是基本数据类型。用户可以通过创建该类型的类来创建新的类型。例如，我们可以通过 City 类创建一个新的 Object 类型。

示例

class City:
    pass
City_object = City()
 
# now, we will print the type of object of City class
print("Type of City_object is:", type(City_object))

输出

Type of City_object is: <class '__main__.City'>

Python 中的类也是一个对象，因此，像其他对象一样，它是元类（Metaclass）的实例。元类是一种特殊的类类型，它负责创建类和类对象。所以，例如，如果用户想找到“City”类的类型，他们会发现它是“type”。

示例

class City:
    pass
 
# now, we will print the type of the City class
print("Type of City class is:", type(City))

输出

Type of City class is: <class 'type'>

由于类也是对象，我们可以修改它们。例如，我们可以像处理其他对象一样，向类中添加或删除字段或函数。

示例

# First, we will define the class without any using any class methods or variables.
class City:
    pass
 
# now, we will define the method variables
City.a = 65
 
# we will now, define the class methods
City.foo = lambda self: print('Pune')
 
# then, we will create the object
userobject = City()
 
print(userobject.a)
userobject.foo()

输出

65
Pune

我们可以总结元类如下：

元类用于创建类，而这些类可以创建对象。

Metaprogramming with Metaclasses in Python

元类负责创建类，因此用户可以通过插入代码或额外的操作来修改类的创建方式，从而编写自己的自定义元类。通常情况下，用户不需要自定义元类，但在特殊情况下是必要的。

有些问题可以使用元类或非元类来解决，但有些情况只有元类才能解决。

如何创建自定义元类

要创建自定义元类，用户自定义元类必须继承 type 元类，通常会重写，例如：

__new__(): __new__() 函数在 __int__() 函数之前执行。它用于创建对象并返回。用户可以通过重写此函数来控制对象的创建方式。
__int__(): __int__() 函数用于初始化已创建的对象，该对象作为参数传递。

用户可以直接使用 type() 方法创建类。type() 方法的调用方式如下：

如前例所示，用户可以传入一个参数调用它，它将返回类型。
用户可以传入三个参数调用它。它将创建一个类。传递给它的参数如下：
- 类的名称
- 传入一个包含类继承的基类的元组
- 类字典：这将作为类的本地命名空间，其中填充了函数和变量。

示例

def City_method(self):
    print("This is City class method!")
 
# we will create the base class
class Base:
    def userfunction(self):
        print("This is a inherited method!")
 
# we will create the city class dynamically by using
# type() function.
City = type('City', (Base, ), dict(a = "Mark Jackson", user_method = City_method))
 
# now, we will print the type of City
print("The Type of City class: ", type(City))
 
# we will create the instance of City class
City_object = City()
print(" The Type of City_object: ", type(City_object))
 
# we will now call the inherited method
City_object.userfunction()
 
# we will call the City class method
City_object.user_method()
 
# at last we will print the variable
print(City_object.a)

输出

The Type of City class:  <class 'type'>
 The Type of City_object:  <class '__main__.City'>
This is a inherited method!
This is City class method!
Mark Jackson

现在，让我们看看如何在不直接使用 type() 函数的情况下创建元类。例如，我们将创建一个名为 MultiBases 的元类，它将检查正在创建的类是否继承自多个基类。如果是，它将引发一个错误。

示例

# Inside the metaclass
class MultiBases(type):
    # we will override the __new__() function
    def __new__(city, city_name, bases, citydict):
        # if the number of base classes are greator than 1
        # it will raise an error
        if len(bases)>1:
            raise TypeError("There are inherited multiple base classes!!!")
         
        # else it will execute the __new__() function of super class, that is
        # it will call the __init__() function of type class
        return super().__new__(city, city_name, bases, citydict)
 
# the metaclass can be specified by using 'metaclass' keyword argument
# now we will use the MultiBase class for creating classes
# this will be propagated to all subclasses of Base
class Base(metaclass = MultiBases):
    pass
 
# this will raise no error
class P(Base):
    pass
 
# this will raise no error
class Q(Base):
    pass
# this will raise no error
class R(Base):
    pass
# This will raise an error!
class S(P, Q, R):
    pass

输出

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-409c90c285d5> in <module>
     29     pass
     30 # This will raise an error!
---> 31 class S(P, Q, R):
     32     pass

<ipython-input-2-409c90c285d5> in __new__(city, city_name, bases, citydict)
      6         # it will raise an error
      7         if len(bases)>1:
----> 8             raise TypeError("There are inherited multiple base classes!!!")
      9 
     10         # else it will execute the __new__() function of super class, that is

TypeError: There are inherited multiple base classes!!!

如何用元类解决问题

有些问题用户可以通过使用元类和装饰器来解决。但有些问题只能通过使用元类来找到解决方案。例如，用户想要调试类函数，他们希望的是，每当类函数被执行时，都会在执行其主体之前打印其完整的限定名称。

示例

from functools import wraps
 
def debugg(funct):
    '''decorator for debugging passed function'''
     
    @wraps(funct)
    def wrapperr(*args, **kwargs):
        print("The full name of this Function:", funct.__qualname__)
        return funct(*args, **kwargs)
    return wrapperr
 
def debug_methods(clas):
    '''class decorator make use of debug decorator
       for debuging the class functions '''
     
    # now we will check in the class dictionary for any callable(function)
    # if there is any, replace it with debugged version
    for key, value in vars(clas).items():
        if callable(value):
            setattr(clas, key, debugg(value))
    return clas
 
# sample class
@debugmethods
class Calculator:
    def add(self, p, q):
        return p+q
    def mul(self, p, q):
        return p*q
    def div(self, p, q):
        return p/q
     
user_cal = Calculator()
print(user_cal.add(5, 8))
print(user_cal.mul(6, 7))
print(user_cal.div(21, 7))

输出

The full name of this method: Calculator.add
13
The full name of this method: Calculator.mul
42
The full name of this method: Calculator.div
3.0

解释 -

上述解决方案工作正常，但有一个问题，即用户希望将装饰器方法应用于继承了“Calculator”类的所有子类。在这种情况下，用户必须单独将装饰器方法应用于每个子类，就像我们在上面的 Calculator 类示例中所做的那样。

现在，真正的问题是，类可能有很多子类，单独应用装饰器方法到每个子类既困难又耗时。因此，为了解决这个问题，用户必须确保每个子类都具有此调试属性，他们应该寻找基于元类的解决方案。

示例

我们将正常创建类，然后立即使用 debug 方法装饰器进行包装。

from functools import wraps
 
def debugg(funct):
    '''decorator for debugging passed function'''
     
    @wraps(funct)
    def wrapperr(*args, **kwargs):
        print("The full name of this Function:", funct.__qualname__)
        return funct(*args, **kwargs)
    return wrapperr
 
def debug_methods(clas):
    '''class decorator will make use of the debug decorator
       to the debug class '''
     
    for key, value in vars(clas).items():
        if callable(value):
            setattr(clas, key, debugg(value))
    return clas
 
class debug_Meta(type):
    '''meta class which feed created class object
       to debug_method for getting debug functionality
       enabled objects'''
     
    def __new__(clas, clasname, bases, clasdict):
        object = super().__new__(clas, clasname, bases, clasdict)
        object = debug_methods(object)
        return object
     
# the base class with metaclass 'debug_Meta'
# now all the subclass of this will have the applied debugging function
class Base(metaclass = debug_Meta):pass
 
# now, we will inherite the Base
class Calculator(Base):
    def add(self, p, q):
        return p+q
     
#and then, we will inherite the Calculator
class Calculator_adv(Calculator):
    def mult(self, p, q):
        return p*q

 
# Now Calculator_adv object will show
# the behaviour og debugging

user_cal = Calculator_adv()
print(user_cal.add(3, 7))
user_cal = Calculator_adv()
print(user_cal.mult(3, 7))

输出

The full name of this Function: Calculator.add
10
The full name of this Function: Calculator_adv.mult
21

用户何时应该使用元类

用户不经常使用元类，因为元类主要用于复杂的情况。但有少数情况用户可以使用元类。

如上面的例子所示，元类用于向下生成继承层次结构。这也会影响所有子类。如果用户有这种情况，他们可以使用元类。
如果用户想自动更改类，他们可以在类创建时使用元类。
如果用户是应用程序编程接口（API）开发者，他们可以为此目的使用元类。

结论

在本教程中，我们讨论了元类、如何自定义元类，以及用户如何使用它们来解决复杂编程问题和它们的替代方案。

下一个主题Python 精度处理

← 上一个下一个 →

使用元类进行 Python 元编程

元类（Metaclasses）

如何创建自定义元类

如何用元类解决问题

用户何时应该使用元类

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python 问题

使用元类进行 Python 元编程

元类（Metaclasses）

如何创建自定义元类

如何用元类解决问题

用户何时应该使用元类

结论

相关帖子

Python Graphviz: DOT 语言

是否应该更新 Python 的最新版本错误修复

Python 中的 CamelCase

使用 Python 创建秒表

使用 get() 方法从 Python 字典中获取值

Python 中的 Numpy Logical _and()

Python 中的 randint() 函数

利用机器学习 - Python 进行飞船泰坦尼克号项目

Python 中的带括号的上下文管理器

int 对象不可迭代

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器