Python中基于MRO的解析顺序规则（一）-Python

1、面向对象的概念

对具有共同属性的类进行分类的过程称为面向对象。

2、备注

定义类时，类名的首字母必须大写

3、面向对象的案例

 1 class Person(object):
 2     def __init__(self,name,age):  #name,age可以理解为类的属性；init为初始化；类里定义的函数称为构造方法/构造函数
 3         self.name=name   #实例属性
 4         self.age=age
 5         print("start")
 6     def __del__(self):   #清理操作
 7         print("end")
 8     def show(self):     #self为类本身，不可省略
 9         print("name:{0},age:{1}".format(self.name,self.age))
10 obj=Person(name="wuya",age=18)   #要调用类里边的变量、方法函数等，首先需要对类进行实例化；obj是类Person()实例化后的对象,类实例化的过程也是类初始化的过程。类的实例化过程也是针对构造方法初始化的过程（等于调用了__init__的方法）
11 obj.show()
12 #Person(name="wuya",age=18).show()   #用类名调用方法

以上代码运行结果为：

4、类中方法的执行顺序：初始化方法->具体方法->清理方法

5、面向对象的特性

1）包

a.实例属性

b.Data 属性（类中的变量）

2）继承

3）多态性

6、方法：

一个。普通方法：属于对象，也属于类，只能读写；

b.特征方法：属于对象，只有read属性，方法不能有形参；

c。静态方法：属于一个类，只能通过类名调用。一般数据属性是通过静态方法处理的

7、封装入口示例

 1 class Animal(object):
 2     def __init__(self,age):
 3         self.age=age
 4     def getAge(self):
 5         return self.age
 6     def setAge(self,age):
 7         if age>10 and age<100:
 8             self.age=age    #允许修改年龄
 9         else:

10             print("年龄错误")
11 objAnimal=Animal(age=25)    #类的实例化
12 print(objAnimal.getAge())   #输出获取年龄的方法的调用结果
13 objAnimal.setAge(age=11)    #调用修改年龄的方法
14 print(objAnimal.getAge())   #输出获取年龄的方法的调用结果

8、高级打包示例

 1 class Animal(object):
 2     address="地球"   #数据属性
 3     def __init__(self,age):
 4         self.age=age   #实例属性
 5     #     @staticmethod
 6     def address(self):   #静态方法，数据属性使用静态方法来处理
 7         return "地球"
 8     def show(self,name="❀"):   #普通方法，可读写
 9         print("it come from {0},and it's age is {1},and it's name is {2}".format(self.address(),self.age,name))
10     def func(self,**kwargs):
11         print(kwargs)
12     @property
13     def info(self):   #特性方法，只读（只有输出）
14         print("hello world")
15     @property
16     def getAge(self):    #特性方法，只读（只有返回）
17         return self.age
18 objAnimal=Animal(age=30)   #类的实例化
19 objAnimal.show()           #调用普通方法
20 #objAnimal.show(name="monkey")
21 # Animal().show(name="monkey")
22 # Animal(age=10).address()
23 objAnimal.func(name="cch",age=18,city="西安")
24 objAnimal.info             #特性方法调用
25 print(Animal.address(""))
26 print(objAnimal.age)

9、继承

1）概念

父类（基类）：继承类

子类（派生类）：继承其他类

2）Java和Python继承的区别

Java是单继承，Python是多继承

3）子类从父类继承什么：

a、变量（数据属性）

b、实例属性

c、方法

3）方法覆盖

当父类的方法不能满足子类的需要时，子类会重写父类的方法，子类实例化后的对象会调用这个方法，子类将被优先考虑。

 1 class Father(object):
 2     address="西安"
 3     def __init__(self,name,age):
 4         self.name=name
 5         self.age=age
 6     def info(self):
 7         print("this is a father's method")
 8 class Son(Father):
 9     def __init__(self,name,age,score):
10         Father.__init__(self,name,age)   #子类继承了父类的实例属性
11         self.score=score
12     def show(self):
13         print("name is {0},and age is {1},and score is {1}".format(self.name,self.age,self.score))
14     def info(self):      #父类的方法重写
15         print("this is a son's method")
16 son=Son(name="wuya",age=18,score=99)
17 son.show()
18 print(son.address)   #子类继承了父类的变量（数据属性）
19 son.info()    #不用print,info()中有print,函数与返回值时，输出函数为空。子类重写父类的方法，那么子类实例化后的对象调用该方法，优先考虑的是子类的方法。

