你會使用super()嗎？你肯定你瞭解它嗎？

咱們常常在類的繼承當中使用super()， 來調用父類中的方法。例以下面：

class A:
    def func(self):
        print('OldBoy')


class B(A):
    def func(self):
        super().func()
        print('LuffyCity')


A().func()
B().func()

輸出的結果爲：

OldBoy
OldBoy
LuffyCity

A實例化的對象調用了func方法，打印輸出了 Oldboy；

B實例化的對象調用了本身的func方法，先調用了父類的方法打印輸出了 OldBoy ，再打印輸出 LuffyCity 。

這樣是Python3的寫法，今天我們也只討論Python3中的super。

若是不使用super的話，想獲得相同的輸出截個，還能夠這樣寫B的類：

class B(A):
    def func(self):
        A.func(self)
        print('LuffyCity')

這樣能實現相同的效果，只不過傳了一個self參數。那爲何還要使用super()呢？

那我看看有這樣的一個繼承關係的類（鑽石繼承）：

      Base
      /  \
     /    \
    A      B
     \    /
      \  /
       C

代碼是這樣的：

class Base:
    def __init__(self):
        print('Base.__init__')


class A(Base):
    def __init__(self):
        Base.__init__(self)
        print('A.__init__')


class B(Base):
    def __init__(self):
        Base.__init__(self)
        print('B.__init__')


class C(A, B):
    def __init__(self):
        A.__init__(self)
        B.__init__(self)
        print('C.__init__')


C()

輸出的結果是：

Base.__init__
A.__init__
Base.__init__
B.__init__
C.__init__

每一個子類都調用父類的__init__方法，想把全部的初始化操做都作一遍，可是出現了一個問題，Base類的__init__方法被調用了兩次，這是多餘的操做，也是不合理的。

那咱們改寫成使用super()的寫法：

class Base:
    def __init__(self):
        print('Base.__init__')


class A(Base):
    def __init__(self):
        super().__init__()
        print('A.__init__')


class B(Base):
    def __init__(self):
        super().__init__()
        print('B.__init__')


class C(A, B):
    def __init__(self):
        super().__init__()
        print('C.__init__')


C()

輸出的結果是：

Base.__init__
B.__init__
A.__init__
C.__init__ 

這樣執行的結果就比較滿意，是大多數人想要的結果。那爲何會是這樣的結果呢？

那是由於咱們每定義一個類的時候，Python都會建立一個MRO列表，用來管理類的繼承順序。

print(C.mro())
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>]

Python經過這個列表從左到右，查找繼承的信息。Python3中的類都是新式類，都有這個mro屬性，能看出來是廣度優先的查找原則。經典類就沒有mro屬性，但它的查找原則是深度優先。

那我回到super的問題上來，讓咱們先看看super的官方定義。

 super([type[, object-or-type]]) 

返回一個代理對象，該對象將方法調用委託給類的父類或兄弟類。這對於訪問類中已重寫的繼承方法很是有用。搜索順序與getattr()使用的搜索順序相同，只是類型自己被跳過。

類的__mro__屬性列出了getattr()和super()使用的方法解析搜索順序。屬性是動態的，能夠在繼承層次結構更新時進行更改。

看到官方的解釋就能夠很清楚的明白，super是一個類，實例化以後獲得的是一個代理的對象，而不是獲得了父類，而且咱們使用這個代理對象來調用父類或者兄弟類的方法。

那咱們再看看super的使用方法：

super() -> same as super(__class__, <first argument>)
super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)

super至少須要一個參數，而且類型須要是類。

不傳參數的會報錯。只傳一個參數的話是一個不綁定的對象，不綁定的話也就沒什麼用了。

print(super(C))
print(super())

輸出結果：

RuntimeError: super(): no arguments
<super: <class 'C'>, NULL>

在定義類當中能夠不寫參數，Python會自動根據狀況將兩個參數傳遞給super。

class C(A, B):
    def __init__(self):
        print(super())
        super().__init__()
        print('C.__init__')


C()

輸出結果：

<super: <class 'C'>, <C object>>
Base.__init__
B.__init__
A.__init__
C.__init__

因此咱們在類中使用super的時候參數是能夠省略的。

第二種用法， super(type, obj) 傳遞一個類和對象，獲得的是一個綁定的super對象。這還須要obj是type的實例，能夠不是直接的實例，是子類的實例也行。

