面向对象

一：继承

 

1.什么是继承？

继承是一种新建类的方式，新建的类称之为子类，被继承的类称之为父类、基类、超类

Python是支持多继承的，一个子类（儿子）可以有多个父类（爸爸）细思极恐

class Parent1:
    pass

class Parent2:
    pass

class Sub1(Parent1):
    pass

class Sub2(Parent1,Parent2):
    pass

print(Sub1.__bases__)   # 类/对象.__bases__可以查看继承的父类（基类）
# (<class '__main__.Parent1'>,)

print(Sub2.__bases__)
# (<class '__main__.Parent1'>, <class '__main__.Parent2'>)

 

2.继承 与 抽象

要找出类与类之间的继承关系，需要先抽象，再继承。抽象即总结相似之处，总结对象之间的相似之处得到类，总结类与类之间的相似之处就可以得到父类，如下图所示

 

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

image-20200806152503022

上面2张图可以看出：类与类之间的继承指的是：什么 是 什么的关系（金毛和二哈是狗，蜻蜓和蜜蜂是昆虫，金鱼和鲑鱼是鱼）

子类可以继承（遗传）父类的所有属性（金毛和二哈有狗的特征，而狗和昆虫、鱼都拥有生物的特征）

因而继承可以用来解决类与类之间的代码重用性（冗余）问题

 

3.为何要继承？

子类会遗传父类的属性，所以：继承是用来解决类于类之间 代码冗余问题

 

4.如何实现继承？

 

方法1：指名道姓地调用某一个类的函数

特点：不依赖于继承关系

class People:
    school = "Tinghua"

    #            空对象,'xxq', 18, 'male'
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


class Student(People):
    #            空对象,'xxq', 18, 'male', 37,  "Python全栈"
    def __init__(self, name, age, gender, stu_id, course):
        People.__init__(self, name, age, gender)  # People.__init__(空对象,'xxq', 18, 'male')
        self.stu_id = stu_id
        self.course = course

    def choose(self):
        print('%s 正在选课' % self.name)


class Teacher(People):
    def score(self, stu, num):
        stu.num = num


stu1 = Student('xxq', 18, 'male', 37, "Python全栈")

print(stu1.school, stu1.name, stu1.age, stu1.gender)
# Tinghua xxq 18 male

 

方法2：调用super(自己的类名, self)会返回一个特殊的对象super(自己的类名, self).属性会参照属性查找发起的那个类的mro列表去它父类中查找属性

特点：严格依赖于继承关系

class OldboyPeople:
    school = 'OldBoy'

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

    def f1(self):
        print(f'{self.name} say hello')


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


class Teacher(OldboyPeople):
    #           老师的空对象，'egon',18,'male',3000,10
    def __init__(self, name, age, sex, salary, level):
        # 方式2：# 调用super()会得到一个特殊的对象，该对象会参照当前类的mro，去当前类的父类里找属性
        super().__init__(name, age, sex)  # 调用的是方法，自动传入对象
        self.salary = salary
        self.level = level

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


print(Teacher.mro())  # [<class '__main__.Teacher'>, <class '__main__.OldboyPeople'>, <class 'object'>]

 

5.补充知识

新式类：单凡是继承了object类的子类，以及该子类的子子孙孙类，都称之为：新式类。

经典类：没有继承object类的子类，以及该子类的子子孙孙类，都称之为：经典类。

在Python3中，不管这个类有没有继承类，都默认继承与object类。

在Python2中，才有经典类，需要用新式类，只能手动继承。

 

Python的多继承

优点：

​ 子类可以同时遗传多个父类的属性，最大限度地重用代码

缺点：

​ 1.违背人的思维习惯：继承表达的是一种什么"是"什么的关系

​ 2.代码可读性会变差

​ 3.不建议使用多继承，有可能会引发可恶的菱形问题，扩展性变差，如果真的涉及到一个子类不可避免地要重用多个父类的属性，应该使用Mixins

 

6.菱形问题（多继承会到导致的问题）

菱形问题：一个子类继承的多条件分支 最终汇聚到了一个非object类，在菱形继承下

大多数面向对象语言都不支持多继承，而在Python中，一个子类是可以同时继承多个父类的，这固然可以带来一个子类可以对多个不同父类加以重用的好处，但也有可能引发著名的 Diamond problem菱形问题(或称钻石问题，有时候也被称为“死亡钻石”)，菱形其实就是对下面这种继承结构的形象比喻。

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(C, B):
    # def test(self):
    #     print('from D')
    pass


# print(D.mro())  # 类D以及类D的对象访问属性都是参照该类的mro列表
# 输出：[<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

obj = D()
obj.test()        # from C

print(D.test)       # <function C.test at 0x039D84A8>

print(C.mro())  # 类C以及类C的对象访问属性都是参照该类的mro列表
# 输出：[<class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

c = C()
c.test()        # from C

 

二：属性查找

 

可以通过对象.mro()或者类名.mro()来打印查找顺序，==Python2中不行==

 

