Python面向對象三大特徵之繼承

咱們都知道Python面向對象編程有三大特徵，繼承，封裝和多態，下面幾篇問題，咱們會分別講述着幾大特徵。

今天說的是繼承，若是有編程基礎的人對這個詞應該不會陌生，繼承是一種建立新類的方式，新建的類能夠繼承一個或多個父類（python支持多繼承），父類又可稱爲基類或超類，新建的類稱爲派生類或子類，而子類會「」遺傳」父類的屬性（數據屬性和函數屬性），從而解決代碼重用問題。

上面這段話就是繼承的概念和使用繼承所要達到的目的。

下面咱們來看看具體代碼案例，繼續的大體寫法就是

子類名（父類1，父類2，。。。）

Python是能夠實現對繼承的，有些編程語法是隻能單繼承。

class ParentClass:
    name= '父類'
    def __init__(self,size,color):
        self.size = size
        self.color = color

    def fun(self):
        print('我來自父類')


class SubClass(ParentClass):
        name = '子類'
        pass
#實例化對象
s1 = SubClass('30','red')

#{'size': '30', 'color': 'red'} 若是子類沒有構造方法的話，子類屬性會找到父類的構造方法，繼承父類的數據屬性
print(s1.__dict__)

#(<class 'object'>,) python3中統一都是新式類,因此若是不加繼承的父類，默認的父類是object類
print(ParentClass.__bases__)

#(<class '__main__.ParentClass'>,) 子類的父類
print(SubClass.__bases__)

# "我來自父類" 子類對象調用父類的方法
s1.fun()

#子類對象調用數據屬性，會先在子類中找，若是找不到會去父類的做用域裏面找
#這裏子類裏面定義了name屬性因此結果是： 子類
#若是子類裏面沒有定name，結果就是：父類
print(s1.name)
複製代碼

這段是繼承大體的用法，子類能夠繼承父類的數據屬性和函數屬性。下面咱們說說使用繼承的好處及代碼重用和重寫，組合的用法

代碼重用

咱們如今有2個類貓和狗，它們都是動物，那若是咱們要描述貓和狗這2個類的話，咱們會存在大量的重複代碼，以下

class Cat:
    def cry(self):
        print('喵喵')
    def  eat(self):
        print('吃')
    def run(self):
        print('跑')
    def jump(self):
        print('跳')


class Dog:
    def cry(self):
        print('汪汪')
    def eat(self):
        print('吃')
    def run(self):
        print('跑')
    def jump(self):
        print('跳')

cat1 =  Cat()
dog1 = Dog()
cat1.cry()
dog1.cry()
複製代碼

上面2個類也許除了cry方法，其餘的方法都是同樣的，都貓和狗贊成的動做，那像上面那樣寫，就會出現大量的重複代碼，下面咱們用繼承來改寫

class animal:
    def cry(self):
        print('動物叫')
    def eat(self):
        print('吃')
    def run(self):
        print('跑')
    def jump(self):
        print('跳')

class Cat(animal):
    def cry(self):
        print('喵喵')

class Dog(animal):
    def cry(self):
        print('汪汪')

cat1 =  Cat()
dog1 = Dog()
cat1.cry()  #喵喵
dog1.cry()  #汪汪
cat1.eat() #吃
dog1.eat() #吃
複製代碼

上面咱們定義了一個animal的父類，把子類的相同部分放入父類，子類就能夠用繼承的方式來調用父類的函數屬性或者說方法了，而不用再類裏面再重複編碼。

2. 類的方法重寫

其實上面的例子咱們已經用到重寫，就是父類定義了一個方法，可是子類和父類的方法實現不同，要達到另一個功能，比較上面

父類的cry方法時： ‘動物叫’

子類Cat的cry要實現：‘喵喵叫’

子類Dog的cry要實現：‘汪汪叫’

這種狀況就要使用重寫

class animal:
    def cry(self):
        print('動物叫')
    def eat(self):
        print('吃')
    def run(self):
        print('跑')
    def jump(self):
        print('跳')

class Cat(animal):
    def cry(self):
        print('喵喵')

class Dog(animal):
    def cry(self):
        print('汪汪')

cat1 =  Cat()
dog1 = Dog()
cat1.cry()  #喵喵 重寫父類cry方法
dog1.cry()  #汪汪 重寫父類cry方法
複製代碼

3. 子類的方法派生，就是子類能夠定義本身的方法

class animal:
   def cry(self):
       print('動物叫')
   def eat(self):
       print('吃')
   def run(self):
       print('跑')
   def jump(self):
       print('跳')

