Python中的Super用法示例詳解

更新時間：2022年04月18日 08:21:53 作者：Mr-Yang

Python中可以直接通過調用父類名調用父類方法,在多重繼承中,使用super()是一個很好的習慣,下面這篇文章主要給大家介紹了關于Python中Super用法的相關資料,文中通過示例代碼介紹的非常詳細,需要的朋友可以參考下

Python Super用法

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

# 就是我有一個 class 比如說是 Male，然后繼承另外一個 class 比如是 Person，然后我在這個 Male 也就是它的子類的 init 函數里面用 super().__init__() 來調用它父類的初識化函數
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 是一個方法或者函數，但是實際上 super 是一個正兒八經的 class，它是一個內置內的名字，然后 super() 并不是調用了一個函數，super() 是建立了一個 super 的對象

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

盡管我們更常用的是 super() 括號里面什么都沒有，但是 super 的完整版它里面應該是有兩個參數，第一個參數是一個 type 也就是一個 class，第二個參數是一個 type 或者是一個 object，其中第二個參數決定了這一個函數綁定到那個 object 或者 class 上，同時第二個參數決定了使用那個 mro，而第一個參數決定了在 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__這個函數，然后發(fā)現(xiàn)有這個函數，然后它在把這個__init__綁定到 self 上，在這里可以理解為這個 Person 的__init__函數傳進去的這個 self 就是 super 里面的這個 self，也就是說Person.__init__(self,name)這行代碼等價于 super(Male, self).__init__(name)這行代碼。

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

在未來有可能會改變基類的名字，甚至會改變繼承的方式，在這種情況下如果使用 super 的話就什么都不用管，應為他會自動追隨這個 mro 找到正確的 class ，但是用這種命名的 class 的話就要全部修改，這樣更容易引起錯誤
其實 super 是動態(tài)的，他會根據 self 的 mro 進行尋找，而 self 也就是傳進來的這個 argument 它本身是動態(tài)的，也就是說同樣一個函數里面，我用 super 在不改變這個函數的情況下我有可能會拿到不同的 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，那第一個參數它由于是 Person，所以他會從 Person 后面的那個 class 也就是 Animal 開始找，那 Animal 是有__init__函數的，但是 Animal 的 __init__ 只有一個參數 age，所以當我們傳入 age name 的時候那就錯了，這時候就只需要將它改成只傳進去一個 age 如： super(Person, self).__init__(age) 就可以了，同時也跳過了 Person。

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

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

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

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

# 那這里的話就是從 m 這個 object 的 mro 上尋找 Male 后面開始的 __init__ 函數，這樣實際上就找到了 Person 的 __init__ 函數，然后再用 Person 的 __init__ 函數對 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直觀的理解是，調用父類中的方法：

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

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

b = B()
b.test()

執(zhí)行結果為：

A.test
B.test

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

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()

打印結果：