回顾

属性的存放位置：
        类中应该存储所有对象公共的内容
        对象中存储都是每个对象独有的(都不同)
初始化函数：__init__
        给对象的属性赋初值 , 可以保证只要对象被创建就一定有相应的属性
       节省重复代码( 指初始化函数init给每个对象都会初始一份相应的属性)

绑定方法指的是 ：将类或对象与函数进行了绑定
        之所以绑定是为了提高整合度,后续在拿到对象就可以直接调用对象相关的所有属性，而无需关心数据是什么 如何处理
        类、对象其实都可以看作是一个存储数据的容器（有属性有方法）

对象绑定方法：

默认就是绑定给对象的
         当使用对象调用时 会自动传入对象本身作为第一个参数，执行该方法时,直接问self对应的这个对象要数据就可以了
         用类来调用时就是一个普通函数 该怎么传就这么传
类绑定方法
         当执行该方法时,需要访问类中的内容而不需要对象中的内容时用类绑定方法
          @classmethod
         无论使用类还是对象来调用都会自动传入类本身作为第一个参数
非绑定方法
          既不需要访问类中的内容 也不需要访问对象中的内容 那就作为非绑定方法 就是一个普通函数 没有自动传值的效果
         @staticmethod

继承：说的是类与类之间的关系：【什么是什么的关系 如:猫是动物，猫继承了动物类】

一个类继承另外一外类，继承的类称之为子类、派生类，被继承的类称之为父类、基类或超类

一个类可以继承多个类。
            继承后，子类可以复用父类的内容 ，减少了类与类之间的代码冗余

在继承背景下属性的查找顺序
         对象本身 -> 所在的类 -> 类的父类 -> .... object

抽象类  指的是 把一系列类中的相同的特征和行为抽取 形成一个新的类 (公共父类)
          使用继承时 应该先抽象 再继承

派生:  某子类拥有与父类不同的内容，优先使用自己的

覆盖：子类出现了与父类完全相同的名字

一切皆对象：在py3里面所有数据全是对象 包括 int list 模块 函数 .....包等等....

在子类派生的新方法中重用父类的功能的两种方式：
       1.指名道姓地引用某一个类中的函数，与继承无关

2. super() 得到一个对象，该对象专门用来访问父类中的属性，而父类参照mro列表顺寻查找父类
       py3：super()              
       py2:  super(自己的类名,自己的对象self)

今日内容

一、属性查找顺序：

--  在单继承背景下的属性查找的优先级：先在自己类中查找，没有就去父类中查找

class Foo:    def f1(self):         print('Foo.f1')

    def f2(self):        print('Foo.f2')        self.f1()   => 此self == obj

class Bar(Foo):    def f1(self):        print('Bar.f1')

obj = Bar()obj.f2()   #Foo.f2#Bar.f1

-- 在多背景下属性的查找顺序：

  1）如果一个子类继承多个分支,【多个分支没有共同继承一个非object的类】，此时属性的查批优先级是：

      对象-->对象的类--> 对象的父类-->该分支结束后再返回第二个父类，一个分支一个分支的找下去，最后找到object类，没有就报错，如下图先走B分支，走到G没有就找C 分支，最后找到Object类。新

此种没有新式类与经典类之分，py3中默认G中继承了object类，py2中没写就真的就是没有，最后也不会找到object类。

2）菱形继承背景下，属性查找的优先级：菱形指的是一个类有多个分支继承，最后会继承到一个公共的类。

python中的两种类【新式类、经典类】

新式类：直接或间接继承了object的类. ---    python3中都是新式类，因为默认继承ogject

从左往右，从第一个分支找，找到object的子类，再回到第二个分支，同样找到object的子类，依此类推，在最后一个分支找到顶级类，object类

查找其他路线(基于C3算法)，A.mro()   => 得到一个属性查找顺序的列表

经典类：没有【直接或间接】继承object的类，都称之为经典类, python2不会默认继承object类，所有只有py2中才有经典类，而且没有继承object类

从左往右，从第一个分支找，一条线找到底，没有就从第二个分支找。

二、组合：

1. 什么组合？ 组合指的是某一个对象拥有一个属性，该属性的值是另外一个类的对象

2. 为何要用组合？通过为某一个对象添加属性【属性的值是另外一个类的对象】的方式，可以间接地将两个类关联/整合/组合到一起，从而减少类与类之间代码冗余

