面向对象编程的三大特征（封装，继承、多态）以及重写、MRO

封装（特征一）

根据需求将属性和方法封装到一个抽象的类中

在使用的时候，只要按照自己的需求去调用，不必了解实现的细节

封装有两方面的含义
1、将数值（属性）和行为（方法）包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法，这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
2、在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）以访问隐藏的信息，这样，就对隐藏的信息进行了保护。

class Student(object):
    def __init__(self):
        self.__score = 90
    
    def get_score(self):
        return self.__score
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError("成绩必须在0~100之间")

s = Student()
s.get_score()
90    ###  输出

s.set_score(88)
print(s.get_score())
88   ### 输出

继承（特征二）

除了封装，继承也是面向对象的三大特征之一。继承是实现代码复用的重要手段。

在现实生活中，我们很多东西都是继承自父母的，就像相貌、血缘、性格、财富等，这些都是与父母相关的。但是子女和父母并不是完全相同的，而在Python里的继承，是一种完全复制的继承，父类有的，子类都有。

当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到一个基类中，每个类对象特有的属性和方法还是在本类对象中定义，这样，只需要让每个类对象都继承这个基类，就可以访问基类中的属性和方法了。继承基类的每个类对象被称为派生类。基类也被成为父类或超类，派生类也被称为子类。

Python中所有类对象都继承自一个统一的基类：object。这就是为什么我们在定义类对象时要在类名后面添加（object）。

class Animal(object):
    def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")

class Dog(Animal):
   def swim(self):
       print("游泳")
       dog = Dog()
dog.eat()
dog.drink()
dog.swim()
###             输出                    ##
吃饭
喝水
游泳

继承分为单继承和多继承：

• 单继承：子类只有一个直接父类时称为单继承
  假设子类和父类分别为ChildClass和ParentClass,
  子类继承父类的语法格式为：
  
• 多继承：子类有多个直接父类时称为多继承
  假设子类是ChildClass，直接父类是ParentClass1，ParentClass2…PartentClassn
  子类继承父类的格式为：
  
  子类会继承所有父类（包括直接父类和所有间接父类）的所有属性和方法

class parentClassA(object):
    a = 18
    def im(self):
        print("im()这个方法被调用了！")
class ParentClassB(object):
    __pca = 23
    def __pim(self):
        print("__pim()这个方法被调用了！")
class ParentClassC(parentClassA, ParentClassB):
    @classmethod
    def cn(cls):
        print("cn()这个方法被调用了！")
class ParentClassD(object):
    @staticmethod
    def sm():
        print("sm()这个方法被调用了！")
class ChildClass(ParentClassC,ParentClassD):
    pass

子类可以添加父类中没有的属性和方法。

重写

如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重写从而提供自定义的实现，重写的方式为：在子类中定义与父类同名的属性或方法（包括装饰器）

子类重写父类的属性后，通过子类或其实例对象只能访问之类中重写的属性，而无法再访问父类中被重写的的属性。
同理：
子类重写父类的方法后，通过子类或其实例对象只能调用子类中重写后的方法，而无法再调用父类中被重写的方法。

class ParentClass(object):
    a = "a父类"
    def __init__(self):
        print("__init__()被调用了！（父类）")
    def im(self):
        print("im()被调用了（父类）")
    @classmethod
    def cm(cls):
        print("cm()被调用了！（父类）")

  class ChildClass(ParentClass):
    a = "a子类"
    def __init__(self):
        print("__init__()被调用了！（子类）")
    def im(self):
        print("im()被调用了（子类）")
    @classmethod
    def cm(cls):
        print("cm()被调用了！（子类）")

m = ChildClass()
print(ChildClass.a)
print(m.a)
m.im()
ChildClass.cm()
m.cm()
###            输出 
__init__()被调用了！（子类）
a子类
a子类
im()被调用了（子类）
cm()被调用了！（子类）
cm()被调用了！（子类）

父类中被重写的名为xxx的方法，在子类重写后的方法中可以通过super().xxx()进行调用。

class ChildClass(ParentClass):
    a = "a子类"
    def __init__(self):
        super().__init__()
        print("__init__()被调用了！（子类）")
    def im(self):
        super().im()
        print("im()被调用了（子类）")
    @classmethod
    def cm(cls):
        super().cm()
        print("cm()被调用了！（子类）")

ml = ChildClass()
print(ChildClass.a)
print(ml.a)
ml.im()
ChildClass.cm()
ml.cm()
###            输出 
__init__()被调用了！（父类）
__init__()被调用了！（子类）
a子类
a子类
im()被调用了（父类）
im()被调用了（子类）
cm()被调用了！（父类）
cm()被调用了！（子类）
cm()被调用了！（父类）
cm()被调用了！（子类）

MRO

MRO的全称是Method Resolution Order(方法解析顺序），它指的是对于一棵类继承树，当调用最底层类对象所对应实例对象的方法时，Python解释器在继承树上搜索方法的顺序。
对于一棵类继承树，可以调用最底层类对象的方法mro()或访问最底层类对象的特殊属性__ mro __,获得这颗类继承树的MRO。

在子类重写后的方法通过super()调用父类被重写的方法时，在父类中搜索方法的顺序基于以该子类为最底层类对象的类继承树的MRO。
如果想调用指定父类中被重写的方法，可以给super()传入两个实参：super(a_type, obj),其中，第一个实参a_type是个类对象，第二个实参obj是个实例对象，这样，被指定的父类是：
obj所对应类对象的MRO中，a_type后面的那个类对象。

多态（特征三）

多态是在不考虑对象类型的情况下适用对象
除了封装和继承，多态也是面向对象编程的三大特征之一
简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法。

如果子类中不存在指定名称的方法，回到父类中去查找，如果父类找到了，则调用父类中的方法。

class ParentClass(object):
    def do_sth():
        print("do_sth() in ParentClass")
class ChildClass1(ParentClass):
    def do_sth(self):
        print("do_sth() in ChildClass1")
class ChildClass2(ParentClass):
    def do_sth(self):
        print("do_sth() in ChildClass2")
def f(parent):
    parent.do_sth()

f(ParentClass)
f(ChildClass1())
f(ChildClass2())
###            输出 
do_sth() in ParentClass
do_sth() in ChildClass1
do_sth() in ChildClass2

class SomeClass(object):
    def do_sth(self):
        print("do_sth() in SomeClass")
f(SomeClass())
###            输出 
do_sth() in SomeClass

class ChildClass3(ParentClass):
    pass
f(ChildClass3)
###            输出 
do_sth() in ParentClass

Python是动态语言，再调用函数时不会检查参数的类型
动态语言的多态崇尚“ 鸭子类型 ”：当看到一个鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。
在鸭子类型中，我们并不关心对象是什么类型，到底是不是鸭子，只关心对象的行为。
在上面的程序中，我们并不关心变量parent所引用的对象是什么类型，到底是不是ParentClass或其子类类型，只关心变量parent所引用的对象是否有do_sth()这个方法。