在現實生活中，繼承一般指的是子女繼承父輩的財產，如下圖
搞不好,結果如下…
在程序中繼承是描述事物之間的所屬關係，例如貓和狗都屬於動物，程序中便可以描述爲貓和狗繼承自動物；同理，波斯貓和巴釐貓都繼承自貓，而沙皮狗和斑點狗都繼承自狗，如下如所示：
子類可以繼承父類的公共屬性和公共方法，父類中私有的屬性和方法不能被繼承。
一般只繼承一個父類就叫做單繼承，在java等靜態語言中只能繼承一個父類，也就不存在單繼承和多繼承了。
示例代碼：
# 定義一個父類，如下:
如果你對python感興趣，我這有個學習Python基地，裏面有很多學習資料，感興趣的+Q羣：688244617
class Cat(object):
def __init__(self, name, color="白色"):
self.name = name
self.color = color
def run(self):
print("%s--在跑"%self.name)
# 定義一個子類，繼承Cat類如下:
class Bosi(Cat):
# 子類沒有實現__init__方法，則自動調用父類的__init__方法
def setNewName(self, newName):
self.name = newName
def eat(self):
print("%s--在吃"%self.name)
bs = Bosi("印度貓")
print('bs的名字爲:%s'%bs.name)
print('bs的顏色爲:%s'%bs.color)
bs.eat()
bs.setNewName('波斯')
bs.run()
"""
輸出結果：
bs的名字爲:印度貓
bs的顏色爲:白色
印度貓--在吃
波斯--在跑
"""
從圖中能夠看出，所謂多繼承，即子類有多個父類，並且具有它們的特徵。
多繼承的格式如下：
# 定義一個父類
class A:
def printA(self):
print('----A----')
# 定義一個父類
class B:
def printB(self):
print('----B----')
# 定義一個子類，繼承自A、B
class C(A,B):
def printC(self):
print('----C----')
obj_C = C()
obj_C.printA()
obj_C.printB()
"""
輸出結果：
----A----
----B----
"""
如果在上面的多繼承例子中，如果父類A和父類B中，有一個同名的方法，那麼通過子類去調用的時候，調用哪個？
class A:
def print(self):
print('----A----')
class B:
def print(self):
print('----B----')
# 定義一個子類，繼承自A、B
class C(A,B):
pass
obj_C = C()
obj_C.print()
"""
輸出結果：
----A----
"""
事實上調用的順序取決於C類先繼承的是哪個類，先繼承的類會先被調用。
也可通過__mor__查看C類的對象搜索方法時的先後順序，接上面的代碼
print(C.__mro__)
"""
輸出結果：
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
"""
所謂重寫，就是子類中，有一個和父類相同名字的方法，在子類中的方法會覆蓋掉父類中同名的方法
class Cat:
def sayHello(self):
print("halou-----1")
class Bosi(Cat):
def sayHello(self):
print("halou-----2")
class Bali(Cat):
def sayHello(self):
print("halou-----3")
bosi = Bosi()
bali= Bali()
bosi.sayHello()
bali.sayHello()
"""
輸出結果：
halou-----2
halou-----3
"""
通過方法重寫我們可以讓父類的同一個行爲在子類中擁有不同的實現版本，當我們調用這個經過子類重寫的方法時，不同的子類對象會表現出不同的行爲，這個就是多態（poly-morphism）。
class Cat:
def __init__(self,name):
self.name = name
class Bosi(Cat):
def __init__(self,name):
# 調用父類的__init__方法1(python2)
#Cat.__init__(self,name)
# 調用父類的__init__方法2
#super(Bosi,self).__init__(name)
# 調用父類的__init__方法3
super().__init__(name)
self.color = 'yellow'
def getName(self):
return self.name
bosi = Bosi('xiaohua')
print(bosi.name)
print(bosi.color)
"""
輸出結果：
xiaohua
yellow
"""
總結：
上文說過如果在子類中需要父類的構造方法就需要顯式地調用父類的構造方法，或者不重寫父類的構造方法，子類不重寫 init ，實例化子類時，會自動調用父類定義的 init 。
如果子類重寫了__init__ 時，實例化子類，就不會調用父類已經定義的 init 。
如果重寫了__init __ 時，要繼承父類的構造方法，可以使用如下方法：
super(子類，self).init(參數1，參數2，…)
父類名稱.init(self,參數1，參數2，…)
多態的概念是應用於Java和C#這一類強類型語言中，而Python崇尚“鴨子類型”。