pythonday17

一, 繼承

　　繼承是一種創建新類的方式，在python中，新建的類可以繼承一個或多個父類，父類又可稱為

　　基類或超類，新建的類稱為派生類或子類

　　1. python中類的繼承分為：單繼承和多繼承

        class ParentClass1: #定義父類
            pass

        class ParentClass2: #定義父類
            pass

        class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
            pass

        class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
            pass

　　2. 查看繼承

        >>> SubClass1.__bases__ #__base__只查看從左到右繼承的第一個子類，__bases__則是查看所有繼承的父類
        (<class '__main__.ParentClass1'>,)
        >>> SubClass2.__bases__
        (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

　　提示：如果沒有指定基類，python的類會預設繼承object類，object是所有python類的基

　　類，它提供了一些常見方法（如__str__）的實現。

        >>> ParentClass1.__bases__
        (<class 'object'>,)
        >>> ParentClass2.__bases__
        (<class 'object'>,)

　　3. 繼承的重要性

========================第一部分
        例如
   
　        　貓可以：爬樹、吃

　        　狗可以：看門、吃

        如果我們要分別為貓和狗創建一個類，那麼就需要為 貓 和 狗 實現他們所有的功能，偽代碼如下：
 

        #貓和狗有大量相同的內容
        class 貓：

            def爬樹(self):
                print '爬樹'

            def 吃(self):
                # do something

        class 狗：

            def 看門(self):
                print '看門'

            def 吃(self):
                # do something


========================第二部分
        上述代碼不難看出，吃是貓和狗都具有的功能，而我們卻分別的貓和狗的類中編寫了兩次。如果使用 繼承 的思想，
        如下實現：

　        　動物：吃

　　           貓：爬樹（貓繼承動物的功能）

　　           狗：看門（狗繼承動物的功能）

        偽代碼如下：
        class 動物:

            def 吃(self):
                # do something
      
        # 在類後面括弧中寫入另外一個類名，表示當前類繼承另外一個類
        class 貓(動物)：

            def爬樹(self):
                print '爬樹'

        # 在類後面括弧中寫入另外一個類名，表示當前類繼承另外一個類
        class 狗(動物)：

             def 看門(self):
                print '看門'


========================第三部分
       #繼承的代碼實現
        class Animal:

            def eat(self):
                print("%s 吃 " %self.name)


        class Cat(Animal):

            def __init__(self, name):
                self.name = name
                self.breed = '貓'

            def爬樹(self):
                print '爬樹'

        class Dog(Animal):

            def __init__(self, name):
                self.name = name
                self.breed='狗'
  
            def 看門(self):
                print '看門'


# ######### 執行 #########

        c1 = Cat('小白家的小黑貓')
        c1.eat()


        d1 = Dog('胖子家的小瘦狗')
        d1.eat()

        使用繼承來重用代碼比較好的例子    

　　4. 繼承的好處

　　　a,提高了代碼的復用性
　　　b：提高了代碼的維護性
　　　c：讓類與類之間產生了關係，是多態的前提

　　5. 

        class Animal:
            zhuangtai='能運動'
            qiguan='有大腦'
            def __init__(self,name,sex,age):
                self.name=name
                self.sex=sex
                self.age=age
           def food(self):
                print('不好吃')

        class Person(Animal):
            def __init__(self, name, sex, age,shenggao):
                Animal.__init__(self, name, sex, age) #用類名調用方法,調用父類中的構造方法並執行.
                #super().__init__(name,sex,age)
                self.shenggao=shenggao

            def work(self,):
                print('每天上班')


        class Dog(Animal):
           def food(self):
                super().food()     #用super關鍵字使父類與子類中的food方法調用                                           #法都執行,super自動把self接收到的對象傳給
                           　　　　 # 父類,不用在其()內寫self
                print('屎很香')


        p1=Person('李','男','20',165)
        d1=Dog('旺財','公',10)
        print(p1.zhuangtai)     #用對象調用父類
        print(Person.zhuangtai)    #用類調用父類
        print(p1.__dict__)
        d1.food()                

二, 多繼承

　　1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類

　　2、Python的類如果繼承了多個類，那麼其尋找方法的方式有兩種，分別是：

　　　深度優先和廣度優先

•    當類是經典類時，多繼承情況下，會按照深度優先方式查找
•    當類是新式類時，多繼承情況下，會按照廣度優先方式查找

　　3. 經典類和新式類，從字面上可以看出一個老一個新，新的必然包含了跟多的功能，也是之後

　　推薦的寫法，從寫法上區分的話，如果 當前類或者父類繼承了object類，那麼該類便是新

　　式類，否則便是經典類。

　　 4. 經典多繼承

        class D:

            def bar(self):
                print 'D.bar'
    

        class C(D):

            def bar(self):
                print 'C.bar'


        class B(D):

            def bar(self):
                print 'B.bar'


        class A(B, C):

            def bar(self):
                print 'A.bar'
    
        a = A()
        # 執行bar方法時
        # 首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續去D類中找，如果D類中麽有，則繼續去C類中找，如果還是未找到，則報錯
        # 所以，查找順序：A --> B --> D --> C
        # 在上述查找bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了
        a.bar()

　　 5. 新類多繼承

        class D(object):

            def bar(self):
                print 'D.bar'


        class C(D):

            def bar(self):
                print 'C.bar'


        class B(D):

            def bar(self):
                print 'B.bar'


        class A(B, C):

            def bar(self):
                print 'A.bar'

        a = A()
        # 執行bar方法時
        # 首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續去C類中找，如果C類中麽有，則繼續去D類中找，如果還是未找到，則報錯
        # 所以，查找順序：A --> B --> C --> D
        # 在上述查找bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了
        a.bar()

　　經典類：首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續

　　　去D類中找，如果D類中麽有，則繼續去C類中找，如果還是未找到，則報錯

　　新式類：首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續

　　　去C類中找，如果C類中麽有，則繼續去D類中找，如果還是未找到，則報錯

　　註意：在上述查找過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了