python 中Mixin混入类的使用方法详解_Python

前言

最近在看sanic的源码，发现有很多Mixin的类，大概长成这个样子

				?

									class BaseSanic(

									    RouteMixin,

									    MiddlewareMixin,

									    ListenerMixin,

									    ExceptionMixin,

									    SignalMixin,

									    metaclass=SanicMeta,

									):

于是对于这种 Mixin 研究了一下，其实也没什么新的东西,Mixin 又称混入，只是一种编程思想的体现，但是在使用过程中还是有一些需要注意的地方。大家都知道，python 是一种允许多继承的语言，一个类可以继承多个类，这和java不太一样，java类只能有一个父类，但是java 中有接口的概念，一个类可以实现多个接口，但是java的接口只是定义的函数的签名，并没有具体的实现，具体的实现需要相应的类来完成。 python 就不一样了，一个类可以有多个父类，而混入类就是这种允许多继承语言中才有的一种编程模式。为了更好的理解混入，我们举一个生活中的例子---手机，手机有很多功能，由不同的硬件组合而成，手机有接打电话，收发短信，上网，听歌等功能，组装一台手机就需要将各种硬件进行拼接。如果我们把这些功能抽象成类，那么我们可以有以下写法，为了简单一点，只列接打电话，收发短信功能。

				?

									class Tel:

									    def telfunc(self):

									        print("我可以接打电话")

									        class SMS:

									    def smsfunc(self):

									        print("我可以发短信")

									        class Phone:

									    def __init__(self, sn):

									        self.sn = sn

上面的代码中，有三个类，Tel 类，它有一个 telfunc 方法用于表示有接打电话的能力(或者说是功能)， SMS 类有smsfunc表示SMS类有发短信的能力。而 Phone 这个类才是一个手机类，它应该具有接打电话和发送短信的能力，但是如果我们用上面的方式定义Phone 这个类，则这个类并没有接打电话和收发短信的能力。我们可以怎样做让Phone这个类可以具有打电话和发短信的能力？我们可以在Phone 这个类里再重新定义二个方法 telfunc和 smsfunc，也就是将Tel类和SMS类里的方法再写一遍，这种其实不符合 don't repeate youself的理念。正常情况下我们是让Phone这个类继承Tel类和SMS类，这样Phone这个类就自动拥有了接打电话和发短信的能力了。

				?

									class Tel:

									    def telfunc(self):

									        print("我可以接打电话")

									​class SMS:

									    def smsfunc(self):

									        print("我可以发短信")

									​

									​class Phone(Tel, SMS):

									    def __init__(self, sn):

									        self.sn = sn

									​    def welcome(self):

									        print("welcome {}".format(self.sn))

									​p = Phone("xiaomi")

									p.telfunc()

									p.smsfunc()

									p.welcome()

									​

									'''

									我可以接打电话

									我可以发短信

									welcome xiaomi

									'''

像这种类的定义就是我们所说的混入，将通话功能与短信功能加入到手机中，让手机拥有接打电话和发送短信的功能，这种混入的编码思想有时可以减少很多代码量。很方便的根据一个类需要哪些功能就将哪个类“混入”到该类中。通常情况下，我们会将混入类的命名以Mixin结尾，像上面的代码我们会写成下面这样

				?

									class TelMixin:

									    def telfunc(self):

									        print("我可以接打电话")

									​class SMSMixin:

									    def smsfunc(self):

									        print("我可以发短信")

									​class Phone(TelMixin, SMSMixin):

									    def __init__(self, sn):

									        self.sn = sn

									​    def welcome(self):

									        print("welcome {}".format(self.sn))

以 Mixin 结尾的类，一般是那种功能比较单一，且一般都是某一类型的功能，如最开始介绍的sanic混入类 RouteMixin 与路由相关的功能类，MiddlewareMixin 是与中间件相关的类，ListenerMixin 是监听器相关的类，这些类里的方法专注于自己相关的功能，如果有哪个类需要这些功能，那定义的时候就继承自这些类。

有人会问了，我不想多继承，管理MRO 太麻烦了，我只想单继承，我定义一个统一的父类，它即有接打电话，也有收发短信的功能，还可以听歌，然后让手机来继承这个类不好吗？

如下面的代码：

				?

									class Tel:

									    def telfunc(self):

									        print("我可以接打电话")

									    def smsfunc(self):

									        print("我可以发短信")

									    def songfunc(self):

									        print("我可以放音乐")

									​

									​class Phone(Tel):

									    def __init__(self, sn):

									        self.sn = sn

									​    def welcome(self):

									        print("welcome {}".format(self.sn))

