继承

什么是继承？？？

　　现实生活中的：

　　　　继承就是后人继续做前人遗留下来的事业

　　程序中的：

　　　　继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，

　　　　新建的类可称为子类或派生类，父类又可称为基类或超类，

　　　　简单说就是继承是指一个对象直接使用另一对象的属性和方法

继承可分为单继承与多继承

　　　　单继承：继承一个父类

　　　　多继承：可以继承多个父类

　　　　　　优点：子类可以同时遗传多个父类的属性，最大限度地重用代码
　　　　　　缺点：
　　　　　　　　1、违背人的思维习惯：继承表达的是一种什么"是"什么的关系
　　　　　　　　2、代码可读性会变差
　　　　　　　　3、不建议使用多继承，有可能会引发可恶的菱形问题，扩展性变差，
　　　　　　　　　　如果真的涉及到一个子类不可避免地要重用多个父类的属性，应该使用Mixins

Python2 与 Python3 的区别：

在python2中有经典类与新式类之分
　　　　新式类：继承了object类的子类，以及该子类的子类子子类
　　　　经典类：没有继承object类的子类，以及该子类的子类子子类

在python3中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类

为何要用继承？？？

　　　　用来解决类与类之间代码冗余问题

如何实现继承？？？

　　　　继承与抽象

　　　　要找出类与类之间的继承关系，需要先抽象，再继承。抽象即总结相似之处，

　　　　总结对象之间的相似之处得到类，总结类与类之间的相似之处就可以得到父类

　　　　基于抽象的结果，我们就找到了继承关系

                                            

　　　　 基于上图我们可以看出类与类之间的继承指的是什么’是’什么的关系，

　　　　子类可以继承／遗传父类所有的属性，因而继承可以用来解决类与类之间的代码重用性问题。

通过类的内置属性__bases__可以查看类继承的所有父类

# 类与类之间存在冗余问题
class Student:
    school='OLDBOY'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def choose_course(self):
        print('学生%s 正在选课' %self.name)
class Teacher:
    school='OLDBOY'
    def __init__(self,name,age,sex,salary,level):
        self.name=name
        self.age=age
        self.sex=sex
        self.salary=salary
        self.level=level
    def score(self):
        print('老师 %s 正在给学生打分' %self.name)


# 基于继承解决类与类之间的冗余问题
class OldboyPeople:
    school = 'OLDBOY'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
class Student(OldboyPeople):
    def choose_course(self):
        print('学生%s 正在选课' % self.name)

stu_obj = Student('lili', 18, 'female')
print(stu_obj.__dict__)
print(stu_obj.school)
stu_obj.choose_course()

class Teacher(OldboyPeople):
    def __init__(self, name, age, sex, salary, level):
        # 指名道姓地跟父类OldboyPeople去要__init__
        OldboyPeople.__init__(self,name,age, sex)
        self.salary = salary
        self.level = level

    def score(self):
        print('老师 %s 正在给学生打分' % self.name)

tea_obj=Teacher('egon',18,'male',3000,10)
print(tea_obj.__dict__)
print(tea_obj.school)
tea_obj.score()

属性查找

　　　　有了继承关系，对象在查找属性时，先从对象自己的__dict__中找，如果没有则去子类中找，然后再去父类中找……

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

    def f2(self):
        print('Foo.f2')
        self.f1() # obj.f1()

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

obj=Bar()
obj.f2()

父类如果不想让子类覆盖自己的方法，可以采用双下划线开头的方式将方法设置为私有的

class Foo:
    def __f1(self): # _Foo__f1
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.__f1() # self._Foo__f1,# 调用当前类中的f1

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

obj=Bar()
obj.f2()

菱形问题介绍与MRO

                                                                                   

class A(object):
    def test(self):
        print('from A')


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

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

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


print(D.mro()) # 类D以及类D的对象访问属性都是参照该类的mro列表
obj = D()
obj.test()
总结：类相关的属性查找（类名.属性，该类的对象.属性），都是参照该类的mro

如果多继承是非菱形继承，经典类与新式的属性查找顺序一样：都是一个分支一个分支地找下去，然后最后找object

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

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

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

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

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

如果多继承是菱形继承，经典类与新式类的属性查找顺序不一样：
　　　　经典类：深度优先，会在检索第一条分支的时候就直接一条道走到黑，即会检索大脑袋（共同的父类）
　　　　新式类：广度优先，会在检索最后一条分支的时候检索大脑袋

# 在python2中，未继承object的类及其子类，都是经典类
class G: 
    def test(self):
        print('from G')

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

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

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

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

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

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

# 新式类
print(A.mro()) # A->B->E->C->F->D->G->object

# 经典类：A->B->E->G->C->F->D
obj = A()
obj.test() 

总结：
多继承到底要不用？？？　　　　要用，

　　　　但是规避几点问题：
　　　　　　1、继承结构尽量不要过于复杂
　　　　　　2、推荐使用mixins机制：在多继承的背景下满足继承的什么"是"什么的关系

 

装饰器是在不修改被装饰对象源代码以及调用方式的前提下为被装饰对象添加
新功能的可调用对象property是一个装饰器，是用来绑定给对象的方法伪造成一个数据属性

class People:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    # 定义函数的原因1：
    # 1、从bmi的公式上看，bmi应该是触发功能计算得到的
    # 2、bmi是随着身高、体重的变化而动态变化的，不是一个固定的值说白了，每次都是需要临时计算得到的

    @property
    def bmi(self):
        return self.weight / (self.height ** 2)


obj1 = People('egon', 70, 1.83)
print(obj1.bmi())

print(obj1.bmi)

class People:
    def __init__(self, name):
        self.__name = name
        
    @property
    def name(self): # obj1.name
        return self.__name

    @name.setter
    def name(self, val): # obj1.name='EGON'
        if type(val) is not str:
            print('必须传入str类型')
            return
        self.__name = val

    @name.deleter
    def name(self):
        print('不让删除')
        # del self.__name


obj1=People('egon')
print(obj1.name)