day22-组合、菱形继承问题、在子派生的新方法中重用父类功能的两种方式、多态与多态性（含上节课复习）

上节课复习

上节课复习
    1、__init__方法：用于在调用类时/实例化时自动触发，为对象初始化自己独有的特征

        class People:

            country='China'
            def __init__(self,name,age,sex):
                self.name=name

                self.age=age
                self.sex=sex
            def eat(self):
                self.name self.func()

 #实例化:
#1、创造一个空对象p1
#2、触发对象下的__init__方法，让后将p1,'egon',18,'male'一同传入

p1=People('egon',18,'male')

2.绑定方法：
    在类中定义的函数，类可以使用，但类去调用就是一个普通的函数而已，没有自动传值一说
    但类跟定许多的函数，其实是给对象用的，而且是绑定给对象用的
    绑定给谁就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入
    强调对象的精髓

        对象不仅包含一系列数据（自己独有的+与其他对象共有的），还包含专门操作该数据的方法

3、在python3中统一类与类型的概念

    l=[1,2,3]#l=list([1,2,3,])

    l.append(4)

4、继承
    继承是一种新建类的方式，新建的类称为子类或派生类，被继承成类的称为父类，或超类或基类
    用继承的目的可以“遗传”父类的属性
    用继承的目的就是：减少代码冗余
    class Foo:
        pass

    class Bar(Foo):

        pass

    新式类：继承了object类的类Foo,以及Foo类的子类

    经典类：没有继承了object类的类Foo，以及Foo类的子类

    只有得到python2中才有经典类，在python3中全为新式类（不继承任何类的的类默认就 会继承object）
     cass Foo(object):
        pass
5、派生
    在子中定义的新属性称为派生，在使用中，始终以息有的为准

    class Foo:
        pass

    class Bar(Foo):
        x=1
        def fun(self):
            pass
6、在子类派生出的新方法中重用父类功能
        指名道姓（跟继承无关）：类名、函数（全部参数）

01组合

1.什么是组合
    组合就是一个类的对象具备某一个属性，该属性的值是指向另外一个类的对象
2.为何用组合
    组合也是用来解决类与类直接代码冗余问题的

3.如何用组合

class OldboyPeople:
    school ='oldboy'
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age

        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        OldboyPeople.__init__(self,name,age,sex)

        self.stu_id=stu_id
    def choose_course(self):

        print('%s is choosing course')

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        oldboyPeople.__init__(self,name,age,sex)
        self.level=level
    def score(self,stu,num):
        stu.score=num
        print('老师[%s]为学生[%s]打分[%s]'%(self.name,stu.name,num))

stu1=OldboyStudent('猪哥',19,'male',1)
tea1=OldboyTeacher('egon',18,'male',10)

##########################3

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(wlf):
        msg="""
        课程名：%s
        课程周期：%s
        课程价钱：%s
        """%(self.name,self.period,self.price)
        print(msg)

class OldboyPeople:
    school='oldboy'
    def __init__(self,name,age,sex):
        self.name=name

        self.age=age
        self.sex=sex

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id=stu_id
    def choose_course(self):
        print('%s is choosing course'%self.name)
class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        OldboyPeople.__init__(self,name,age,sex)
        self.level=level
    def score(self,stu,num):
        stu.score=num
        print('老师[%s]为学生[%s]打分[%s]' %(self.name,stu.name,num))

创造课程
python=Course('python全栈开发','5mons',3000)
linux=Course('linux运维','5mons',800)
#python.tell_info()

linux.tell_info()

# 创造学生与老师
stu1=OldboyStudent('猪哥',19,'male',1)
tea1=OldboyTeacher('egon',18,'male',10)

# 将学生、老师与课程对象关联/组合
stu1.course=python
tea1.course=linux


stu1.course.tell_info()
tea1.course.tell_info()

02 菱形继承问题

1.菱形继承
    当一个子继承多个父类时，多个父类最终继承了同一个类，称之为菱形继承
2.菱形继承的问题
    python2区分经典类与新式类，如果子的继承是一个菱形继承，那么经典类与形式的区别为？
        经典类下查找属性：深度优先查找
        新式类下查找属性：广度优先查找

验证范例：
class G(object):
    # def test(self):
    #     print('from G')
    pass


class E(G):
    # def test(self):
    #     print('from E')
    pass


class B(E):
    # def test(self):
    #     print('from B')
    pass


class F(G):
    # def test(self):
    #     print('from F')
    pass


class C(F):
    # def test(self):
    #     print('from C')
    pass


class D(G):
    # def test(self):
    #     print('from D')
    pass


class A(B,C,D):
    def test(self):
        print('from A')
    # pass


obj=A()
print(A.mro())
# obj.test() #A->B->E-C-F-D->G-object

03 在子派生的新方法中重用父类功能的两种方式 

在子派生的新方法中重用父类功能两种方式
方式一：与继承无关
指名道姓法，直接用：类名、函数名
class OldboyPeople:
    school='oldboy'
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):

        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id=stu_id
    def choose_course(self):
        print('%s is choosing course'%self.name)

# 方式二：严格用来继承属性查找关系
# super()会得到一个特殊的对象，该对象就是专门用来访问父类中的属性的（按照继承的关系）
# super().__init__(不用为self传值)
# 注意：
# super的完整用法是super(自己的类名,self),在python2中需要写完整，而python3中可以简写为super()

class OldboyPeople:
    school = 'oldboy'

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

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        # OldboyPeople.__init__(self,name,age,sex)
        super(OldboyStudent,self).__init__(name,age,sex)
        self.stu_id=stu_id

    def choose_course(self):
        print('%s is choosing course' %self.name)

stu1=OldboyStudent('猪哥',19,'male',1)
print(stu1.__dict__)
print(OldboyStudent.mro())

04多态与多态性

1.什么是多态
    多态指的是同一种事物的多种形态
         水-》冰、水蒸气、液态水
        动物-》人、狗、猪

2 为和要用多态
    多态性：
    继承同一个类的多个子类中有相同的方法名
    那么子类产生的对象就可以不用考虑具体的类型而直接调用功能

3.如何用

import abc#Abstract Base Class的编写

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass
    @abc.abstractmethod
    def eat(self):
        pass

# Animal() #强调：父类是用来指定标准的，不能被实例化

class People(Animal):
    def speak(self):
        print('say hello')

    def eat(self):
        pass

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

    def eat(self):
        pass
class Pig(Animal):
    def speak(self):
        print('哼哼哼')

    def eat(self):
        pass

# peo1=People()
# dog1=Dog()
# pig1=Pig()

People().speak()
# dog1.speak()
# pig1.speak()
上述打印方法的结果等同于下方打印方法

def my_speak(animal):
    animal.speak()

my_speak(peo1)
# my_speak(dog1)
# my_speak(pig1)

python推崇的是鸭子类型，只要你叫的声音像鸭子，并且你走路的样子也像鸭子，那你就是鸭子

class Disk:
    def read(self):
        print('disk read')

    def write(self):

        print('disk write')

class Process:

    def read(self):
        print('process read')
    def write(self):

        print('process write')

class File:
    def read(self):
        print('file read')
    def wire:
        print('file write')

obj1=Disk()
obj2=Process()

obj3=File()

obj1.read()
obj1.write()