以上代码运行结果为：

10、继承顺序

1）从上到下（前置条件）：

a.单一继承

b.子类覆盖超类的方法

2）从左到右（前提）：子类继承多个类（子类可以继承多个父类，但父类必须是兄弟关系）

3）所以在Python中，根据MRO的解析顺序规则，会从左到右查找基类。如果找到第一个匹配的属性类，则停止搜索。如果没有，搜索将停止。然后继续搜索，直到找到符合您需求的内容

只要你问。 MRO 实际上是通过 C3 线性化算法实现的。它的核心思想是：

子类优于超类检查

根据列表中的顺序检查多个父类

如果下一个类有两个有效选择，则只能选择第一个（线性搜索）

11、继承顺序示例

 1 class Father(object):
 2     def __init__(self,name,age):
 3         self.name=name

 4         self.age=age
 5     def funM(self):
 6         print("father")
 7 
 8 class Mother(object):
 9     def funM(self):
10         print("mother")
11 
12 class Son(Father,Mother):     #子类Son继承了两个父类
13     def __init__(self,name,age,score):
14         Father.__init__(self,name,age)    #子类Son继承了父类Father和Mother的实例属性
15         self.score=score
16 
17 son=Son(name="ccj",age=18,score=100)
18 son.funM()
19 print(Son.mro())   #使用类名调用mro，查看类的执行顺序

上述代码的执行结果是：

12、子类继承多个非同级父类错误示例

 1 class Person(object):
 2     pass
 3 
 4 class Father(Person):
 5     def __init__(self):
 6         pass
 7     def funM(self):
 8         print("father")
 9 class Mother(object):
10     def funM(self):
11         print("mother")
12 
13 class Son(Person,Father):  #子类继承的多个父类不是同一级，代码会报错,z子类可以继承多个父类，但父类之间必须是同级关系。
14 def __init__(self,score): 15 Father.__init__(self) 16 self.score=score 17 son=Son(score=90) 18 son.funM() 19 print(Son.mro())

上面代码运行的结果是；

13、继承方法调用错误示例

 1 class Person(object):
 2     pass
 3 
 4 class Father(Person):
 5     def __init__(self):

 6         pass
 7 
 8 class Mother(Person):
 9     def funM(self):
10         print("mother")
11 
12 class Son(Father):   #子类继承的父类中没有funM方法，代码会报错
13     def __init__(self,score):
14         Father.__init__(self)
15         self.score=score
16 
17 son=Son(score=99)
18 son.funM()

以上代码运行结果为：

14、继承方法调用错误示例修正

 1 class Person(object):
 2     def funM(self):
 3         print("person")
 4 
 5 class Father(Person):
 6     def __init__(self):
 7         pass
 8 
 9 class Mother(Person):
10     def funM(self):
11         print("mother")
12 
13 class Son(Father):   #子类继承法的父类是Father
14     def __init__(self,score):
15         Father.__init__(self)
16         self.score=score
17 
18 son=Son(score=99)
19 son.funM()    #子类调用方法，先从子类中查找，再从继承的父类查找，若未找到，再从父类的父类中查找。
20 print(Son.mro())

上述方法运行的结果是：

15、继承历史

python2深度优先，python3广度优先

 1 class A:
 2     def show(self):
 3         print('A')
 4 
 5 class B(A):
 6     pass
 7 
 8 class C(A):
 9     def show(self):
10         print('C')
11 
12 class D(B,C):
13     pass
14 
15 if __name__ == '__main__':
16     obj=D()
17     obj.show()  #python2执行的结果是A，pyhton3中的运行结果为C

16、多态性

多泰的优势总结如下：

增加持续的灵活性

添加了正在进行的附加扩展

 1 class Animal(object):
 2     def talk(self):
 3         print("动物会叫")
 4 
 5 class Dog(object):
 6     def talk(self):
 7         print("狗也会叫")
 8 
 9 class Cat(object):
10     def talk(self):
11         print("猫也会叫")
12 
13 def func(animal):
14     animal.talk()
15 if __name__ == '__main__':
16     dog=Dog()
17     func(animal=dog)

以上代码运行结果为：