派生，super 多态与多态性 组合

派生的方法与重用：

方法一：指名道姓的调用某一类函数

>>> class Teacher(People):

...     def __init__(self,name,sex,age,title):

...         People.__init__(self,name,age,sex) #调用的是函数,因而需要传入self

...         self.title=title

...     def teach(self):

...         print('%s is teaching' %self.name)

...

方法二：super（）

调用super会得到一个特殊的对象，该对象专门用来引用父类的属性，且严格按照MRO规定的顺序向后查找

>>> class Teacher(People):

...     def __init__(self,name,sex,age,title):

...         super().__init__(name,age,sex) #调用的是绑定方法，自动传入self

...         self.title=title

...     def teach(self):

...         print('%s is teaching' %self.name)

...

两种方式的区别：

方式一是跟继承没有关系的，而方式二的super()是依赖于继承的，并且即使没有直接继承关系，super()仍然会按照MRO继续往后查找

 >>> #A没有继承B

... class A:

...     def test(self):

...         super().test()

...

>>> class B:

...     def test(self):

...         print('from B')

...

>>> class C(A,B):

...     pass

...

>>> C.mro() # 在代码层面A并不是B的子类，但从MRO列表来看，属性查找时，就是按照顺序C->A->B->object，B就相当于A的“父类”

##[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>,<class ‘object'>]

>>> obj=C()

>>> obj.test() # 属性查找的发起者是类C的对象obj，所以中途发生的属性查找都是参照C.mro()

##from B

多态与多态性：

import abc

# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化

class Animal(metaclass=abc.ABCMeta):

    @abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法

    def talk(self): # 抽象方法中无需实现具体的功能

        pass

class Cat(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准

    def talk(self):

        pass

cat=Cat() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

   '''父类中如何限制子类中得方法名，父类中定义的方法名，在子类中一定要有，哪怕是空'''

 抽象类的特点：只能被继承了，不能被实例化

'''抽象类的这种写法，python不建议写'''

鸭子类型：

不像抽象类那样硬性要求有相同的方法名，不依赖继承，只需要制造出外观和行为相同对象，同样可以实现不考虑对象类型而使用对象，全凭自觉，实现程序的松耦合度

#二者看起来都像文件,因而就可以当文件一样去用，然而它们并没有直接的关系

class Txt: #Txt类有两个与文件类型同名的方法，即read和write

    def read(self):

        pass

    def write(self):

        pass

class Disk: #Disk类也有两个与文件类型同名的方法：read和write

    def read(self):

        pass

    def write(self):

        pass

##类里面的方法名相同但是功能可以不用相同

 组合：

1.一个对象拥有一个属性，该属性的值是另外一个对象

2.继承是满足什么是什么的关系才用

3.组合是满足什么有什么的关系才用

class Course:

    def __init__(self,name,period,price):

        self.name=name

        self.period=period

        self.price=price

    def tell_info(self):

        print('<%s %s %s>' %(self.name,self.period,self.price))

class Date:

    def __init__(self,year,mon,day):

        self.year=year

        self.mon=mon

        self.day=day

    def tell_birth(self):

       print('<%s-%s-%s>' %(self.year,self.mon,self.day))

class People:

    school='清华大学'

    def __init__(self,name,sex,age):

        self.name=name

        self.sex=sex

        self.age=age

#Teacher类基于继承来重用People的代码，基于组合来重用Date类和Course类的代码

class Teacher(People): #老师是人

    def __init__(self,name,sex,age,title,year,mon,day):

        super().__init__(name,age,sex)

        self.birth=Date(year,mon,day) #老师有生日

        self.courses=[] #老师有课程，可以在实例化后，往该列表中添加Course类的对象

    def teach(self):

        print('%s is teaching' %self.name)

python=Course('python','3mons',3000.0)

linux=Course('linux','5mons',5000.0)

teacher1=Teacher('lili','female',28,'博士生导师',1990,3,23)

# teacher1有两门课程

teacher1.courses.append(python)

teacher1.courses.append(linux)

# 重用Date类的功能

teacher1.birth.tell_birth()

# 重用Course类的功能

for obj in teacher1.courses:

    obj.tell_info()

此时对象teacher1集对象独有的属性、Teacher类中的内容、Course类中的内容于一身（都可以访问到），是一个高度整合的产物

派生，super 多态与多态性 组合的相关教程结束。