第十篇 面向对象的程序设计
Posted zatzsr98
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了第十篇 面向对象的程序设计相关的知识，希望对你有一定的参考价值。
一 面向对象的程序设计的由来
见概述：http://www.cnblogs.com/linhaifeng/articles/6428835.html
二 什么是面向对象的程序设计及为什么要有它
面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。
优点是：极大的降低了程序的复杂度
缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。
应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。
面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。
面向对象的程序设计的
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方
面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。
三 类和对象
3.1 什么是对象，什么是类
提示：python的class术语与c++有一定区别，与 Modula-3更像。
python中一切皆为对象，且python3统一了类与类型的概念，类型就是类，所以，不管你信不信，你已经使用了很长时间的类了
1 >>> dict #类型dict就是类dict 2 <class \'dict\'> 3 >>> d=dict(name=\'egon\') #实例化 4 >>> d.pop(\'name\') #向d发一条消息，执行d的方法pop 5 \'egon\'
基于面向对象设计一个款游戏：英雄联盟，每个玩家选一个英雄，每个英雄都有自己的特征和和技能，特征即数据属性，技能即方法属性，特征与技能的结合体就一个对象。
从一组对象中提取相似的部分就是类，类所有对象都具有的特征和技能的结合体
在python中，用变量表示特征，用函数表示技能，因而类是变量与函数的结合体，对象是变量与方法（指向类的函数）的结合体
补充几个有意思的点：
garen_hero.Q()称为向garen_hero这个对象发送了一条消息，让他去执行Q这个函数，完成一个功能，类似的有：
garen_hero.W()
garen_hero.E()
garen_hero.R()
一个英雄可以攻击另外一个英雄，这就是对象之间的交互
garen_hero.attack(Riven)
3.2 类相关知识
3.2.1 初识类
在python中声明函数与声明类很相似
声明函数
1 def functionName(args): 2 \'函数文档字符串\' 3 函数体
声明类
1 \'\'\' 2 class 类名: 3 \'类的文档字符串\' 4 类体 5 \'\'\' 6 7 #我们创建一个类 8 class Data: 9 pass
经典类与新式类在本节开头介绍得出结论，类是数据与函数的结合，二者称为类的属性
class Garen: #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
camp=\'Demacia\' #所有玩家的英雄(盖伦)的阵营都是Demacia;
def attack(self,enemy): #普通攻击技能，enemy是敌人;
enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。
3.2.2 类有两种作用：属性引用和实例化
3.2.2.1 属性引用（类名.属性）
>>> Garen.camp #引用类的数据属性，该属性与所有对象/实例共享 \'Demacia\' >>> Garen.attack #引用类的函数属性，该属性也共享 <function Garen.attack at 0x101356510> >>> Garen.name=\'Garen\' #增加属性 >>> del Garen.name #删除属性
3.2.2.2 实例化（__init__与self）
类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
class Garen: #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
camp=\'Demacia\' #所有玩家的英雄(盖伦)的阵营都是Demacia;
def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
self.nickname=nickname #为自己的盖伦起个别名;
self.aggressivity=aggressivity #英雄都有自己的攻击力;
self.life_value=life_value #英雄都有自己的生命值;
def attack(self,enemy): #普通攻击技能，enemy是敌人;
enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。
实例化：类名+括号
>>> g1=Garen(\'草丛伦\') #就是在执行Garen.__init__(g1,\'草丛伦\')，然后执行__init__内的代码g1.nickname=‘草丛伦’等
self的作用是在实例化时自动将对象/实例本身传给__init__的第一个参数，self可以是任意名字，但是瞎几把写别人就看不懂了。
这种自动传递的机制还体现在g1.attack的调用上，后续会介绍。
类属性的补充
3.3 对象相关知识
对象是关于类而实际存在的一个例子，即实例
>>> g1=Garen(\'草丛伦\') #类实例化得到g1这个实例，基于该实例我们讲解实例相关知识 >>> type(g1) #查看g1的类型就是类Garen <class \'__main__.Garen\'> >>> isinstance(g1,Garen) #g1就是Garen的实例 True
3.3.1 对象/实例只有一种作用：属性引用
#对象/实例本身其实只有数据属性 >>> g1.nickname \'草丛伦\' >>> g1.aggressivity 58 >>> g1.life_value 455 \'\'\' 查看实例属性 同样是dir和内置__dict__两种方式 特殊实例属性 __class__ __dict__ .... \'\'\'
对象/实例本身只有数据属性，但是python的class机制会将类的函数绑定到对象上，称为对象的方法，或者叫绑定方法，绑定方法唯一绑定一个对象，同一个类的方法绑定到不同的对象上，属于不同的方法，内存地址都不会一样
>>> g1.attack #对象的绑定方法 <bound method Garen.attack of <__main__.Garen object at 0x101348dd8>> >>> Garen.attack #对象的绑定方法attack本质就是调用类的函数attack的功能，二者是一种绑定关系 <function Garen.attack at 0x101356620>
对象的绑定方法的特别之处在于：obj.func()会把obj传给func的第一个参数。
3.4 对象之间的交互
我们可以仿照garen类再创建一个Riven类
class Riven:
camp=\'Noxus\' #所有玩家的英雄(锐雯)的阵营都是Noxus;
def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
self.nickname=nickname #为自己的锐雯起个别名;
self.aggressivity=aggressivity #英雄都有自己的攻击力;
self.life_value=life_value #英雄都有自己的生命值;
def attack(self,enemy): #普通攻击技能，enemy是敌人;
enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。
实例出一个Riven来
>>> r1=Riven(\'锐雯雯\')
交互：锐雯雯攻击草丛伦，反之一样
>>> g1.life_value 455 >>> r1.attack(g1) >>> g1.life_value 401
3.5 类名称空间与对象/实例名称空间
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性
而类有两种属性：数据属性和函数属性
其中类的数据属性是共享给所有对象的
>>> id(r1.camp) #本质就是在引用类的camp属性，二者id一样 4315241024 >>> id(Riven.camp) 4315241024
而类的函数属性是绑定到所有对象的：
>>> id(r1.attack) 4302501512 >>> id(Riven.attack) 4315244200 \'\'\' r1.attack就是在执行Riven.attack的功能，python的class机制会将Riven的函数属性attack绑定给r1，r1相当于拿到了一个指针，指向Riven类的attack功能 除此之外r1.attack()会将r1传给attack的第一个参数 \'\'\'
创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常
练习：编写一个学生类，产生一堆学生对象，要求有一个计数器（属性），统计总共实例了多少个对象
3.6 小结
定义锐雯类：
class Riven:
camp=\'Noxus\'
def __init__(self,nickname,
aggressivity=54,
life_value=414,
money=1001,
armor=3):
self.nickname=nickname
self.aggressivity=aggressivity
self.life_value=life_value
self.money=money
self.armor=armor
def attack(self,enemy):
damage_value=self.aggressivity-enemy.armor
enemy.life_value-=damage_value
定义盖文类：
class Garen:
camp=\'Demacia\'
def __init__(self,nickname,
aggressivity=58,
life_value=455,
money=100,
armor=10):
self.nickname=nickname
self.aggressivity=aggressivity
self.life_value=life_value
self.money=money
self.armor=armor
def attack(self,enemy):
damage_value=self.aggressivity-enemy.armor
enemy.life_value-=damage_value
定义装备：
class BlackCleaver:
def __init__(self,price=475,aggrev=9,life_value=100):
self.price=price
self.aggrev=aggrev
self.life_value=life_value
def update(self,obj):
obj.money-=self.price #减钱
obj.aggressivity+=self.aggrev #加攻击
obj.life_value+=self.life_value #加生命值
def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
obj.life_value-=1000 #假设火烧的攻击力是1000
测试交互
r1=Riven(\'草丛伦\')
g1=Garen(\'盖文\')
b1=BlackCleaver()
print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
if r1.money > b1.price:
r1.b1=b1
b1.update(r1)
print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
print(g1.life_value)
r1.attack(g1) #普通攻击
print(g1.life_value)
r1.b1.fire(g1) #用装备攻击
print(g1.life_value) #g1的生命值小于0就死了
按照这种思路一点一点的设计类和对象，最终你完全可以实现一个对战类游戏。
四 继承与派生
4.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\'>,)
4.2 继承与抽象（先抽象再继承）
抽象即抽取类似或者说比较像的部分。
抽象分成两个层次：
1.将奥巴马和梅西这俩对象比较像的部分抽取成类；
2.将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
4.3 继承与重用性
使用继承来重用代码比较好的例子在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用
class Hero:
def __init__(self,nickname,aggressivity,life_value):
self.nickname=nickname
self.aggressivity=aggressivity
self.life_value=life_value
def move_forward(self):
print(\'%s move forward\' %self.nickname)
def move_backward(self):
print(\'%s move backward\' %self.nickname)
def move_left(self):
print(\'%s move forward\' %self.nickname)
def move_right(self):
print(\'%s move forward\' %self.nickname)
def attack(self,enemy):
enemy.life_value-=self.aggressivity
class Garen(Hero):
pass
class Riven(Hero):
pass
g1=Garen(\'草丛伦\',100,300)
r1=Riven(\'锐雯雯\',57,200)
print(g1.life_value)
r1.attack(g1)
print(g1.life_value)
\'\'\'
运行结果
300
243
\'\'\'
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.
注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最顶级的父类。
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
class Riven(Hero):
camp=\'Noxus\'
def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
print(\'from riven\')
def fly(self): #在自己这里定义新的
print(\'%s is flying\' %self.nickname)
在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值
class Riven(Hero):
camp=\'Noxus\'
def __init__(self,nickname,aggressivity,life_value,skin):
Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
self.skin=skin #新属性
def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
Hero.attack(self,enemy) #调用功能
print(\'from riven\')
def fly(self): #在自己这里定义新的
print(\'%s is flying\' %self.nickname)
r1=Riven(\'锐雯雯\',57,200,\'比基尼\')
r1.fly()
print(r1.skin)
\'\'\'
运行结果
锐雯雯 is flying
比基尼
\'\'\'
4.4 组合与重用性
软件重用的重要方式除了继承之外还有另外一种方式，即：组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
其实早在3.5小节中我们就体会了组合的用法，比如一个英雄有一个装备
>>> class Equip: #武器装备类 ... def fire(self): ... print(\'release Fire skill\') ... >>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类 ... camp=\'Noxus\' ... def __init__(self,nickname): ... self.nickname=nickname ... self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性 ... >>> r1=Riven(\'锐雯雯\') >>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法 release Fire skill
组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，
1.继承的方式
通过继承建立了派生类与基类之间的关系，它是一种\'是\'的关系，比如白马是马，人是动物。
当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师
>>> class Teacher: ... def __init__(self,name,gender): ... self.name=name ... self.gender=gender ... def teach(self): ... print(\'teaching\') ... >>> >>> class Professor(Teacher): ... pass ... >>> p1=Professor(\'egon\',\'male\') >>> p1.teach() teaching
2.组合的方式
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程
class BirthDate:
def __init__(self,year,month,day):
self.year=year
self.month=month
self.day=day
class Couse:
def __init__(self,name,price,period):
self.name=name
self.price=price
self.period=period
class Teacher:
def __init__(self,name,gender):
self.name=name
self.gender=gender
def teach(self):
print(\'teaching\')
class Professor(Teacher):
def __init__(self,name,gender,birth,course):
Teacher.__init__(self,name,gender)
self.birth=birth
self.course=course
p1=Professor(\'egon\',\'male\',
BirthDate(\'1995\',\'1\',\'27\'),
Couse(\'python\',\'28000\',\'4 months\'))
print(p1.birth.year,p1.birth.month,p1.birth.day)
print(p1.course.name,p1.course.price,p1.course.period)
\'\'\'
运行结果:
1995 1 27
python 28000 4 months
\'\'\'
当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好
4.5 接口与归一化设计
1.什么是接口
java中的interface继承有两种用途：
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）
二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能
class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
def read(self): #定接口函数read
pass
def write(self): #定义接口函数write
pass
class Txt(Interface): #文本，具体实现read和write
def read(self):
print(\'文本数据的读取方法\')
def write(self):
print(\'文本数据的读取方法\')
class Sata(Interface): #磁盘，具体实现read和write
def read(self):
print(\'硬盘数据的读取方法\')
def write(self):
print(\'硬盘数据的读取方法\')
class Process(Interface):
def read(self):
print(\'进程数据的读取方法\')
def write(self):
print(\'进程数据的读取方法\')
实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
在python中根本就没有一个叫做interface的关键字，上面的代码只是看起来像接口，其实并没有起到接口的作用，子类完全可以不用去实现接口 ，如果非要去模仿接口的概念，可以借助第三方模块：
http://pypi.python.org/pypi/zope.interface
twisted的twisted\\internet\\interface.py里使用zope.interface
文档https://zopeinterface.readthedocs.io/en/latest/
设计模式：https://github.com/faif/python-patterns
2. 为何要用接口
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
然后让子类去实现接口中的函数。
这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。
再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样
4.6 抽象类
1 什么是抽象类
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
2 为什么要有抽象类
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案
3. 在python中实现抽象类
#_*_coding:utf-8_*_
__author__ = \'Linhaifeng\'
#一切皆文件
import abc #利用abc模块实现抽象类
class All_file(metaclass=abc.ABCMeta):
all_type=\'file\'
@abc.abstractmethod #定义抽象方法，无需实现功能
def read(self):
\'子类必须定义读功能\'
pass
@abc.abstractmethod #定义抽象方法，无需实现功能
def write(self):
\'子类必须定义写功能\'
pass
# class Txt(All_file):
# pass
#
# t1=Txt() #报错,子类没有定义抽象方法
class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print(\'文本数据的读取方法\')
def write(self):
print(\'文本数据的读取方法\')
class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print(\'硬盘数据的读取方法\')
def write(self):
print(\'硬盘数据的读取方法\')
class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print(\'进程数据的读取方法\')
def write(self):
print(\'进程数据的读取方法\')
wenbenwenjian=Txt()
yingpanwenjian=Sata()
jinchengwenjian=Process()
#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()
print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)
4. 抽象类与接口
抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。
抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计
4.7 继承实现的原理（继承顺序）
1 继承顺序
继承顺序
2 继承原理（python如何实现的继承）
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.如果对下一个类存在两个合法的选择,选择第一个父类
4.8 子类中调用父类方法
子类继承了父类的方法，然后想进行修改，注意了是基于原有的基础上修改，那么就需要在子类中调用父类的方法
方法一：父类名.父类方法()
View Code 方法二：super()
View Code
不用super引发的惨案
View Code 当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次（注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表）
View Code五 多态与多态性
很多人喜欢将二者混为一谈，然后百思不得其解，其实只要分开看，就会很明朗
5.1 多态
多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）
1. 序列类型有多种形态：字符串，列表，元组。
2. 动物有多种形态：人，狗，猪
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class People(Animal): #动物的形态之一:人
def talk(self):
print(\'say hello\')
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print(\'say wangwang\')
class Pig(Animal): #动物的形态之三:猪
def talk(self):
print(\'say aoao\')
3. 文件有多种形态：文本文件，可执行文件
import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
@abc.abstractmethod
def click(self):
pass
class Text(File): #文件的形态之一:文本文件
def click(self):
print(\'open file\')
class ExeFile(File): #文件的形态之二:可执行文件
def click(self):
print(\'execute file\')
5.2 多态性
一 什么是多态性（请务必注意注意注意：多态与多态性是两种概念。）
多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同功能的函数。
在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。
比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同
多态性分为静态多态性和动态多态性
静态多态性：如任何类型都可以用运算符+进行运算
动态多态性：如下
1.
2.
>>> def func(animal): #参数animal就是对态性的体现 ... animal.talk() ... >>> people1=People() #产生一个人的对象 >>> pig1=Pig() #产生一个猪的对象 >>> dog1=Dog() #产生一个狗的对象 >>> func(people1) say hello >>> func(pig1) say aoao >>> func(dog1) say wangwang
3.
>>> def func(f): ... f.click() ... >>> t1=Text() >>> e1=ExeFile() >>> func(t1) open file >>> func(e1) execute file
综上我们也可以说，多态性是‘一个接口（函数func），多种实现（如f.click()）’
二 为什么要用多态性（多态性的好处）
其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，也就是说python本身就是支持多态性的，这么做的好处是什么呢？
1.增加了程序的灵活性
以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
2.增加了程序额可扩展性
通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用
>>> class Cat(Animal): #属于动物的另外一种形态：猫 ... def talk(self): ... print(\'say miao\') ... >>> def func(animal): #对于使用者来说，自己的代码根本无需改动 ... animal.talk() ... >>> cat1=Cat() #实例出一只猫 >>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能 say miao \'\'\' 这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1) \'\'\'
六 封装
从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。但其实这种理解相当片面
首先我们要了解
6.1 要封装什么
你钱包的有多少钱（数据的封装）
你的性取向（数据的封装）
你撒尿的具体功能是怎么实现的（方法的封装）
6.2 为什么要封装
封装不是单纯意义的隐藏：
1：封装数据的主要原因是：保护隐私（作为男人的你，脸上就写着：我喜欢男人，你害怕么？）
2：封装方法的主要原因是：隔离复杂度（快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了，比如你不必知道你自己的尿是怎么流出来的，你直接掏出自己的接口就能用尿这个功能）
你的身体没有一处不体现着封装的概念：你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，），你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。还有你的头把你的脑子封装到了脑壳里，然后提供了眼睛这个接口....再比如电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！
提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。
6.3 封装分为两个层面
封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问）
第一个层面的封装（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装
>>> r1.nickname \'草丛伦\' >>> Riven.camp \'Noxus\'
注意：对于这一层面的封装（隐藏），类名.和实例名.就是访问隐藏属性的接口
第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。
在python中用双下划线的方式实现隐藏属性（设置成私有的）
类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
class A:
__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
def __init__(self):
self.__X=10 #变形为self._A__X
def __foo(self): #变形为_A__foo
print(\'from A\')
def bar(self):
self.__foo() #只有在类内部才可以通过__foo的形式访问到.
隐藏，并对外提供接口，接口附加类型检查逻辑
这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
2.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
注意：对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了
也可以用6.4所讲的特性property来解决，即将介绍
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
>>> a=A() >>> a._A__N 0 >>> a._A__X 10 >>> A._A__N 0
2.变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形
3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
#正常情况
>>> class A: ... def fa(self): ... print(\'from A\') ... def test(self): ... self.fa() ... >>> class B(A): ... def fa(self): ... print(\'from B\') ... >>> b=B() >>> b.test() from B
#把fa定义成私有的，即__fa >>> class A: ... def __fa(self): #在定义时就变形为_A__fa ... print(\'from A\') ... def test(self): ... self.__fa() #只会与自己所在的类为准,即调用_A__fa ... >>> class B(A): ... def __fa(self): ... print(\'from B\') ... >>> b=B() >>> b.test() from A
python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的
其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只不过显得稍微傻逼一点点
python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__，详见面向对象进阶
6.4 特性（property）
1 什么是特性property
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
class People:
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def bmi(self):
return self.weight / (self.height**2)
p1=People(\'egon\',75,1.85)
print(p1.bmi)
例二：圆的周长和面积
import math
class Circle:
def __init__(self,radius): #圆的半径radius
self.radius=radius
@property
def area(self):
return math.pi * self.radius**2 #计算面积
@property
def perimeter(self):
return 2*math.pi*self.radius #计算周长
c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
\'\'\'
输出结果:
10
314.1592653589793
62.83185307179586
\'\'\'
注意：此时的特性arear和perimeter不能被赋值
c.area=3 #为特性area赋值 \'\'\' 抛出异常: AttributeError: can\'t set attribute \'\'\'
2 为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
除此之外，看下
ps：面向对象的封装有三种方式: 【public】 这种其实就是不封装,是对外公开的 【protected】 这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开 【private】 这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
class Foo:
def __init__(self,val):
self.__NAME=val #将所有的数据属性都隐藏起来
@property
def name(self):
return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)
@name.setter
def name(self,value):
if not isinstance(value,str): #在设定值之前进行类型检查
raise TypeError(\'%s must be str\' %value)
self.__N以上是关于第十篇 面向对象的程序设计的主要内容，如果未能解决你的问题，请参考以下文章