python中Mixin混入类的用法

Mixin 在 python 中也不是什么新鲜的东西,只是一种编程思想的体现,利用其可以多继承的语言特点,从而达到一种灵活的编程方式。

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

1
2
3
4
5
6
7
8
class BaseSanic(
    RouteMixin,
    MiddlewareMixin,
    ListenerMixin,
    ExceptionMixin,
    SignalMixin,
    metaclass=SanicMeta,
):

于是对于这种 Mixin 研究了一下,其实也没什么新的东西,Mixin 又称混入,只是一种编程思想的体现,但是在使用过程中还是有一些需要注意的地方。

大家都知道,python 是一种允许多继承的语言,一个类可以继承多个类,这和java不太一样,java类只能有一个父类, 但是java 中有接口的概念,一个类可以实现多个接口,但是java的接口只是定义的函数的签名,并没有具体的实现,具体的实现需要相应的类来完成。

python 就不一样了,一个类可以有多个父类,而混入类就是这种允许多继承语言中才有的一种编程模式。

为了更好的理解混入,我们举一个生活中的例子—手机, 手机有很多功能,由不同的硬件组合而成,手机有接打电话,收发短信,上网,听歌等功能,组装一台手机就需要将各种硬件进行拼接。

如果我们把这些功能抽象成类,那么我们可以有以下写法,为了简单一点,只列接打电话,收发短信功能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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 这个类里再重新定义二个方法 telfuncsmsfunc,也就是将Tel类和SMS类里的方法再写一遍,这种其实不符合 don't repeate youself的理念。

正常情况下我们是让Phone这个类继承Tel类和SMS类,这样Phone这个类就自动拥有了接打电话和发短信的能力了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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结尾,像上面的代码我们会写成下面这样

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
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 太麻烦了,我只想单继承,我定义一个统一的父类,它即有接打电话,也有收发短信的功能,还可以听歌,然后让手机来继承这个类不好吗? 如下面的代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
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类的时候 不加入 接打电话和收发短信的类就可以了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
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 并没有多态,或者说它天然的就是多态。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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) 方法来调用传入参数的通话功能,得到以下输出

1
2
3
4
5
6
7
8
对讲机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混入,其实它本质上就是继承,只是这种继承是存在于允许多继承的编程语言中,如果说区别,本质上也没有什么区别,如果硬是要说些区别,其实也是有一点点。

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

说了那么多Mixin 的好处,它有什么不好的地方吗? 其实在我看来,有一个问题,也说不上是不好,只是习惯问题,以前写代码还是写单继承多一些,并不太习惯这种多继承的方式,不过如果一切都按照相应的规则来操作也不是什么大问题。

还有一个问题就是功能的拆分,这个很是考验编程人员在设计代码之初整体把握能力,就像单体应用想要拆分成微服务,边界问题可能是开始时最头疼的,拆细了吧,会写出很多类,拆粗了吧,就又回到单继承的思维模式了,所以这个也是个经验问题吧。

总结

Mixin 混入也可以说是编程模式,并不是什么新的语法,用好混入类可以使自己的代码结构清晰,功能明了,所以以后在设计类时要多考虑使用Mixin混入类的实现方式。