class Cat(animal):
   def cry(self):
       print('喵喵')
   def  swoop(self): #定義子類的方法
       print('飛撲')


cat1 =  Cat()
cat1.swoop()
複製代碼

4.類的組合，組合指的是，在一個類中以另一個類的對象做爲數據屬性，稱爲類的組合,當類之間有顯著不一樣，而且較小的類是較大的類所須要的組件時，用組合比較好.

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr


    def recruit(self):
        print('%s xxx計算機學校訂在招生' %self.name)

class Course:
    def __init__(self,name,price,period,School):
        self.name=name
        self.price=price
        self.period=period
        self.school=School  #實現Course和School的組合
s1=School('xxx計算機學校','北京')
s2=School('xxx計算機學校','南京')
s3=School('xxx計算機學校','上海')

msg=''' 1 xxx計算機學校 北京校區 2 xxx計算機學校 南京校區 3 xxx計算機學校 上海校區 '''
while True:
    print(msg)
    menu={
        '1':s1,
        '2':s2,
        '3':s3
    }
    choice=input('選擇學校>>: ')
    school_obj=menu[choice]
    name=input('課程名>>： ')
    price=input('課程費用>>： ')
    period=input('課程週期>>： ')
    new_course=Course(name,price,period,school_obj)
    print('課程【%s】屬於【%s】學校' %(new_course.name,new_course.school.name))  #實現Course和School的組合
複製代碼

5.Python實現接口

接口就是定義抽象函數，不作具體函數實現，起到規範子類的做用，讓子類必須實現接口的抽象函數。接口提取了一羣類共同的函數，能夠把接口當作一個函數的集合。而後讓子類去實現接口中的函數。這麼作的意義在於歸一化，什麼叫歸一化，就是隻要是基於同一個接口實現的類，那麼全部的這些類產生的對象在使用時，從用法上來講都同樣。

歸一化的好處在於：

1. 歸一化讓使用者無需關心對象的類是什麼，只須要的知道這些對象都具有某些功能就能夠了，這極大地下降了使用者的使用難度。

2. 歸一化使得高層的外部使用者能夠不加區分的處理全部接口兼容的對象集合

下面上代碼

import abc #利用abc模塊實現抽象類
class Interface(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod  #抽象方法，不作具體實現
    def test1(self):
        pass
    @abc.abstractclassmethod
    def test2(self):
        pass
class SubClass(Interface):
    def test1(self):
        print('實現抽象方法1')
    def test2(self):
        print('實現抽象方法2')

s1 = SubClass()
複製代碼

若是咱們子類裏面不實現具體的抽象函數，會報錯

import abc #利用abc模塊實現抽象類
class Interface(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod  #抽象方法，不作具體實現
    def test1(self):
        pass
    @abc.abstractclassmethod
    def test2(self):
        pass
class SubClass(Interface):
    def test1(self):
        print('實現抽象方法1')
#不實現test2方法
s1 = SubClass()
複製代碼

報錯信息：

Traceback (most recent call last): File "C:/Users/aryin/Desktop/mysite2/繼承.py", line 16, in s1 = SubClass() TypeError: Can't instantiate abstract class SubClass with abstract methods test2

6.類繼承的順序，根據類的MRO屬性

class A:
   def test(self):
       print('A')
class B(A):
   def test(self):
       print('B')

class C(A):
   def test(self):
       print('C')

class D(B):
   def test(self):
       print('D')

class E(C):
   def test(self):
       print('E')

class F(D,E):
   def test(self):
       print('F')
       
# (<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
print(F.__mro__) 
複製代碼

類繼承是是按照MRO屬性裏面的順序去調用父類的屬性

7.子類調用父類的方法，是經過super函數來實現的，在複雜的類繼承關係中，super()的取值是按照上面的MRO裏面的順序來定的。

class animal:
    def __init__(self,name,type,size,color):
        self.name = name
        self.type = type
        self.size = size
        self.color = color
    def cry(self):
        print('動物叫')
    def eat(self):
        print('吃')

class Cat(animal):
    def __init__(self,name,type,size,color,age):
        super().__init__(name,type,size,color)  #調用父類的構造函數，這是super最經常使用的地方
        self.age = age
    def cry(self):
        super().cry()  #子類從新了父類的方法,可是同時又要實現父類中cry方法
        print('喵喵')

cat1 = Cat('毛球','波斯貓',10,'白色','5歲')

# 動物叫
# 喵喵
cat1.cry()
複製代碼