python之面向對象（繼承）

class GrandFather:
    def 喝花酒(self):
        pass


class Father():    # 父類或基類
    def 籃球(self):
        pass

    def 足球(self):
        pass

    def 抽菸(self):
        pass

    def 喝酒(self):
        pass

    def 燙頭(self):
        pass

class Son(Father):  # 子類或派生類
    def 保健(self):
        pass

s = Son()
s.保健()
s.喝酒()
s.喝花酒()   # 不能調用

只有Father繼承了GrandFather，Son繼承了Father，s才能調用喝酒（）和喝花酒（）

舉個例子

class F:
    def f1(self):
        print('F.f1')

    def f2(self):
        print('F.f2')

class S(F):
    def s1(self):
        print('S.s1')

    def s2(self):
        print('S.s2')

obj = S()  
obj.s1()   #  S.s1
obj.s2()   #  S.s2

重寫

class F:
    def f1(self):
        print('F.f1')

    def f2(self):
        print('F.f2')

class S(F):
    def s1(self):
        print('S.s1')

    def f2(self):
        print('S.f2')

obj = S()
obj.s1()   #  S.s1
obj.f2()   #  S.f2

不管執行的是子類的方法還是父類的方法，self永遠指調用方法的調用者 

class F:
    def f1(self):
        print('F.f1')

    def f2(self):
        print('F.f2')

class S(F):
    def s1(self):
        print('S.s1')

    def f2(self):
        print('S.f2')

obj = S()
obj.s1()  #  這一句執行的時候self是obj
obj.f1()  #  這一句執行的時候self還是obj
# 不管執行的是子類的方法還是父類的方法，self永遠指調用方法的調用者

既想執行父類中的f2，又想執行子類中的f2

class F:
    def f1(self):
        print('F.f1')

    def f2(self):
        print('F.f2')

class S(F):
    def s1(self):
        print('S.s1')

    def f2(self):
        # 找到父類，執行父類中的f2方法
        super(S, self).f2()
        # F.f2(self)   #  這種方法也可以，但是推薦用super
        print('S.f2')


# 既想調用父類的f2，又想調用子類的f2
obj = S()
obj.f2()  
# F.f2
# S.f2

栗子

如果用的是別人的代碼，想要修改一個功能，又不能修改源碼，就可以用繼承

# 別人的應用程序，或web框架
class RequestHandler:
    def get(self, arg):
        print('爲所欲爲')

class BaseRequestHandler(RequestHandler):
    def get(self, arg):
        super(BaseRequestHandler, self).get(arg)
        print('……')

obj = BaseRequestHandler()
obj.get(123)
# 爲所欲爲
# ……

多繼承

class F1:
    def a(self):
        print('F1.a')

class F2:
    def a(self):
        print('F2.a')

class S(F2, F1):
    pass

obj = S()
obj.a()   # F2.a

class F1:
    def a(self):
        print('F1.a')

class F2:
    def a(self):
        print('F2.a')

class S(F1, F2):
    pass

obj = S()
obj.a()  # F1.a

從左到右依次尋找，如果左邊的F1沒有，但是F1的父類有，會先找F1的父類F0，F0沒有才會再找F2。

class F0:
    def a(self):
        print('F0.a')

class F1(F0):
    def a1(self):
        print('F1.a')

class F2:
    def a(self):
        print('F2.a')

class S(F1, F2):
    pass

obj = S()
obj.a()  # F0.a

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

class F0(Base):
    def a1(self):
        print('F0.a')

class F1(F0):
    def a1(self):
        print('F1.a')

class F2(Base):
    def a(self):
        print('F2.a')

class S(F1, F2):
    pass

obj = S()
obj.a()  # F2.a

如果有共同的基類，會先把公共基類下面的找完了再找基類。

python中支持多繼承   a、左側優先    b、一條道走到黑     c、同一個根時，根最後執行。

class BaseRequest():
    pass

class RequestHandler(BaseRequest):
    def serve_forever(self):
        print('RequestHandler.serve_forever')
        self.process_request()

    def process_request(self):
        print('RequestHandler.process_request')

class Minx:
    def process_request(self):
        print('minx.process_request')

class Son(Minx, RequestHandler):
    pass

obj = Son()
obj.serve_forever()

# RequestHandler.serve_forever
# minx.process_request

class BaseRequest():
    def __init__(self):
        print('BaseRequest.init')


class RequestHandler(BaseRequest):

    def __init__(self):
        super(RequestHandler, self).__init__()
        print('RequestHandler.init')

    def serve_forever(self):
        print('RequestHandler.serve_forever')
        self.process_request()

    def process_request(self):
        print('RequestHandler.process_request')

class Minx:
    def process_request(self):
        print('minx.process_request')

class Son(Minx, RequestHandler):
    pass

obj = Son()
obj.serve_forever()



# BaseRequest.init
# RequestHandler.init
# RequestHandler.serve_forever
# minx.process_request