继承与派生

1、什么是继承"
    继承是一种新建类的方式，新建的类称之为子类或派生类，继承的父类称之为基类或超类
    -在python中一个子类可以继承多个父类 ******
    -在其他语言中，一个子类只能继承一个父类
2、继承的作用
    减少代码的冗余
3、如何实现继承？
    1）先确认谁是子类，谁是父类
    2）在定义子类时，子类名（父类名）

#父类
class Father1:
    x = 1
    pass
class Father2:
    pass
class Father3:
    pass

#子类
class Sub(Father1, Father2, Father3):
    pass

#子类.__bases__查看父类
print(Sub.__base__) #<class '__main__.Father1'>
print(Sub.x)  #1

-如何寻找到继承的关系：

　　-确认谁是子类：

　　　　hcy对象----->人子类------>动物父类

　　　　猪坚强对象----->猪子类-------->动物父类

　　　　哈士奇对象------->狗子类------->动物父类

　　-确认谁是父类

　　　　-动物类是父类

　　　　　　-抽取对象之间相似的部分，总结出来

　　　　　　-抽取类之间相似的部分，总结出父类

#oldboy人类
class OldboyPeople:
    school = 'oldbay'
    country = 'china'
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

#老师类
class OldboyTeacher(OldboyPeople):
    #老师修改分数
    def change_score(self):
        print(f'老师{self.name}正在修改分数。。。。')

#学生类
class OldboyStudent(OldboyPeople):
    #学生选课系统
    def choose_course(self):
        print(f'学生『{self.name}正在选择课程。。。')

stu1 = OldboyStudent('YJG', 50, 'female')
print(stu1.school, stu1.name, stu1.age, stu1.sex)
tea1 = OldboyTeacher('大脸', 75, 'female')
print(tea1.school, tea1.name, tea1.age, tea1.sex)

注意：中程序的执行顺序是由上到下，父类必须定义在子类的上方

- 在继承背景下，对象属性的查找顺序：

　　1.先从对象自己的名称空间中查找

　　2.对象中没有，从子类的名称空间中查找

　　3.子类中没有，从父类的名称空间中查找，若父类没有，则会报错！

#父类
class Goo:
     x =10
     pass

#子类
class Foo(Goo):
     x =100
     pass
foo_obj= Foo()
#1)
# foo_obj.x = 1000
print(foo_obj.x)        #100
print('对象的名称空间：', foo_obj.__dict__)   # {}
print('子类的名称空间：', Foo.__dict__)  #{'__module__': '__main__', 'x': 100, '__doc__': None}
print('父类的名称空间:', Goo.__dict__)     #{'__module__': '__main__', 'x': 10, '__dict__': <attribute '__dict__' of 'Goo'
print('对象的名称空间：', foo_obj.__dict__)   #{}
#2)
foo_obj.x = 1000
print(foo_obj.x)        #1000    对象添加属性的操作，并不是修改了子类的属性
print('对象的名称空间',foo_obj.__dict__)   #{'x': 1000}
print('子类的名称空间',Foo.__dict__ )      #{'__module__': '__main__', 'x': 100, '__doc__': None}
print('父类的名称空间', Goo.__dict__)      #{'__module__': '__main__', 'x': 10, '__dict__': <attribute '__dict__'...
print('对象的名称空间', foo_obj.__dict__)  #{'x': 1000}

派生：

　　指的是子类继承父类的属性方法，并且派生出自己独有的属性与方法

　　若子类中的方法名与父类的相同，优先用子类的

#父类
class Foo:
    def f1(self):
        print('from Foo.f1...')
    def f2(self):   #self ---->bar_obj
        print('from Foo.f2...')
        #bar_obj.f1()---->对像自己找---->Bar ----->Foo
        self.f1()

#子类
class Bar(Foo):

    #相当于重写
    def f1(self):
        print('from Bar.f1...')
    def func(self):
        print('from Bar.func...')

bar_obj = Bar()
bar_obj.f1()    #from Bar.f1...
bar_obj.func()  #from Bar.func...
bar_obj.f2()    #from Foo.f2...
                #from Bar.f1...

