ToB企服应用市场:ToB评测及商务社交产业平台

标题: Python 元编程 [打印本页]
作者: 用多少眼泪才能让你相信    时间: 2023-4-8 14:25
标题: Python 元编程
作者：袁首京  原创文章，转载时请保留此声明，并给出原文连接。
元编程并不象它听起来那么时髦和新奇。常用的 decorator 就可以认为是一种元编程。简单来说，元编程就是编写操作代码的代码。
有点绕，是吧？别着急，咱们一点一点来讨论。
注意：本文中的代码适用于 Python 3.3 及以上。
元类

多数编程语言中，一切东西都有类型。Python 也不例外，我们可以用 type() 函数获取任意变量的类型。
  1. num = 23
  2. print("Type of num is:", type(num))
  4. lst = [1, 2, 4]
  5. print("Type of lst is:", type(lst))
  7. name = "Atul"
  8. print("Type of name is:", type(name))
复制代码
执行结果是：
  1. Type of num is: <class 'int'>
  2. Type of lst is: <class 'list'>
  3. Type of name is: <class 'str'>
复制代码
Python 中的所有类型都是由 Class 定义的。这一条与其它编程语言，比如 Java、C++ 等等不同。在那些语言中，int、char、float 之类是基本数据类型，但是在 Python 中，它们是 int 类或 str 类的对象。
象其它 OOP 语言一样，我们可以使用 class 定义新类型：
  1. class Student:
  2.     pass
  4. stu_obj = Student()
  5. print("Type of stu_obj is:", type(stu_obj))
复制代码
执行结果是：
  1. Type of stu_obj is: <class '**main**.Student'>
复制代码
一点儿也不意外，对吧？其实有意外，因为在 Python 中，类也是一个对象，就像任何其他对象一样，它是元类的实例。即一个特殊的类，创建了 Class 这个特殊的类实例。看如下代码：
  1. class Student:
  2.     pass
  4. print("Type of Student class is:", type(Student))
复制代码
执行结果是：
  1. Type of Student class is: <class 'type'>
复制代码
既然类也是一个对象，所以以修改对象相同的方式修改它就顺理成章。如下先定义一个没有任何属性和方法的类，然后在外部为其添加属性和方法：
  1. class test:
  2.     pass
  4. test.x = 45
  5. test.foo = lambda self: print('Hello')
  7. myobj = test()
  8. print(myobj.x)
  9. myobj.foo()
复制代码
执行结果是：
  1. 45
  2. Hello
复制代码
以上过程可以简单概括为：
元类创建类，类创建实例
画个图象这样:
元类 -> 类 -> 实例
因此，我们就可以编写自定义的元类，执行额外的操作或者注入代码，来改变类的生成过程。这在某些场景下很有用，主要是比如有些情况下使用元编程更简单，另一些情况只有元编程才能解决问题。
创建自定义元类

创建自定义元类，有两种方法。第一种是继承 type 元类，并且覆写两个方法：
它在 init() 之前调用，生成类实例并返回。我们可以覆盖此方法来控制对象的创建过程。
这个不多解释，相信你都明白。
如下是个例子：
  1. class MultiBases(type):
  2.     def __new__(cls, clsname, bases, clsdict):
  3.         if len(bases)>1:
  4.             raise TypeError("Inherited multiple base classes!!!")
  6.         return super().__new__(cls, clsname, bases, clsdict)
  9. class Base(metaclass=MultiBases):
  10.     pass
  13. class A(Base):
  14.     pass
  17. class B(Base):
  18.     pass
  21. class C(A, B):
  22.     pass
复制代码
执行结果是：
  1. Traceback (most recent call last):
  2. File "<stdin>", line 2, in <module>
  3. File "<stdin>", line 8, in **new**
  4. TypeError: Inherited multiple base classes!!!
复制代码
第二种方法是直接使用 type() 函数创建类。这个方法如果只用一个参数调用，它会返回该参数的类型，前文已经描述过。但是使用三个参数调用时，它会创建一个类。这三个参数如下：
以下是示例：
  1. def test_method(self):
  2.     print("This is Test class method!")
  5. class Base:
  7.     def myfun(self):
  8.         print("This is inherited method!")
  11. Test = type('Test', (Base, ), dict(x="atul", my_method=test_method))
  12. print("Type of Test class: ", type(Test))
  14. test_obj = Test()
  15. print("Type of test_obj: ", type(test_obj))
  17. test_obj.myfun()
  18. test_obj.my_method()
  20. print(test_obj.x)
复制代码
执行结果是：
  1. Type of Test class: <class 'type'>
  2. Type of test_obj: <class '**main**.Test'>
  3. This is inherited method!
  4. This is Test class method!
  5. atul
复制代码
使用元类解决问题

了解了元类的创建方法后，可以来解决一些实际问题了。例如，如果我们想在每次调用类方法时，都先输出一下它的全限定名，该怎么办呢？
最常用的方法是使用 decorator，象这样：
  1. from functools import wraps
  4. def debug(func):
  6.     @wraps(func)
  7.     def wrapper(*args, **kwargs):
  8.         print("Full name of this method:", func.__qualname__)
  9.         return func(*args, **kwargs)
  10.     return wrapper
  13. def debugmethods(cls):
  14.     for key, val in vars(cls).items():
  15.         if callable(val):
  16.             setattr(cls, key, debug(val))
  17.     return cls
  20. @debugmethods
  21. class Calc:
  23.     def add(self, x, y):
  24.         return x+y
  26.     def mul(self, x, y):
  27.         return x\*y
  29.     def div(self, x, y):
  30.         return x/y
  33. mycal = Calc()
  34. print(mycal.add(2, 3))
  35. print(mycal.mul(5, 2))
复制代码
执行结果是：
  1. Full name of this method: Calc.add
  2. 5
  3. Full name of this method: Calc.mul
  4. 10
复制代码
这个方案很漂亮。但是，如果变更一下需求，例如我们希望 Calc 的所有子类的方法执行时，都先输出一下它的全限定名，该怎么办呢？
在每一个子类上加上 @debugmethods 是一种方案，但是有点啰嗦，是不是？
该基于元类的解决方案出场了，以下是个例子：
  1. from functools import wraps
  4. def debug(func):
  6.     @wraps(func)
  7.     def wrapper(*args, **kwargs):
  8.         print("Full name of this method:", func.__qualname__)
  9.         return func(*args, **kwargs)
  10.     return wrapper
  13. def debugmethods(cls):
  15.     for key, val in vars(cls).items():
  16.         if callable(val):
  17.             setattr(cls, key, debug(val))
  18.     return cls
  21. class debugMeta(type):
  23.     def __new__(cls, clsname, bases, clsdict):
  24.         obj = super().__new__(cls, clsname, bases, clsdict)
  25.         obj = debugmethods(obj)
  26.         return obj
  29. class Base(metaclass=debugMeta):
  30.     pass
  33. class Calc(Base):
  35.     def add(self, x, y):
  36.         return x+y
  39. class Calc_adv(Calc):
  41.     def mul(self, x, y):
  42.         return x\*y
  45. mycal = Calc_adv()
  46. print(mycal.mul(2, 3))
复制代码
执行结果是：
  1. Full name of this method: Calc_adv.mul
  2. 6
复制代码
何时使用元类

该说的基本说完了，剩下最好一件事。元编程算是 Python 的一个魔法，多数时候我们其实用不到。但是什么时候需要呢？大概有三种情况：
  作者：袁首京  原创文章，转载时请保留此声明，并给出原文连接。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4