一、复习
1、类：
对象属性的查找顺序：先找自身再找类
类的名称空间：直接写在类中
对象的名称空间：写在__init__方法中，通过self.属性形成名称空间中的名字
类的方法：在类中用@classmethod装饰的方法，第一个参数一定接收类，建议只拿类调用
对象的方法：在类中定义的普通方法，第一个参数一定接收对象，建议只拿对象调用
2、封装：对外隐藏属性与方法的实现细节，类的内部均可以直接访问__名字
方式：在属性或方法前用__修饰，将__名字更名为_类名__名字
作用：有些属性或方法只提供给内部使用，所以采用封装处理
对象属性的封装，对外提供接口
@property
def id(self):
return self.__id
@id.setter
def id(self,id):
seif.__id = id
@id.deleter
def id(self):
del self.__id
二、组合
自定义类的对象作为另外一个类的属性
class Teacher:
def __init__(self,name,age):
self.name = name
self.age = age
t1 = Teacher('Bom',18)
print(type(t1.name),type(t1.age))
class Student:
def __init__(self,name,age,teacher):
self.name = name
self.age = age
self.teacher = teacher
stu = Student('Tom',18,t1)
print(stu.__dict__)
print(stu.teacher.name)
print(stu.teacher.age)
三、继承
1、将所有共有的属性与方法抽离出，形成父类
父类是多个有共同点的普通类抽离共有属性与方法形成的类
继承：子类与父类形成的一种关系，可以让子类能直接从父类中获取属性与方法
优点：减少代码冗余
两个名词：
先写子类：抽离 出父类 (先有多个有共同点的类，抽离出共性的形成的类)
先写父类：派生 出子类 (通过已有的父类，再去定义该类的子类)
2、语法
class People:
def __init__(self,name):
self.name = name
def eat(self):
print(self.name + '在吃饭')
class Student(People):
identify = '学生'
student = Student('Bob')
student.eat()
class Teacher(People):
pass
class Leader(People):
pass
3、属性与方法的继承
父类所有未封装的属性和方法都可以被继承：
父类的所有未封装的属性和方法，子类都能访问
父类的所有封装的属性和方法，子类都不能访问
在外界通过子类或子类对象，不能访问
在子类内部也不能访问
class Sup:
__num = 10
def __init__(self,name):
self.__name = name
@property
def name(self):
return self.__name
@classmethod
def __c_fn(cls):
print(cls,'c fn')
def __o_fn(self):
print(self.name,'o fn')
class Sub(Sup):
def test(self)；
print(self)
print(self.__name)
pass
print(Sub.num) #不能被访问
Sub.c_fn() #不能被访问
sub = Sub('Bob')
print(sub.name) #Bob
sub.o_fn() #不能被访问
sub.test() #不能被访问 因为内部不能访问__name
4、有父类时的属性（方法）查找顺序：
优先找自身，自身没有找父类
父类没有找父类的父类
一直找到最顶级的父类，如果还没有就报错
5、方法的重写：
先写好父类的方法，由于父类的功能不满足子类需求
子类可以重写父类的方法：方法名与父类相同，自定义方法的实现体
class Sup:
num = 10
def test(sef):
print('test sup')
class Sub(self):
num = 100
def test(self):
print('test sub')
print(Sub.num) #100 优先查找自己的
Sub().test() #test sub
6、方法的重用：
重用：还需要父类方法的功能，在父类方法功能基础上再添加新功能
突破点：在子类中去调用父类的方法，还有保证调用者是子类（子类的对象）
class Sup:
def test(self):
print('>>>sup',self)
print('test sup')
class Sub(sup):
pass
def test(self):
super().test() #python2中写法 super(Sup,self).test()
print('>>>sub',self)
print('test sub')
Sub().test()
7、__init__结合super()
class Sup:
def test(self):
print(self)
def __init__(self,name)
self.name = name
class Sub(Sup):
#有继承关系下，只要名字相同，即使产生不同，还是属于同一个方法
def test(self,num):
super().tset()
print(num)
#默认父级的__init__可以被继承过来，
#但是会出现子类对象的属性比父类多
def __init__(self,name,salary):
super().__init__(name) #父级有的共性功能通过super()交给父级做
self.salary = salary #子类特有的自己来完成
Sub('Bob',15000).test(10)
Sub().test() #使用还是使用自身带参的，不能使用父级不带参的（本质名字相同就是一个，优先查找自己的）
8、多继承
简单的多继承：
属性的查找顺序：优先找自己的，如果没有，按照继承先后查找父级
子类可以继承所有父类的所有可继承属性
class A:
name = 'A'
num = 10
class B:
name = 'B'
count = 100
class C(A,B):
pass #自己=》A=》B
复杂的多继承：
class A:
name = 'A'
class B(A):
name = 'B'
class C:
name = 'C'
class D(C):
name = 'D'
class E(B,D):
name = 'E' #E=>B=>A=>D=>C
菱形继承：
经典类：python2中才有，没有继承任何类的类
新式类：python2中没有直接或间接继承object的类（python3中没有明确继承关系的类默认继承object），
python中所定义的所有类
深度优先，在查找第一个分支查找到底
广度优先，菱形的头在所有分支查找接收后再被查找
通过 类.mro()查看继承顺序图