8.18 利用Mixins扩展类功能

问题

你有很多有用的方法，想使用它们来扩展其他类的功能。但是这些类并没有任何继承的关系。因此你不能简单的将这些方法放入一个基类，然后被其他类继承。

解决方案

通常当你想自定义类的时候会碰上这些问题。可能是某个库提供了一些基础类，你可以利用它们来构造你自己的类。

假设你想扩展映射对象，给它们添加日志、唯一性设置、类型检查等等功能。下面是一些混入类：

  1. class LoggedMappingMixin:
  2.     """
  3.     Add logging to get/set/delete operations for debugging.
  4.     """
  5.     __slots__ = ()  # 混入类都没有实例变量，因为直接实例化混入类没有任何意义
  6.  
  7.     def __getitem__(self, key):
  8.         print('Getting ' + str(key))
  9.         return super().__getitem__(key)
  10.  
  11.     def __setitem__(self, key, value):
  12.         print('Setting {} = {!r}'.format(key, value))
  13.         return super().__setitem__(key, value)
  14.  
  15.     def __delitem__(self, key):
  16.         print('Deleting ' + str(key))
  17.         return super().__delitem__(key)
  18.  
  19.  
  20. class SetOnceMappingMixin:
  21.     '''
  22.     Only allow a key to be set once.
  23.     '''
  24.     __slots__ = ()
  25.  
  26.     def __setitem__(self, key, value):
  27.         if key in self:
  28.             raise KeyError(str(key) + ' already set')
  29.         return super().__setitem__(key, value)
  30.  
  31.  
  32. class StringKeysMappingMixin:
  33.     '''
  34.     Restrict keys to strings only
  35.     '''
  36.     __slots__ = ()
  37.  
  38.     def __setitem__(self, key, value):
  39.         if not isinstance(key, str):
  40.             raise TypeError('keys must be strings')
  41.         return super().__setitem__(key, value)

这些类单独使用起来没有任何意义，事实上如果你去实例化任何一个类，除了产生异常外没任何作用。它们是用来通过多继承来和其他映射对象混入使用的。例如：

  1. class LoggedDict(LoggedMappingMixin, dict):
  2.     pass
  3.  
  4. d = LoggedDict()
  5. d['x'] = 23
  6. print(d['x'])
  7. del d['x']
  8.  
  9. from collections import defaultdict
  10.  
  11. class SetOnceDefaultDict(SetOnceMappingMixin, defaultdict):
  12.     pass
  13.  
  14.  
  15. d = SetOnceDefaultDict(list)
  16. d['x'].append(2)
  17. d['x'].append(3)
  18. # d['x'] = 23  # KeyError: 'x already set'

这个例子中，可以看到混入类跟其他已存在的类(比如dict、defaultdict和OrderedDict)结合起来使用，一个接一个。结合后就能发挥正常功效了。

讨论

混入类在标准库中很多地方都出现过，通常都是用来像上面那样扩展某些类的功能。它们也是多继承的一个主要用途。比如，当你编写网络代码时候，你会经常使用 socketserver 模块中的 ThreadingMixIn 来给其他网络相关类增加多线程支持。例如，下面是一个多线程的XML-RPC服务：

  1. from xmlrpc.server import SimpleXMLRPCServer
  2. from socketserver import ThreadingMixIn
  3. class ThreadedXMLRPCServer(ThreadingMixIn, SimpleXMLRPCServer):
  4.     pass

同时在一些大型库和框架中也会发现混入类的使用，用途同样是增强已存在的类的功能和一些可选特征。

对于混入类，有几点需要记住。首先是，混入类不能直接被实例化使用。其次，混入类没有自己的状态信息，也就是说它们并没有定义 init() 方法，并且没有实例属性。这也是为什么我们在上面明确定义了 slots = () 。

还有一种实现混入类的方式就是使用类装饰器，如下所示：

  1. def LoggedMapping(cls):
  2.     """第二种方式：使用类装饰器"""
  3.     cls_getitem = cls.__getitem__
  4.     cls_setitem = cls.__setitem__
  5.     cls_delitem = cls.__delitem__
  6.  
  7.     def __getitem__(self, key):
  8.         print('Getting ' + str(key))
  9.         return cls_getitem(self, key)
  10.  
  11.     def __setitem__(self, key, value):
  12.         print('Setting {} = {!r}'.format(key, value))
  13.         return cls_setitem(self, key, value)
  14.  
  15.     def __delitem__(self, key):
  16.         print('Deleting ' + str(key))
  17.         return cls_delitem(self, key)
  18.  
  19.     cls.__getitem__ = __getitem__
  20.     cls.__setitem__ = __setitem__
  21.     cls.__delitem__ = __delitem__
  22.     return cls
  23.  
  24.  
  25. @LoggedMapping
  26. class LoggedDict(dict):
  27.     pass

这个效果跟之前的是一样的，而且不再需要使用多继承了。参考9.12小节获取更多类装饰器的信息，参考8.13小节查看更多混入类和类装饰器的例子。

原文:

http://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p18_extending_classes_with_mixins.html