首先这种写法当然是可以的，语法上没有任何问题，也很好的实现了相应的功能，代码量也减少了，但是这里大家想一个逻辑问题，如果我想造一个ipod类，ipod 这个类没有接打电话收发短信的功能，只有听歌的功能，那么我此时要写这个类该如何定义？是不是要定义一个ipod类，然后再写它的听歌方法songfunc，如果此时使用混入的编程思想，那么我们就完全可以定义ipod类的时候 不加入 接打电话和收发短信的类就可以了。

				?

									class TelMixin:

									    def telfunc(self):

									        print("我可以接打电话")

									​class SMSMixin:

									    def smsfunc(self):

									        print("我可以发短信")

									        class SongMixin:

									    def songfunc(self):

									        print("我可以放音乐")

									​class Phone(TelMixin, SMSMixin, SongMixin):

									    def __init__(self, sn):

									        self.sn = sn

									​class Ipod(SongMixin):

									    def __init__(self, sn):

									        self.sn = sn

如果还有别的什么类，比如对讲机，它只有接打电话的功能，那么我们就只需要把接打电话的功能混入到对讲机类即可, class Intercom(TelMixin):

但是有人又会问了，这样的混入，虽说少写了一些代码，但是如果子类相应实现并不完全和父类一致该如何处理？如对讲机虽然可以通话，但是它是单向通话，并不能双向通话的。这时对于子类实现与父类不一致的情况，那么就需要子类重写父类方法了，也就是OOP中的继承与多态，严格意义上来说, python 并没有多态，或者说它天然的就是多态。

				?

									class TelMixin:

									    def telfunc(self):

									        print("我可以接打电话")

									​class SMSMixin:

									    def smsfunc(self):

									        print("我可以发短信")

									​class SongMixin:

									    def songfunc(self):

									        print("我可以放音乐")

									​class Intercom(TelMixin):

									    def __init__(self, sn):

									        self.sn = sn

									​    def telfunc(self):

									        print("对讲机{} 的通话".format(self.sn))

									​class Phone(TelMixin, SMSMixin, SongMixin):

									    def __init__(self, sn):

									        self.sn = sn

									​class Ipod(SongMixin):

									    def __init__(self, sn):

									        self.sn = sn

									​def testTelfunc(o):

									    o.telfunc()

									d = Intercom("moto")

									p = Phone("huawei")

									ipod = Ipod("apple")

									testTelfunc(d)

									testTelfunc(p)

									testTelfunc(ipod)

以上代码，我们重写了对讲机类的telfunc 方法，但是并没有对Ipod类实现通话功能, 然后写了一个testTelfunc(o) 方法来调用传入参数的通话功能,

得到以下输出：

#对讲机moto 的通话
#我可以接打电话
Traceback (most recent call last):
  File "/Users/yyx/test/test.py", line 54, in <module>
    testTelfunc(ipod)
  File "/Users/yyx/test/test.py", line 46, in testTelfunc
    o.telfunc()
AttributeError: 'Ipod' object has no attribute 'telfunc'

当给testTelfunc 传入的是对讲机Intercom 对象时，由于该类重写了telfunc方法，所以这里调用的是该子类的telfunc方法，当传入的是Phone类对象时，由于该类继承了TelMixin类，且没有重写telfunc方法，所以这里会调用TelMixin类中的telfunc 方法，但是当传入的是Ipod类时，这个类既没有继承TelMixin，也没有自己的telfunc方法，所以就崩溃了。这也是一种另类的多态体现吧，只是它没有像java中的那么严格。

Mixin 与继承的区别

说了那么多的Mixin混入，其实它本质上就是继承，只是这种继承是存在于允许多继承的编程语言中，如果说区别，本质上也没有什么区别，如果硬是要说些区别，其实也是有一点点。

首先，Mixin 类最好不要有初始化方法，也就是 __init__ 方法，因为如果Mixin类定义了初始化方法，那么在子类中也最好调用一下父类也就是混入类的初始方法super().__init__(),当然不调用也没关系，IDE 只会给你一个提示，语法上并没有什么错误。
Mixin 类最好不要单独的实例化，因为混入类的设计初衷就是要让子类来继承的，然后子类可以丰富混入类的功能，混入类只是为了让子类拥有某些功能而来的。
Mixin 类最好是某一类功能的合集，比如上面sanic 源码中的 RouteMixin 混入类，它只定义与路由相关的功能方法，这样的好处是，不会有同名的方法，如果混入类中有同名的方法，那么就给自己找麻烦了，排查问题也不太好排查，其实这个也是比单继承自一个类方便的地方。

说了那么多Mixin 的好处，它有什么不好的地方吗？其实在我看来，有一个问题，也说不上是不好，只是习惯问题，以前写代码还是写单继承多一些，并不太习惯这种多继承的方式，不过如果一切都按照相应的规则来操作也不是什么大问题。还有一个问题就是功能的拆分，这个很是考验编程人员在设计代码之初整体把握能力，就像单体应用想要拆分成微服务，边界问题可能是开始时最头疼的，拆细了吧，会写出很多类，拆粗了吧，就又回到单继承的思维模式了，所以这个也是个经验问题吧。