#派生后继承关系查找验证：
bar_obj = Bar()
bar_obj.f2()
'''
结果1: 
    from Foo.f2...
    from Bar.f1...
'''

派生与继承：

子类继承父类，派生出自己的属性与方法，并且重用父类的属性与方法。

解决问题：子类重用父类的属性，并派生出新的属性

　　两种方式：

　　　　1.直接引用父类的__init__为其传参，并添加子类的属性

　　　　2.通过super来指向父类的属性

　　　　　　-super（）是一个特殊的类，调用super得到一个对象，该对象指向父类的名称空间

　　　　注意：使用哪一种都可以，但不能两种方式混合使用

class People:
    school = '清华大学'
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

class Teacher(People):
    def __init__(self, name, sex, age, title): #派生
        self.name = name
        self.sex = sex
        self.age = age
        self.title = title
    def teach(self):
        print('%s is teaching'%self.name)

obj = Teacher('lili','female', 28, '高级教师') #只会找自己类中的__init__
print(obj.name, obj.sex, obj.age, obj.title)  #lili female 28 高级教师

这里Teacher中的__init__内的前三行又是在写重复代码，若想在子类派生出的方法重用父类的功能，可以用两种方式：

# #方式一‘：指名道姓’地调用某一个类的函数
# class Teacher(People):
#     def __init__(self, name, sex, age, title):
#         People.__init__(self, name, age, sex)
#         self.title = title
#     def teach(self):
#         print('%s is teaching' %self.name)
# obj = Teacher('lili','female', 28, '高级教师') #只会找自己类中的__init__
#
# print(obj.teach())  #lili is teaching
#                     #None

# #方法二: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)

obj = Teacher('lili','female', 28, '高级教师') #只会找自己类中的__init__

print(obj.teach())  #lili is teaching
                    #None

注意：在python2中super 的使用需要完整地写成super（自己的类名,self）,而在python3中可以简写为super（）。

-新式类：
1.凡是继承object的类或子孙类都是新式类
2.在python3中所有的类都默认继承object
-经典类：
1.在python2中才会有经典类与新式类之分
2.在python2中，凡是没有继承object的类，都是经典类

class User(object):
    pass

class User:
    x =10
    pass

class Sub(User):
    pass

print(User.__dict__)      #  {'__module__': '__main__', 'x': 10, '__dict__':
                            # <attribute '__dict__' of 'User' objects>,
print(object)   #<class 'object'>

调用mro 返回的是一个继承序列

　　super 的继承顺序严格遵循mro继承序列

class Father1:
    x =10
    pass

class Father2:
    x = 20
    pass
#多继承的情况下，从左到右
class Sub(Father1,Father2):
    def __init__(self):   #注意__int__不是__init__
        print(super().__delattr__)

print(Sub.mro())   # [<class '__main__.Sub'>, <class '__main__.Father1'>, <class '__main__.Father2'>, <class 'object'>]
obj = Sub()
print(object)   #<class 'object'>

在python3中提供了一种查找新式类查找顺序的内置方法

　　mro():会把当前类的继承关系列出来

注：supper()会严格按照mro列表的顺序往后查找

class A:        #默认继承object
    def test(self):
        print('from A.test')
        super().test()
class B:
    def test(self):
        print('from B.test')
class C(A, B):
    pass
c = C()
#检查super的继承顺序
#mro(): 会把当前类的继承关系列出来。
print(C.mro()) #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
c.test()    #from A.test
            #from B.test

砖石继承：

　　多继承情况下造成’“砖石继承”

　　mro 的查找顺序：

　　　　-新式类：

　　　　　　-广度优先

　　　　-经典类：

　　　　　　-深度优先

#新式类
class A(object):
    def test(self):
        print('from A')
    pass

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

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

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

class F(D, E):
    def test(self):
        print('from F')
    pass
# F-->D-->B-->E-->C-->A-->object,注意：当class C(A)中A不存在时，则查找顺序为F-D-B-A-E-C->object
print(F.mro())
obj = F()
obj.test()
如果是经典类，查找顺序为：
F-D-C-A-E-C