class Foo1:    pass

class Foo2:    pass

class Foo3:    pass

class Bar():    x = 123

obj_from_bar = Bar()obj1 = Foo1()obj2 = Foo2()obj3 = Foo3()

obj1.attr1 = obj_from_barobj2.attr1 = obj_from_barobj3.attr1 = obj_from_bar

obj1.attr1.xobj2.attr1.xobj3.attr1.x

3. 什么时候用组合？

    让学生/老师有选课的功能，新增一个课程类，如下：

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

class OldboyStudent(OldboyPeople):    school = 'oldboy'

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

    def choose_coure(self):        print('%s choosing coures' % self.name)

class OldboyTeacher(OldboyPeople):    school = 'Oldboy'

    def __init__(self, name, age, sex, level):        super().__init__(name,age, sex)        # OldboyPeople.__init__(self,name,age, sex)        self.level = level

    def score(self, stu, num):        stu.score = num

class Course:    def __init__(self,c_name, c_price, c_period):        self.c_name = c_name        self.c_price = c_price        self.c_period = c_period

python = Course('python', 1900, '5month')

stu1 =OldboyStudent('fanny',17, 'female')stu1.course = pythonprint(stu1.course.c_name)print(stu1.course.c_price)print(stu1.course.c_period)

tea1 = OldboyTeacher('egon', 18, 'male',100)tea1.course = pythonprint(tea1.course.c_name)print(tea1.course.c_price)print(tea1.course.c_period)

问题：是否可以减少代码冗余问题？将冗余部分放到课程类中

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

class OldboyStudent(OldboyPeople):    school = 'oldboy'

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

    def choose_coure(self):        print('%s choosing coures' % self.name)

class OldboyTeacher(OldboyPeople):    school = 'Oldboy'

    def __init__(self, name, age, sex, level):        super().__init__(name,age, sex)        # OldboyPeople.__init__(self,name,age, sex)        self.level = level

    def score(self, stu, num):        stu.score = num

class Course:    def __init__(self,c_name, c_price, c_period):        self.c_name = c_name        self.c_price = c_price        self.c_period = c_period

def tel_info(self):        print('<课程名称:%s 价钱:%s 周期:%s>'% (self.c_name,self.c_price, self.c_period))

python = Course('python', 1900, '5month')

stu1 =OldboyStudent('fanny',17, 'female')stu1.course = pythonstu1.course.tel_info()

tea1 = OldboyTeacher('egon', 18, 'male',100)tea1.course = pythontea1.course.tel_info()

三、多态与接口、鸭子类型

--  什么是多态：指的是同一种/类事物的不同形态，但不同形态需遵循一个共同的规范【需跟父类有相同名字的方法】

--   为何要用多态：

提供了一个接口，父类就是一个规范，外界只要知道父类的有什么功能就可以了，

参照父类中的【定义的函数名跟在父类中有就行了】方法使用，而不需要关心对象内部以及对象所在的类有什么。如len()方法，随便给一个对象就可以统计长度

--   如何用多态： 要想使用接口的便利，必须如下这样：

1）父类Animal只是用来建立规范的，不能用来实例化的，更无需实现内部的方法

2) 子类中必须依照定义跟父类相同名字的方法【具体功能自定】

     3) 为了强制让子类完全依照父类，可以给父类加装饰器 。一旦没有按照父类定义方法，就子类就不能实例对象

     4）python中更推崇约定即【鸭子类型】，大家统一遵照就可以了，这样的好外是：可以不需要继承父类，即没有莲藕关系。

     5）鸭子类型：通过谚语来阐述：具体的功能不一样，但是功能名必须一样：例【鸭子类型之读写件】

import abcclass Animal(metaclass=abc.ABCMeta):@abc.abstractmethod    def speak(self):        pass

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

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

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

obj1 = People()obj2 = Dog()obj3 = Pig()

例【鸭子类型之读写件】：

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

    def write(self):        print('Disk write')

class Cpu:    def read(self):        print('Cpu read')

    def write(self):        print('Cpu write')

class Memory:    def read(self):        print('Memory read')

    def write(self):        print('Memory write')

obj1 = Disk()obj2 = Memory()obj3 = Cpu()

obj1.read() obj2.read()obj3.read()