a = A()
print(super(A, a))
print(super(Base, a))

輸出結果：

Base.__init__
A.__init__
<super: <class 'A'>, <A object>>
<super: <class 'Base'>, <A object>>

第三種用法， super(type, type2)傳遞兩個類，獲得的也是一個綁定的super對象。這須要type2是type的子類。

print(super(Base, A))
print(super(Base, B))
print(super(Base, C))

 輸出結果：

<super: <class 'Base'>, <A object>>
<super: <class 'Base'>, <B object>>
<super: <class 'Base'>, <C object>>

接下來咱們就該說說查找順序了，兩個參數，是按照那個參數去計算MRO呢？

咱們將C類中的super的參數填寫上，而且實例化，看看輸出的結果。

class C(A, B):
    def __init__(self):
        super(C, self).__init__()
        print('C.__init__')

 輸出結果：

Base.__init__
B.__init__
A.__init__
C.__init__

看結果和以前super沒填參數的結果是同樣的。

那咱們將super的第一個參數改成A：

class C(A, B):
    def __init__(self):
        super(A, self).__init__()
        print('C.__init__')

輸出結果：

Base.__init__
B.__init__
C.__init__

咦！？那A.__init__怎麼跑丟了呢？多出來了B.__init__呢？

這是應爲Python是按照第二個參數來計算MRO，此次的參數是self，也就是C的MRO。在這個順序中跳過一個參數（A）找後面一個類（B），執行他的方法。

知道這個後，輸出的結果就能夠理解了。 super(A, self).__init__() 沒有執行Base的方法，而是執行了B的方法。

---

那咱們接下來講說 super(type, obj)  和 super(type, type2)的區別。

代碼以下：

class Base:
    def func(self):
        return 'from Base'


class A(Base):
    def func(self):
        return 'from A'


class B(Base):
    def func(self):
        return 'from B'


class C(A, B):
    def func(self):
        return 'from C'


c_obj = C()

print(super(C, C))
print(super(C, c_obj))

輸出結果：

<super: <class 'C'>, <C object>>
<super: <class 'C'>, <C object>>

兩次的打印結果如出一轍，verygood。那他們的方法是不是同樣的呢？測試一下。

print(super(C, C).func is super(C, c_obj).func)
print(super(C, C).func == super(C, c_obj).func)

輸出結果：

False
False

他倆的方法既不是指向同一個，值還不相等。是否是搞錯了呢？再試試下面的看看。

c1 = super(C, C)
c2 = super(C, C)
print(c1 is c2)
print(c1 == c2)
print(c1.func is c2.func)
print(c1.func == c2.func)

輸出結果：

False
False
True
True

 c1和c2不是一個對象，可是他們的方法倒是相同的。

那 super(C, C).func 和 super(C, c_obj).func 的確是不一樣的。那打印出來看看有什麼區別：

print(super(C, C).func)
print(super(C, c_obj).func)

 輸出結果：

<function A.func at 0x0000000009F4D6A8>
<bound method A.func of <__main__.C object at 0x00000000022A94E0>>

 super的第二個參數傳遞的是類，獲得的是函數。

 super的第二個參數傳遞的是對象，獲得的是綁定方法。

 函數和綁定方法的區別就再也不贅述了，在這裏想獲得同樣的結果，只須要給函數傳遞一個參數，而綁定方法則不須要傳遞額外的參數了。

print(super(C, C).func(c_obj))
print(super(C, c_obj).func())

 輸出結果：

from A
from A

那我如今總結一下：

1. super()使用的時候須要傳遞兩個參數，在類中能夠省略不寫，咱們使用super()來找父類或者兄弟類的方法；
2. super()是根據第二個參數來計算MRO，根據順序查找第一個參數類後的方法。
3. super()第二個參數是類，獲得的方法是函數，使用時要傳self參數。第二個參數是對象，獲得的是綁定方法，不須要再傳self參數。

給使用super()的一些建議：

1. super()調用的方法要存在；
2. 傳遞參數的時候，儘可能使用*args 與**kwargs；
3. 父類中的一些特性，好比【】、重寫了__getattr__，super對象是不能使用的。
4. super()第二個參數傳的是類的時候，建議調用父類的類方法和靜態方法。