一、面向对象引言
一、面向对象的程序设计的由来
详述见：http://www.cnblogs.com/linhaifeng/articles/6428835.html
二、面向对象引子
写一个简单程序：人狗大战
角色：人、狗 人角色特性：攻击力、生命值、名字、等级 狗角色特性：攻击力、生命值、名字、品种
1、用函数实现功能：角色和技能分别定义不同的函数
1 def person(attack,life_value,name,level):
2 person_dic = {‘attack‘:attack,
3 ‘life_value‘:life_value,
4 ‘name‘:name,
5 ‘level‘:level}
6 return person_dic
7 def dog(attack,life_value,name,level):
8 dog_dic = {‘attack‘:attack,
9 ‘life_value‘:life_value,
10 ‘name‘:name,
11 ‘type‘:type}
12 return dog_dic
13
14 def attack(person_d,dog_d):
15 print(‘%s 打了 %s‘ %(person_d[‘name‘],dog_d[‘name‘]))
16 dog_d[‘life_value‘] -= person_d[‘attack‘]
17
18 def bite(dog_d,person_d):
19 print(‘%s 咬了 %s‘ %(dog_d[‘name‘],person_d[‘name‘]))
20 person_d[‘life_value‘] -= dog_d[‘attack‘]
定义角色和技能
1 alex = person(100,1000,‘alex‘,2) 2 egg = dog(200,2000,‘egon‘,‘金毛‘) 3 print(egg[‘life_value‘]) 4 attack(alex,egg) 5 print(egg[‘life_value‘]) 6 bite(egg,alex) 7 print(alex[‘life_value‘])
角色实例化，互相攻击
弊端：某一角色误操作，可以调用其他角色的技能，这是明显的bug，必须修正：角色只能调用自己的技能
2、改进，角色只能调用自己的技能
1 def person(attack,life_value,name,level):
2 ‘‘‘
3 将独有的特性放到内部，只能自己调用
4 :param attack:
5 :param life_value:
6 :param name:
7 :param level:
8 :return:
9 ‘‘‘
10 def atk( dog_d):
11 print(‘%s 打了 %s‘ % (name, dog_d[‘name‘]))
12 dog_d[‘life_value‘] -= attack
13 person_dic = {‘attack‘:attack,
14 ‘life_value‘:life_value,
15 ‘name‘:name,
16 ‘level‘:level,
17 ‘atk‘:atk}
18 return person_dic
19 def dog(attack,life_value,name,level):
20 def bite(person_d):
21 print(‘%s 咬了 %s‘ % (name, person_d[‘name‘]))
22 person_d[‘life_value‘] -= attack
23 dog_dic = {‘attack‘:attack,
24 ‘life_value‘:life_value,
25 ‘name‘:name,
26 ‘type‘:type,
27 ‘bite‘:bite}
28 return dog_dic
定义角色和技能（技能放在角色函数内）
1 alex = person(100,1000,‘alex‘,2) 2 egg = dog(200,2000,‘egon‘,‘金毛‘) 3 print(egg[‘life_value‘]) 4 alex[‘atk‘](egg) 5 print(egg[‘life_value‘]) 6 egg[‘bite‘](alex) 7 print(alex[‘life_value‘])
角色实例化，操作（技能不能互相调用了）
三、面向对象与面向过程的区别
1、面向对象概述、优缺点及应用场景
面向过程的程序设计的核心是过程二字（流水线式思维），过程即解决问题的步骤。流程需要精心设计，是一种机械式的思维模式。
优点：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。
缺点：一套流水线或者流程就是来解决一个问题，无法满足个性化需求，牵一发而动全身。
应用场景：适用于一旦流程确定，很少改变的场景。例如：Linux内核，git，以及shell相关管理脚本。
2、面向对象概述、优缺点及应用场景
面向对象的程序设计的核心是对象二字。
对象是特征和技能的综合体，基于面向对象设计程序就好比在创建一个世界，你就是世界的上帝，存在的皆为对象，不存在的也可以创建出来。
与面向过程的机械式思维方式形成鲜明对比，面向对象更加注重对显示世界的模拟，是一种“上帝式”的思维模式。
优点：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中。如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：1、复杂性高。编程的复杂性远高于面向过程，不了解面向对象而立即基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，例如shell脚本。
2、可控性差。无法像面对过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果。面向对象的程序一旦开始就由对象之间的交互解决问题，即便设计者也无法准确地预测最终结果。例如：新增一个游戏人物，在对战的过程中极容易出现阴霾的技能，一刀砍死3个人。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层：互联网应用，企业内部软件，游戏等。
思路一：只关心某一个对象变成抽象规范了一类对象
思路二：当多个函数都需要传递同样的多个参数的时候，考虑面向对象的思想
面想对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计知识用来解决扩展性。
二、初识面向对象
Python中一切皆为对象，（数据）类型的本质就是类。例如：字典等。
在Python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象则是这一类事物中具体的一个。
一、类的相关知识
1、初始类
定义函数时，函数名首字母小写。
1 def functionName(args): 2 ‘‘‘ 3 注释 4 :param args: 5 :return: 6 ‘‘‘ 7 函数体
函数定义阶段
定义类与定义函数类似。类名首字母要大写。
1 class Date: 2 ‘类的文档字符串‘ 3 类体
定义类
2、类有两种作用：属性引用和实例化
属性引用方法：类名.属性
1 class Person: 2 rol = ‘人‘ #数据属性、静态属性、类属性 3 country = ‘中国‘ 4 def __init__(self,name,age,life_value): #初始化方法 5 # self.__dict__[‘name‘] = name 6 self.name = name #属性、对象属性 7 self.theage = age 8 self.life_value = life_value 9 10 def attack(self): #函数属性、动态属性、方法 11 #self只是一个形式参数，可以叫其他名字，但正常没人会这样 12 #self是水性杨花，那个对象调这个方法，self就是那个对象 13 print(‘attack方法被%s执行了‘%self.name) 14 print(Person.rol) ##属性引用
实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征。
语法：对象名 = 类名（参数）
执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法
1 class Person: 2 rol = ‘人‘ #数据属性、静态属性、类属性 3 country = ‘中国‘ 4 def __init__(self,name,age,life_value): #初始化方法 5 # self.__dict__[‘name‘] = name 6 self.name = name #属性、对象属性 7 self.theage = age 8 self.life_value = life_value 9 10 def attack(self): #函数属性、动态属性、方法 11 #self只是一个形式参数，可以叫其他名字，但正常没人会这样 12 #self是水性杨花，那个对象调这个方法，self就是那个对象 13 print(‘attack方法被%s执行了‘%self.name) 14 print(Person.rol) 15 alex=Person(‘alex‘,38,1000) 16 egg=Person(‘egon‘,18,2000)
查看属性和调用方法
print(alex.name) ##查看属性信息 对象名.属性名 print(alex.attack()) #调用方法：对象名.方法名()
self：在实例化时自动将对象/实例本身传给__init__的第一个参数。可以自定义个名字，但一般情况采用默认。
类的属性补充
1 一：我们定义的类的属性到底存到哪里了？有两种方式查看 2 dir(类名)：查出的是一个名字列表 3 类名.__dict__:查出的是一个字典，key为属性名，value为属性值 4 二：特殊的类属性 5 类名.__name__# 类的名字(字符串) 6 类名.__doc__# 类的文档字符串 7 类名.__base__# 类的第一个父类(在讲继承时会讲) 8 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 9 类名.__dict__# 类的字典属性 10 类名.__module__# 类定义所在的模块 11 类名.__class__# 实例对应的类(仅新式类中)
类属性的补充
二、对象的相关知识
对象是关于类而上实际存在的一个例子。
对象/实例只有一种作用：属性引用
注意：
1. 站的角度不同，定义出的类是截然不同的，详见面向对象实战之需求分析
2. 现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类......
3. 有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类
面向对象的小结
1 class 类名: 2 def __init__(self,参数1,参数2): 3 self.对象的属性1 = 参数1 4 self.对象的属性2 = 参数2 5 6 def 方法名(self):pass 7 8 def 方法名2(self):pass 9 10 对象名 = 类名(1,2) #对象就是实例，代表一个具体的东西 11 #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法 12 #括号里传参数，参数不需要传self，其他与init中的形参一一对应 13 #结果返回一个对象 14 对象名.对象的属性1 #查看对象的属性，直接用 对象名.属性名 即可 15 对象名.方法名() #调用类中的方法，直接用 对象名.方法名() 即可
三、属性查找
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字为类的属性。
创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
1、类的属性分类和特点：
- 数据（静态）属性：是所有对象共享的，id都一样
- 函数（动态）属性：绑定给对象用的obi.method称为绑定方法，内存地址都一样
id是Python的实现机制，并不能真实反映内存地址，若有内存地址，还是以内存地址为准。
obj.name会先从obj自己的名称空间里找name，找不到则去类中找，找不到就找父类......最后都找不到就抛出异常。
2、练习
编写一个学生类，产生一堆学生对象，要求有一个计数器（属性），统计总共有多少个对象。
对于任何数据类型的静态属性，它的修改操作尽量用类名；尤其是对于不可变数据类型，修改必须用类名
1 class Student: 2 count = 0 3 def __init__(self,name,sex,age): 4 self.name = name 5 self.sex = sex 6 self.age = age 7 Student.count += 1 8 alex = Student(‘alex‘,‘male‘,28) 9 egon = Student(‘egon‘,‘male‘,18) 10 print(alex.count) 11 print(egon.count)
计数器
四、对象之间的交互
1、实例：人狗大战
1 class Dog: 2 def __init__(self,name,type,aggr): 3 self.name = name 4 self.dog_type = type 5 self.aggr = aggr 6 self.life_value = 2000 7 8 def bite(self,person_obj): #self==egg,person_obj=alex 9 #属性的变化 10 print(‘%s咬了%s‘%(self.name,person_obj.name)) 11 person_obj.life_value -= self.aggr 12 13 class Person: 14 rol = ‘人‘ #数据属性、静态属性、类属性 15 country = ‘中国‘ 16 def __init__(self,name,age,life_value): #初始化方法 17 self.name = name #属性、对象属性 18 self.theage = age 19 self.life_value = life_value 20 self.aggr = 1 21 22 def attack(self,dog_obj):#函数属性、动态属性、方法 23 print(‘%s攻击了%s‘%self.name,dog_obj) 24 dog_obj.life_value -= self.aggr 25 26 alex = Person(‘alex‘,38,500) 27 egg = Dog(‘egon‘,‘二哈‘,20) 28 print(alex.life_value) 29 egg.bite(alex) #Dog.bite(egg,alex) 30 print(alex.life_value)
2、练习
练习一：已知一个圆的半径，求圆的周长和面积。（使用return）
能用return的返回结果的，不用print
1 from math import pi 2 class Circle(): 3 def __init__(self,r): 4 self.r=r 5 def perimeter(self): 6 return self.r*pi*2 7 8 def area(self): 9 return pi*self.r**2 10 11 circle1 = Circle(5) 12 print(circle1.perimeter()) 13 print(circle1.area())
计算圆的周长和面积
练习二：在终端输出如下信息
小明，10岁，男，上山去砍柴 小明，10岁，男，开车去东北 小明，10岁，男，最爱大保健 老李，90岁，男，上山去砍柴 老李，90岁，男，开车去东北 老李，90岁，男，最爱大保健
打印信息
1 class Person: 2 def __init__(self,name,age,sex): 3 self.name = name 4 self.age = age 5 self.sex = sex 6 def shangshan(self): 7 print(‘%s,%s,%s,上山去砍柴‘ %(self.name,self.age,self.sex)) 8 def kaiche(self): 9 print(‘%s,%s,%s,开车去东北‘ %(self.name,self.age,self.sex)) 10 def zuiai(self): 11 print(‘%s,%s,%s,最爱大保健‘ %(self.name,self.age,self.sex)) 12 13 xiaoming = Person(‘小明‘,10,‘男‘) 14 laoli = Person(‘老李‘,90,‘男‘) 15 xiaoming.shangshan() 16 xiaoming.kaiche() 17 xiaoming.zuiai()
代码实现
五、面向对象的组合用法
1、组合简介
软件重用的重要方式，除了继承以外，还有一种方式就是组合。
组合指的是在一个类中以另外一个类的对象作为数据属性，称为类的组合。
组合描述的是类之间的所属关系。例如：人有生日等等
2、继承与组合
组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同， 1.继承的方式 通过继承建立了派生类与基类之间的关系，它是一种‘是‘的关系，比如白马是马，人是动物。 当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人 2.组合的方式 用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3..
1 class People: 2 def __init__(self,name,age,sex): 3 self.name=name 4 self.age=age 5 self.sex=sex 6 7 class Course: 8 def __init__(self,name,period,price): 9 self.name=name 10 self.period=period 11 self.price=price 12 def tell_info(self): 13 print(‘<%s %s %s>‘ %(self.name,self.period,self.price)) 14 15 class Teacher(People): 16 def __init__(self,name,age,sex,job_title): 17 People.__init__(self,name,age,sex) 18 self.job_title=job_title 19 self.course=[] 20 self.students=[] 21 22 23 class Student(People): 24 def __init__(self,name,age,sex): 25 People.__init__(self,name,age,sex) 26 self.course=[] 27 28 29 egon=Teacher(‘egon‘,18,‘male‘,‘沙河霸道金牌讲师‘) 30 s1=Student(‘牛榴弹‘,18,‘female‘) 31 32 python=Course(‘python‘,‘3mons‘,3000.0) 33 linux=Course(‘python‘,‘3mons‘,3000.0) 34 35 #为老师egon和学生s1添加课程 36 egon.course.append(python) 37 egon.course.append(linux) 38 s1.course.append(python) 39 40 #为老师egon添加学生s1 41 egon.students.append(s1) 42 43 44 #使用 45 for obj in egon.course: 46 obj.tell_info()
例子：继承与组合
3、举例：
实例一：人类和生日类组合
1 class Birthday: 2 ‘‘‘ 3 生日类 4 ‘‘‘ 5 def __init__(self,year,month,day): 6 self.year = year 7 self.month = month 8 self.day = day 9 class Person: 10 ‘‘‘ 11 人类 12 ‘‘‘ 13 # def __init__(self,name,birth): 14 def __init__(self,name): 15 self.name = name 16 # self.birthday =birth 17 # 实例化两个类，然后将两个类组合起来 18 alex_birth = Birthday(1968,1,1) 19 alex = Person(‘alex‘) 20 alex.birth = alex_birth 21 print(alex.birth.year)
实例二：计算圆环的周长和面积
圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用
1 from math import pi 2 3 class Circle: 4 ‘‘‘ 5 定义了一个圆形类； 6 提供计算面积(area)和周长(perimeter)的方法 7 ‘‘‘ 8 def __init__(self,radius): 9 self.radius = radius 10 def area(self): 11 return pi * self.radius * self.radius 12 def perimeter(self): 13 return 2 * pi *self.radius 14 15 circle = Circle(10) #实例化一个圆 16 area1 = circle.area() #计算圆面积 17 per1 = circle.perimeter() #计算圆周长 18 print(area1,per1) #打印圆面积和周长 19 20 class Ring: 21 ‘‘‘ 22 定义了一个圆环类 23 提供圆环的面积和周长的方法 24 ‘‘‘ 25 def __init__(self,radius_outside,radius_inside): 26 self.outsid_circle = Circle(radius_outside) 27 self.inside_circle = Circle(radius_inside) 28 def area(self): 29 return self.outsid_circle.area() - self.inside_circle.area() 30 def perimeter(self): 31 return self.outsid_circle.perimeter() + self.inside_circle.perimeter() 32 33 ring = Ring(10,5) #实例化一个环形 34 print(ring.perimeter()) #计算环形的周长 35 print(ring.area()) #计算环形的面积
三、面向对象的三大特性
一、类的继承
1、什么是继承
继承指的是类与类之间的关系，是一种什么是什么的关系，功能之一就是用来解决代码重用问题。
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类。
Python中的继承分为单继承和多继承。
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass
查看继承
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类 (<class ‘__main__.ParentClass1‘>,) >>> SubClass2.__bases__ (<class ‘__main__.ParentClass1‘>, <class ‘__main__.ParentClass2‘>)
提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现
>>> ParentClass1.__bases__ (<class ‘object‘>,) >>> ParentClass2.__bases__ (<class ‘object‘>,)
2、继承与抽象（先抽象在继承）
抽象即抽取类似或者比较像的部分。
1.将奥巴马和梅西这俩对象比较像的部分抽取成类；
2.将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
3、继承和重用性
1 class Animal: 2 def __init__(self,name,aggr,life_value): 3 self.name=name 4 self.aggr=aggr 5 self.life_value=life_value 6 def func(self): 7 print(self.name) 8 9 class Dog(Animal): 10 def __init__(self,name,aggr,life_value,type): 11 Animal.__init__(self,name,aggr,life_value) 12 self.type=type #派生属性 13 def bite(self): 14 #派生方法 15 Animal.func(self) 16 17 class Person(Animal): 18 def __init__(self,name,aggr,life_value,money): 19 Animal.__init__(self,name,aggr,life_value) 20 self.money=money 21 egg=Dog(‘egon‘,200,2000,‘金毛‘) 22 alex=Person(‘alex‘,10,1000,2000) 23 24 print(egg.__dict__) 25 print(alex.__dict__)
在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大
4、派生
子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
1 class Animal: 2 ‘‘‘ 3 人和狗都是动物，所以创造一个Animal基类 4 ‘‘‘ 5 def __init__(self, name, aggressivity, life_value): 6 self.name = name # 人和狗都有自己的昵称; 7 self.aggressivity = aggressivity # 人和狗都有自己的攻击力; 8 self.life_value = life_value # 人和狗都有自己的生命值; 9 10 def eat(self): 11 print(‘%s is eating‘%self.name) 12 13 class Dog(Animal): 14 ‘‘‘ 15 狗类，继承Animal类 16 ‘‘‘ 17 def bite(self, people): 18 ‘‘‘ 19 派生：狗有咬人的技能 20 :param people: 21 ‘‘‘ 22 people.life_value -= self.aggressivity 23 24 class Person(Animal): 25 ‘‘‘ 26 人类，继承Animal 27 ‘‘‘ 28 def attack(self, dog): 29 ‘‘‘ 30 派生：人有攻击的技能 31 :param dog: 32 ‘‘‘ 33 dog.life_value -= self.aggressivity 34 35 egg = Person(‘egon‘,10,1000) 36 ha2 = Dog(‘二愣子‘,50,1000) 37 print(ha2.life_value) 38 print(egg.attack(ha2)) 39 print(ha2.life_value)
object 类祖宗
若一个类有指定的父类，那么他的父类就是被指定的那个
若一个类没有指定的父类，那么他的父类就是object
凡是继承了object类的类都是新式类
Python3里所有的类都是新式类
新式类调用父类的方法
1、指名道姓：父类名.方法名(self,aggr1...) ---->经典类 Python以经典类为主
2、super关键字：super.方法名(aggr1....) ----->只适合与新式类
1 class Teacher: 2 def __init__(self,name,age,salary): 3 self.name = name 4 self.age = age 5 self.salary = salary 6 self.teach() ##和egon.teach()效果一样，所有调用优先自己的 7 def teach(self): 8 print(‘%s正在讲课‘ %self.name) 9 10 class Professor(Teacher): 11 # def __init__(self,name,age): 12 # super().__init__(self,name,age) 13 def teach(self): 14 # super().teach() 15 print(‘教授%s正在讲课‘%self.name) 16 def print_write(self): 17 print(‘%s正在写专利‘%self.name) 18 # Write a patent 写专利 19 egon = Professor(‘egon‘,20,20000) 20 # print(egon.__dict__) 21 # egon.teach()
在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值
5、钻石继承
1 class A(object): 2 def test(self): 3 print(‘from A‘) 4 5 class B(A): 6 def test(self): 7 print(‘from B‘) 8 9 class C(A): 10 def test(self): 11 print(‘from C‘) 12 13 class D(B): 14 def test(self): 15 print(‘from D‘) 16 17 class E(C): 18 def test(self): 19 print(‘from E‘) 20 21 class F(D,E): 22 # def test(self): 23 # print(‘from F‘) 24 pass 25 f1=F() 26 f1.test() 27 print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性 28 29 #新式类继承顺序:F->D->B->E->C->A 30 #经典类继承顺序:F->D->B->A->E->C 31 #python3中统一都是新式类 32 #pyhon2中才分新式类与经典类
继承顺序
继承原理
python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如
>>> F.mro() #等同于F.__mro__ [<class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.E‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类
6、继承小结
1、继承的作用
1）减少代码的重用
2）提高代码可读性
3）规范编程模式
2、名字解释
抽象：抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。
继承：子类继承了父类的方法和属性
派生：子类在父类方法和属性的基础上产生了新的方法和属性
3、钻石继承
新式类：广度优先
经典类：深度优先
4、经典类和新式类的区别 1、关于基类 ： 新式类默认继承object 2、关于在子类中执行父类的方法:新式类有super，经典类只能用指名道姓 3、关于多继承：新式类 广度优先（mro），经典类：深度优先 在py3没有经典类；在py2里经典类和新式类共存 5、关于继承：子类继承父类子类的对象调用方法，优先在子类中找，如果子类中有，就执行子类中的 如果子类中没有，就执行父类的 多个父类以广度优先为准