Python Super用法

這篇文章我們來介紹一下 super，我相信大部分的人使用 super 都是使用這種方式；

# 就是我有一個 class 比如說是 Male，然后繼承另外一個 class 比如是 Person，然后我在這個 Male 也就是它的子類的 init 函數(shù)里面用 super().__init__() 來調(diào)用它父類的初識化函數(shù)
from objprint import op
class Person:
    def __init__(self, name):
        self.name = name
class Male(Person):
    def __init__(self, name):
        super().__init__(name)
        self.gender = "male"
m = Male('xiaoyang')
op(m)

# 輸出：
<Male 0x23669a19fa0
  .gender = 'male',
  .name = 'xiaoyang'
>

在我們常用 super 的時候都通常會認為 super 是一個方法或者函數(shù)，但是實際上 super 是一個正兒八經(jīng)的 class，它是一個內(nèi)置內(nèi)的名字，然后 super() 并不是調(diào)用了一個函數(shù) ，super() 是建立 了一個 super 的對象

>>> type(super)
<class 'type'>

盡管我們更常用的是 super() 括號里面什么都沒有，但是 super 的完整版它里面應該是有兩個參數(shù)，第一個參數(shù)是一個 type 也就是一個 class，第二個參數(shù)是一個 type 或者是一個 object，其中第二個參數(shù)決定了這一個函數(shù)綁定到那個 object 或者 class 上，同時第二個參數(shù)決定了使用那個 mro，而第一個參數(shù)決定了在 mro 鏈上 從哪個class 開始往后找，例如；

from objprint import op
class Person:
    def __init__(self, name):
        self.name = name

class Male(Person):
    def __init__(self, name):
        # super().__init__(name)
        super(Male, self).__init__(name)
        self.gender = "male"

m = Male('xiaoyang')
op(m)

# 輸出：
<Male 0x171f680afa0
  .gender = 'male',
  .name = 'xiaoyang'
>

# 其實我們看剛才的 super().__init__(name) 它是等價于 super(Male, self).__init__(name) 的。

那么這個super(Male, self)它是做了這樣一個事情，首先它要從 self 這個 object 里面拿到 mro，然后他會找到第一個 argument，也就是 Male 在 mro 里所處的位置，那在當前的情況下 Male 就是最開始的那個（Male Person object）接下來他會從 Male 后面的那個 class 開始找，那它第一個找到的就是 Person，然后它就看Person 里面有沒有__init__這個函數(shù)，然后發(fā)現(xiàn)有這個函數(shù)，然后它在把這個__init__綁定到 self 上，在這里可以理解為這個 Person 的__init__函數(shù)傳進去的這個 self 就是 super 里面的這個 self，也就是說Person.__init__(self,name)這行代碼等價于 super(Male, self).__init__(name)這行代碼。

至于為什么不直接使用Person.__init__(self,name)是有幾個原因：

• 在未來有可能會改變基類的名字，甚至會改變繼承的方式，在這種情況下如果使用 super 的話就什么都不用管，應為他會自動追隨這個 mro 找到正確的 class ，但是用這種命名的 class 的話就要全部修改，這樣更容易引起錯誤
• 其實 super 是動態(tài)的，他會根據(jù) self 的 mro 進行尋找，而 self 也就是傳進來的這個 argument 它本身是動態(tài)的，也就是說同樣一個函數(shù)里面，我用 super 在不改變這個函數(shù)的情況下我有可能會拿到不同的 class。

在來看這個示例：

from objprint import op

class Animal:
    def __init__(self, age):
        self.age = age

class Person(Animal):
    def __init__(self, age, name):
        super().__init__(age)
        self.name = name

class Male(Person):
    def __init__(self,age, name):
        # super(Male, self).__init__(age, name) 
        super(Person, self).__init__(age, name) 
        self.gender = "male"

m = Male(18， 'xiaoyang')
op(m)

如果在 Male 中正常的使用它 super(Male, self).__init__(age, name) ，那么它就會正常的初始化所有的東西，它會訪問這個 Person 的 __init__ ，然后 Person 的__init__會訪問 Animal 的__init__，最后就完成了這個 Male。

那如果把它改成super(Person, self).__init__(age, name) ，那么就會報錯，因為當我們使用 super(Person, self)的時候，self 的 mro 鏈是 Male Person Animal 然后是 object，那第一個參數(shù)它由于是 Person，所以他會從 Person 后面的那個 class 也就是 Animal 開始找，那 Animal 是有__init__函數(shù)的，但是 Animal 的 __init__ 只有一個參數(shù) age，所以當我們傳入 age name 的時候那就錯了，這時候就只需要將它改成只傳進去一個 age 如： super(Person, self).__init__(age) 就可以了，同時也跳過了 Person。

總結(jié) super 的兩個參數(shù)也就是第一個 type 和第二個 type 或者 object 分別決定了什么：

第一個只決定了在 mro 這個鏈上從哪里開始找

第二個是決定使用這個函數(shù)的對象和 mro

super 并不是只能在 class 里面使用的，它可以在任何一個地方使用，我只要給定 第二個參數(shù) object 或者 class ，在給定第一個參數(shù)從哪里開始找，我就能使用它的函數(shù)，例如：

# 那這里的話就是從 m 這個 object 的 mro 上尋找 Male 后面開始的 __init__ 函數(shù)，這樣實際上就找到了 Person 的 __init__ 函數(shù)，然后再用 Person 的 __init__ 函數(shù)對 m 這個 object 做初始化
from objprint import op

class Animal:
    def __init__(self, age):
        self.age = age

class Person(Animal):
    def __init__(self, age, name):
        super().__init__(age)
        self.name = name

class Male(Person):
    def __init__(self,age, name):
        super(Person, self).__init__(age)
        self.gender = "male"

m = Male(18, 'xiaoyang')
op(m)

print("----------------------")

super(Male, m).__init__(20, "xiaoyang")
op(m)

# 輸出：
<Male 0x18412d13f70
  .age = 18,
  .gender = 'male'
>
----------------------
<Male 0x18412d13f70
  .age = 20,
  .gender = 'male',
  .name = 'xiaoyang'
>

附：super的典型用法

很多人對super直觀的理解是，調(diào)用父類中的方法：

class A:
? ? def test(self):
? ? ? ? print('A.test')

class B(A):
? ? def test(self):
? ? ? ? super().test()
? ? ? ? print('B.test')

b = B()
b.test()

執(zhí)行結(jié)果為：

A.test
B.test

從上面的例子看來，super確實可以調(diào)用父類中的方法。但是看下面的代碼：

class A:
? ? def test(self):
? ? ? ? print('A.test')

class TestMixin:
? ? def test(self):
? ? ? ? print('TestMixin.test')
? ? ? ? super().test()

class B(TestMixin, A):
? ? def test(self):
? ? ? ? print('B.test')
? ? ? ? super().test()


b = B()
b.test()

打印結(jié)果：

B.test
TestMixin.test
A.test

上面的代碼先創(chuàng)建B的對象b，然后調(diào)用b.test()，但是B的test函數(shù)通過super()，會調(diào)到第一個父類TestMixin的test函數(shù)，因為TestMixin是B的第一個父類。

TestMixin中的test函數(shù)中通過super調(diào)到了A中的test函數(shù)，但是A不是TestMixin的父類。在這個繼承體系中，A和TestMixin都是B的父類，但是A和TestMixin沒有任何繼承關(guān)系。為什么TestMixin中的super會調(diào)到A中的test函數(shù)呢？

總結(jié) 

到此這篇關(guān)于Python中Super用法的文章就介紹到這了,更多相關(guān)Python Super詳解內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！