繼承.

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

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

 1 復制代碼
 2 class ParentClass1: #定義父類
 3     pass
 4 
 5 class ParentClass2: #定義父類
 6     pass
 7 
 8 class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
 9     pass
10 
11 class SubClass2(ParentClass1,ParentClass2): #
 
python支持多繼承，用逗號分隔開多個繼承的類
12     pass

查看繼承

>>> 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‘>,)

　　繼承的重要性

  1 ==========================第一部分
  2 例如
  3 
  4 　　貓可以：爬樹、吃、喝、拉、撒
  5 
  6 　　狗可以：看門、吃、喝、拉、撒
  7 
  8 如果我們要分別為貓和狗創建一個類，那麽就需要為 貓 和 狗 實現他們所有的功能，偽代碼如下：
  9  
 10 
 11
 
 #貓和狗有大量相同的內容
 12 class 貓：
 13 
 14     def爬樹(self):
 15         print ‘爬樹‘
 16 
 17     def 吃(self):
 18         # do something
 19 
 20     def 喝(self):
 21         # do something
 22 
 23     def 拉(self):
 24         # do something
 25 
 26     def 撒(self):
 27         # do something
 28 
 29 class 狗：
 30 
 31     def 看門(self):
 32         print ‘看門‘
 33 
 34     def 吃(self):
 35         # do something
 36 
 37     def 喝(self):
 38         # do something
 39 
 40     def 拉(self):
 41         # do something
 42 
 43     def 撒(self):
 44         # do something
 45 
 46 
 47 
 48 ==========================第二部分
 49 上述代碼不難看出，吃、喝、拉、撒是貓和狗都具有的功能，而我們卻分別的貓和狗的類中編寫了兩次。如果使用 繼承 的思想，如下實現：
 50 
 51 　　動物：吃、喝、拉、撒
 52 
 53 　　   貓：爬樹（貓繼承動物的功能）
 54 
 55 　　   狗：看門（狗繼承動物的功能）
 56 
 57 偽代碼如下：
 58 class 動物:
 59 
 60     def 吃(self):
 61         # do something
 62 
 63     def 喝(self):
 64         # do something
 65 
 66     def 拉(self):
 67         # do something
 68 
 69     def 撒(self):
 70         # do something
 71 
 72 # 在類後面括號中寫入另外一個類名，表示當前類繼承另外一個類
 73 class 貓(動物)：
 74 
 75     def爬樹(self):
 76         print ‘爬樹‘
 77 
 78 # 在類後面括號中寫入另外一個類名，表示當前類繼承另外一個類
 79 class 狗(動物)：
 80 
 81      def 看門(self):
 82         print ‘看門‘
 83 
 84 
 85 
 86 
 87 ==========================第三部分
 88 #繼承的代碼實現
 89 class Animal:
 90 
 91     def eat(self):
 92         print("%s 吃 " %self.name)
 93 
 94     def drink(self):
 95         print ("%s 喝 " %self.name)
 96 
 97     def shit(self):
 98         print ("%s 拉 " %self.name)
 99 
100     def pee(self):
101         print ("%s 撒 " %self.name)
102 
103 
104 class Cat(Animal):
105 
106     def __init__(self, name):
107         self.name = name
108         self.breed = ‘貓‘
109 
110     def爬樹(self):
111         print ‘爬樹‘
112 
113 class Dog(Animal):
114 
115     def __init__(self, name):
116         self.name = name
117         self.breed=‘狗‘
118   
119     def 看門(self):
120         print ‘看門‘
121 
122 
123 
124 # ######### 執行 #########
125 
126 c1 = Cat(‘小白家的小黑貓‘)
127 c1.eat()
128 
129 c2 = Cat(‘小黑的小白貓‘)
130 c2.drink()
131 
132 d1 = Dog(‘胖子家的小瘦狗‘)
133 d1.eat()
134 
135 使用繼承來重用代碼比較好的例子繼承的重要性
136 
137 繼承可以減少代碼重用

那麽問題又來了，多繼承呢？

• 是否可以繼承多個類
• 如果繼承的多個類每個類中都定了相同的函數，那麽那一個會被使用呢？

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

2、Python的類如果繼承了多個類，那麽其尋找方法的方式有兩種，分別是：深度優先和廣度優先

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

經典類和新式類，從字面上可以看出一個老一個新，新的必然包含了跟多的功能，也是之後推薦的寫法，從寫法上區分的話，如果 當前類或者父類繼承了object類，那麽該類便是新式類，否則便是經典類。

 1 class D:
 2 
 3     def bar(self):
 4         print ‘D.bar‘
 5 
 6 
 7 class C(D):
 8 
 9     def bar(self):
10         print ‘C.bar‘
11 
12 
13 class B(D):
14 
15     def bar(self):
16         print ‘B.bar‘
17 
18 
19 class A(B, C):
20 
21     def bar(self):
22         print ‘A.bar‘
23 
24 a = A()
25 # 執行bar方法時
26 # 首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續去D類中找，如果D類中麽有，則繼續去C類中找，如果還是未找到，則報錯
27 # 所以，查找順序：A --> B --> D --> C
28 # 在上述查找bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了
29 a.bar()
30 
31 經典類多繼承
32 
33 經典類多繼承

 1 class D(object):
 2 
 3     def bar(self):
 4         print ‘D.bar‘
 5 
 6 
 7 class C(D):
 8 
 9     def bar(self):
10         print ‘C.bar‘
11 
12 
13 class B(D):
14 
15     def bar(self):
16         print ‘B.bar‘
17 
18 
19 class A(B, C):
20 
21     def bar(self):
22         print ‘A.bar‘
23 
24 a = A()
25 # 執行bar方法時
26 # 首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續去C類中找，如果C類中麽有，則繼續去D類中找，如果還是未找到，則報錯
27 # 所以，查找順序：A --> B --> C --> D
28 # 在上述查找bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了
29 a.bar()
30 
31 新式類多繼承

經典類：首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續去D類中找，如果D類中麽有，則繼續去C類中找，如果還是未找到，則報錯

新式類：首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中麽有，則繼續去C類中找，如果C類中麽有，則繼續去D類中找，如果還是未找到，則報錯

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

Python-面向對象-繼承