1.新式类 与 经典类 关于属性查找的方式不同

新式类（Python3默认）：广度优先，会在检索最后一条分支的时候检索大脑袋

经典类（Python2默认）：深度优先，会在检索第一条分支的时候就直接一条道走到黑，即会检索大脑袋（共同的父类）

 

2.单继承背景下的属性查找

class Foo:
    def f2(self):
        print("Foo.f2")

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


class Bar(Foo):
    def f2(self):
        print("Bar.f2")


obj = Bar()
print(obj.f2)
# <bound method Bar.f2 of <__main__.Bar object at 0x0000023DFB4B5940>>

print(obj.f2())
# Bar.f2

print(obj.f1)
# <bound method Foo.f1 of <__main__.Bar object at 0x0000023DFB4B5940>>

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

 

3.单继承背景下的隐藏属性查找

class Foo:
    def __f2(self):
        print("Foo.f2")

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


class Bar(Foo):
    def __f2(self):
        print("Bar.f2")


obj = Bar()
print(obj.f1)
# <bound method Foo.f1 of <__main__.Bar object at 0x00000147E4A85940>>

print(obj.f1())
# Foo.f1
# Foo.f2
# None

 

4.菱形继承 与 非菱形继承 的 属性查找顺序

 

非菱形继承的查找顺序

都是一个分支一个分支地找下去，然后最后找object

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


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


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


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


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


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


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

obj = A()
obj.test()  # 结果为：from F

 

菱形继承的属性查找

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


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


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


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


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')
    pass


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

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

 

5.5.属性查找 - 进阶

class A:
    def test(self):
        super().test()


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


class C(A, B):
    pass


print(A.mro())  # [<class '__main__.A'>, <class 'object'>]
print(B.mro())  # [<class '__main__.B'>, <class 'object'>]
print(C.mro())  # 在代码层面A并不是B的子类，但从MRO列表来看，属性查找时，就是按照顺序C->A->B->object，B就相当于A的“父类”
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>,<class ‘object'>]

obj = C()
obj.test()  # 属性查找的发起者是类C的对象obj，所以中途发生的属性查找都是参照C.mro()
# from B

class A:
    def test(self):
        print('from A')
        super().test1()


class B:
    def test1(self):
        print('from B')


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


print(C.mro())  # 在代码层面A并不是B的子类，但从MRO列表来看，属性查找时，就是按照顺序C->A->B->object，B就相当于A的“父类”
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>,<class ‘object'>]

obj = C()
obj.test()  # 属性查找的发起者是类C的对象obj，所以中途发生的属性查找都是参照C.mro()

 

6.总结

 

多继承到底要不用？？？

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

 

类相关的属性查找（类名.属性，该类的对象.属性），都是参照该类的mro

python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。 而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

 

三：Mixins机制

 

Mixins核心：在多继承背景下，尽可能地提升多继承的可读性

 

ps：让多继承满足人的思维习惯 ==> 什么 是 什么

class Vehicle:  # 交通工具
    def fly(self):
        print("I am flying")


class CivilAircraft(Vehicle):  # 民航飞机
    pass


class Helicopter(Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

 

按照上述的继承，汽车、民航飞机、直升机都是交通工具，如果把fly这个功能写进交通工具中，汽车也会飞了，在当下，这不大现实

class Vehicle:  # 交通工具
    pass


class Flyable:    # 新建一个类Flyable，只当做可飞行交通工具的父类
    def fly(self):
        print("I am flying")


class CivilAircraft(Vehicle, Flyable):  # 民航飞机
    pass


class Helicopter(Vehicle, Flyable):  # 直升飞机
    pass


class Car(Vehicle):
    pass

 

所以再定义了一个Flyable功能，让会飞的交通工具也去继承它

Python语言可没有接口功能，但是它可以多重继承。那Python是不是就该用多重继承来实现呢？是，也不是。说是，因为从语法上看，的确是通过多重继承实现的。说不是，因为它的继承依然遵守”is-a”关系，从含义上看依然遵循单继承的原则。

class Vehicle:  # 交通工具
    pass


class FlyableMixin:        # 加一个Mixin结尾，可以当做一个假父类混入区中
    def fly(self):
        print("I am flying")


class CivilAircraft(Vehicle, FlyableMixin):  # 民航飞机
    pass


class Helicopter(Vehicle, FlyableMixin):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

这里可以看到，CivilAircraft和Helicopter都继承了Vehicle，还有FlyableMixin，但是FlyableMixin，表示混入(mix-in)，它告诉别人，这个类是作为功能添加到子类中，而不是作为父类，它的作用同Java中的接口。

使用Mixin类实现多重继承要非常小心
    1.首先它必须表示某一种功能，而不是某个物品，如同Java中的Runnable，Callable等
    2.其次它必须责任单一，如果有多个功能，那就写多个Mixin类
    3.然后，它不依赖于子类的实现
    4.最后，子类即便没有继承这个Mixin类，也照样可以工作，就是缺少了某个功能。

 最后修改：2020 年 08 月 06 日 08 : 11 PM