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()第二個參數傳的是類的時候，建議調用父類的類方法和靜態方法。