歡迎光臨
我們一直在努力

Python學習:15.Python物件導向(二、繼承的各種情況)

文章摘要: class C(A)廣度優先多種情況解析 情況一 有A、B、C、D、E幾個類

一、什麼是繼承

繼承是一種建立類的方法,在python中,一個類可以繼承來自一個或多個父。原始類稱為基類或超類。

#建立父類
class Parent1:
    pass

class Parent2:
    pass

# 繼承父類,單繼承
class Obj1(Parent1):
    pass

#繼承父類,多繼承
class Obj2(Parent1,Parent2):
    pass

二、什麼時候使用繼承

在已經建立的幾個類中,這幾哥類中的方法和變數有相同的,這種時候我們就可以使用類的繼承,將其它類中已有的方法和變數通過繼承的方式,在新建立的類中,使用正常的方式就可以呼叫父類中的方法。剩下自己特有的方法只要在自己類中定義就可以。

舉個列子:人都會吃,喝,玩,小明也是一個人,所以小明也會,所以小明繼承了人的屬性,特別的是小明還會背古詩,就基於以上的說法寫一個類的繼承。

class Man:

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def play(self):
        print('玩')


class XiaoMing(Man):

    def recite(self):
        print('背古詩')

xm = XiaoMing()
xm.eat()
xm.recite()


輸出結果:
吃
背古詩

三、單繼承與多繼承

單繼承:僅僅繼承一個父類,當查詢方法的時候,首先在自己裏面查詢,然後到父類裏面查詢。

class Biology:
    def split(self):
        print(self.name+" accrue")

class Animal(Biology):#在類後面加括號加上所要繼承類的名字,繼承的是類的方法
    def GoWhoring(self):
        print("i like go whoring")
    def eat(self):
        print(self.name+" eat")

class superman:
    def gamble(self):
        print("gamble is interesting")
    def GoWhoring(self):
        print("beautiful whoring")
        
class Cat(Animal):
    def GoWhoring(self):
        print("i don't like go whoring")
    def __init__(self,name):
        self.name = name
    def cry(self):
        print(self.name + " 喵")
                                                    #優先順序:自己,父類(左邊,右邊)
class Dog(Animal,superman):#在繼承多個父類時,在兩個父類都有同一個名字的方法時,優先選擇括號左邊的父類的方法
    def __init__(self,name):
        self.name = name
    def cry(self):
        print(self.name + " 汪")

mimi = Cat("mimi")
mimi.eat()
mimi.cry()                #當基類裡方法存在,派生類裡也存在同名方法,優先找派生類裡的方法
mimi.GoWhoring() #當父類裡有一個方法自己也有一個同名的方法時,預設使用自己的方法
husike = Dog("erha")#雖然Dog裡沒有eat和split但是由於Dog繼承了Animal和的方法,而Animal繼承了Biology的方法
husike.eat()            #所以Dog可以使用Biology的方法    
husike.cry()            #父類有一個名字叫"基類"  子類有一個名字叫"派生類"
husike.split()
husike.GoWhoring()
faker = Animal()
faker.GoWhoring()#優先使用自己的方法

派生類可以繼承基類裡的所有功能。

當基類裡方法存在,派生類裡也存在同名方法,派生類優先找派生類裡的方法(意思是優先找自己的)。

在Java、C#裏面一個子類只能繼承一個父類,多了報錯,但是在python裡可以繼承多個父類

在經典類中,繼承是以深度優先,在新式類中,繼承是以廣度優先。

Python 2.x中預設都是經典類,只有顯式繼承了object纔是新式類。

python 3.x中預設都是新式類,經典類被移除,不必顯式的繼承object。

深度優先:

class A():
    def save(self):
        print("This is from A")
class B(A):
    pass
class C(A):
    def save(self):
        print("This is from C")
class D(B,C):
    pass

fun =  D()
fun.save()

輸出結果:
This is from A"

深度優先的時候就是一條道走到黑,從左向右找,先把左邊的一個裏面的全部找完在找右邊的。

廣度優先:

class A():
    def save(self):
        print("This is from A")
class B(A):
    pass

class C(A):
    def save(self):
        print("This is from C")
class D(B,C):
    pass

fun =  D()
fun.save()

輸出結果:
This is from C

首先在左邊的上一層父類中尋找,如果沒有就到右邊一個父類中尋找,沒有就到左邊父類的父類中尋找。

廣度優先多種情況解析

情況一

有A、B、C、D、E幾個類,A為B的父類,B為C的父類,E為D的父類,D為C的父類 現在C需要使用一個方法,只有在A,E裡有,第一次C先去B中尋找沒有找到 然後就會去A裏面找,A裡沒有就去D裏面找,然後再去E裡找。

class A:
    def function(self):
        print("are you OK?A")

class B(A):
    def function_fake(self):
        print("are you OK?B")

class E:
    def function(self):
        print("are you OK?E")

class D(E):
    def function_fake(self):
        print("are you OK?D")

class C(B, D):
    def Sb(self):
        print("i am sb")

faker = C()
faker.function()

輸出結果:
are you OK?A

括號裡為查詢順序。

情況二

它會先把沒有共同的父類尋找玩,然後再找共同的父類,因為在這種情況下它想找到和自己關係最近的。

class S:
    def function(self):
        print('are you Ok?S')

class A(S):
    def function_fake(self):
        print("are you OK?A")

class B(A):
    def function_fake(self):
        print("are you OK?B")

class E(S):
    def function(self):
        print("are you OK?E")

class D(E):
    def function_fake(self):
        print("are you OK?D")

class C(B, D):
    def Sb(self):
        print("i am sb")

faker = C()
faker.function()

輸出結果:
are you OK?E

情況三

當A、B、D、E、都沒有C所要找的函式時纔會找右邊的F(括號右邊)

class F():
    def function(self):
        print("are you OK?F")

class A:
    def function_fake(self):
        print("are you OK?A")

class E:
    def function_fake(self):
        print("are you OK?E")

class B(A,F):
    def function_fake(self):
        print("are you OK?B")

class D(E):
    def function_fake(self):
        print("are you OK?D")

class C(B, D):
    def Sb(self):
        print("i am sb")


faker = C()
faker.function()


輸出結果:
are you OK?F

情況四

首先面執行一個 c1 = C();c1.xxx() ,xxx在D裏面而且xxx又執行了self.ooo() 而ooo在BDE裡都有它會執行哪個?

class B:
    def ooo(self):
        print("B")


class E:
    def ooo(self):
        print("E")


class D(E):
    def xxx(self):
        self.ooo()

    def ooo(self):
        print("D")


class C(B, D):
    pass


c1 = C()
c1.xxx()

輸出結果:
B

解析:首先找到c1.xxx在D裏面,在D裏面又執行了self.ooo(),這個self代指c1,而c1為C類的物件,意思還是c1.ooo,所以尋找ooo時還是從C開始,因為先找左邊的所以,找到了B的ooo 以後找是誰執行的函式要看準self到底是誰的從self下手。

紅色為第二次尋找路徑(尋找ooo方法的次序)

今天的類的繼承主要是多繼承的時候父類中方法選擇的。

未經允許不得轉載:頭條楓林網 » Python學習:15.Python物件導向(二、繼承的各種情況)