9.17 在类上强制使用编程规约

问题

你的程序包含一个很大的类继承体系，你希望强制执行某些编程规约（或者代码诊断）来帮助程序员保持清醒。

解决方案

如果你想监控类的定义，通常可以通过定义一个元类。一个基本元类通常是继承自 type 并重定义它的 new() 方法或者是 init() 方法。比如：

  1. class MyMeta(type):
  2.     def __new__(self, clsname, bases, clsdict):
  3.         # clsname is name of class being defined
  4.         # bases is tuple of base classes
  5.         # clsdict is class dictionary
  6.         return super().__new__(cls, clsname, bases, clsdict)

另一种是，定义 init() 方法：

  1. class MyMeta(type):
  2.     def __init__(self, clsname, bases, clsdict):
  3.         super().__init__(clsname, bases, clsdict)
  4.         # clsname is name of class being defined
  5.         # bases is tuple of base classes
  6.         # clsdict is class dictionary

为了使用这个元类，你通常要将它放到到一个顶级父类定义中，然后其他的类继承这个顶级父类。例如：

  1. class Root(metaclass=MyMeta):
  2.     pass
  3.  
  4. class A(Root):
  5.     pass
  6.  
  7. class B(Root):
  8.     pass

元类的一个关键特点是它允许你在定义的时候检查类的内容。在重新定义 init() 方法中，你可以很轻松的检查类字典、父类等等。并且，一旦某个元类被指定给了某个类，那么就会被继承到所有子类中去。因此，一个框架的构建者就能在大型的继承体系中通过给一个顶级父类指定一个元类去捕获所有下面子类的定义。

作为一个具体的应用例子，下面定义了一个元类，它会拒绝任何有混合大小写名字作为方法的类定义（可能是想气死Java程序员^_^）：

  1. class NoMixedCaseMeta(type):
  2.     def __new__(cls, clsname, bases, clsdict):
  3.         for name in clsdict:
  4.             if name.lower() != name:
  5.                 raise TypeError('Bad attribute name: ' + name)
  6.         return super().__new__(cls, clsname, bases, clsdict)
  7.  
  8. class Root(metaclass=NoMixedCaseMeta):
  9.     pass
  10.  
  11. class A(Root):
  12.     def foo_bar(self): # Ok
  13.         pass
  14.  
  15. class B(Root):
  16.     def fooBar(self): # TypeError
  17.         pass

作为更高级和实用的例子，下面有一个元类，它用来检测重载方法，确保它的调用参数跟父类中原始方法有着相同的参数签名。

  1. from inspect import signature
  2. import logging
  3.  
  4. class MatchSignaturesMeta(type):
  5.  
  6.     def __init__(self, clsname, bases, clsdict):
  7.         super().__init__(clsname, bases, clsdict)
  8.         sup = super(self, self)
  9.         for name, value in clsdict.items():
  10.             if name.startswith('_') or not callable(value):
  11.                 continue
  12.             # Get the previous definition (if any) and compare the signatures
  13.             prev_dfn = getattr(sup,name,None)
  14.             if prev_dfn:
  15.                 prev_sig = signature(prev_dfn)
  16.                 val_sig = signature(value)
  17.                 if prev_sig != val_sig:
  18.                     logging.warning('Signature mismatch in %s. %s != %s',
  19.                                     value.__qualname__, prev_sig, val_sig)
  20.  
  21. # Example
  22. class Root(metaclass=MatchSignaturesMeta):
  23.     pass
  24.  
  25. class A(Root):
  26.     def foo(self, x, y):
  27.         pass
  28.  
  29.     def spam(self, x, *, z):
  30.         pass
  31.  
  32. # Class with redefined methods, but slightly different signatures
  33. class B(A):
  34.     def foo(self, a, b):
  35.         pass
  36.  
  37.     def spam(self,x,z):
  38.         pass

如果你运行这段代码，就会得到下面这样的输出结果：

  1. WARNING:root:Signature mismatch in B.spam. (self, x, *, z) != (self, x, z)
  2. WARNING:root:Signature mismatch in B.foo. (self, x, y) != (self, a, b)

这种警告信息对于捕获一些微妙的程序bug是很有用的。例如，如果某个代码依赖于传递给方法的关键字参数，那么当子类改变参数名字的时候就会调用出错。

讨论

在大型面向对象的程序中，通常将类的定义放在元类中控制是很有用的。元类可以监控类的定义，警告编程人员某些没有注意到的可能出现的问题。

有人可能会说，像这样的错误可以通过程序分析工具或IDE去做会更好些。诚然，这些工具是很有用。但是，如果你在构建一个框架或函数库供其他人使用，那么你没办法去控制使用者要使用什么工具。因此，对于这种类型的程序，如果可以在元类中做检测或许可以带来更好的用户体验。

在元类中选择重新定义 new() 方法还是 init() 方法取决于你想怎样使用结果类。new() 方法在类创建之前被调用，通常用于通过某种方式（比如通过改变类字典的内容）修改类的定义。而 init() 方法是在类被创建之后被调用，当你需要完整构建类对象的时候会很有用。在最后一个例子中，这是必要的，因为它使用了 super() 函数来搜索之前的定义。它只能在类的实例被创建之后，并且相应的方法解析顺序也已经被设置好了。

最后一个例子还演示了Python的函数签名对象的使用。实际上，元类将每个可调用定义放在一个类中，搜索前一个定义（如果有的话），然后通过使用 inspect.signature() 来简单的比较它们的调用签名。

最后一点，代码中有一行使用了 super(self, self) 并不是排版错误。当使用元类的时候，我们要时刻记住一点就是 self 实际上是一个类对象。因此，这条语句其实就是用来寻找位于继承体系中构建 self 父类的定义。

原文:

http://python3-cookbook.readthedocs.io/zh_CN/latest/c09/p17_enforce_coding_conventions_in_classes.html