标签：
编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。
两种最重要的编程范式分别是面向过程编程和面向对象编程。
2、面向过程编程(Procedural Programming)
Procedural programming uses a list of instructions to tell the computer what to do step-by-step.
面向过程编程依赖你猜到了procedures（过程），一个procedure包含一组要被进行计算的步骤，面向过程又被称为top-down
languages，就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题
。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够
简单到可以在一个小步骤范围内解决。
这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改，如果程序开头你设置了一个变量值为1，如果其它子过程依赖这个值为1的变量才能正常运行，那如果改了这个变量，那这个子过程也要修改，假如又有一个其它子程序依赖这个子过程，那就会发生一连串的影响，随着程序越来越大，这种编程方式的维护难度会越来越高。
如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护的，那还是用面向对象最方便了。
3、面向对象编程（Object-Oriented Programming）
OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。
1、Class（类）
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法
2、Object（对象）
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同
3、Encapsulation（封装）
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法
4、Inheritance（继承）
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
5、Polymorphism（多态）
多态是面向对象的重要特性,简单说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作,
他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”,
因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定
1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 # Author :GU 4 class Dog: 5 def __init__(self,name): 6 self.name = name 7 def bulk(self): 8 print("%s: wang wang wang!" % self.name) 9 d1 = Dog("test1") 10 d2 = Dog("test2") 11 d3 = Dog("test3") 12 d1.bulk() 13 d2.bulk() 14 d3.bulk() 15 ####执行结果; 16 test1: wang wang wang! 17 test2: wang wang wang! 18 test3: wang wang wang!
开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不同就是，你的代码总是需要不断的更改，不是修改bug就是添加新功能等，所以为了日后方便程序的修改及扩展，你写的代码一定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。
先用非OOP的方式写出游戏的基本角色
1 #role 1 2 name = ‘Alex‘ 3 role = ‘terrorist‘ 4 weapon = ‘AK47‘ 5 life_value = 100 6 money = 10000 7 8 #rolw 2 9 name2 = ‘Jack‘ 10 role2 = ‘police‘ 11 weapon2 = ‘B22‘ 12 life_value2 = 100 13 money2 = 10000 14 15 #role 3 16 name3 = ‘Rain‘ 17 role3 = ‘terrorist‘ 18 weapon3 = ‘C33‘ 19 life_value3 = 100 20 money3 = 10000 21 22 #rolw 4 23 name4 = ‘Eric‘ 24 role4 = ‘police‘ 25 weapon4 = ‘B51‘ 26 life_value4 = 100 27 money4 = 10000
1 roles = { 2 1:{‘name‘:‘Alex‘, 3 ‘role‘:‘terrorist‘, 4 ‘weapon‘:‘AK47‘, 5 ‘life_value‘: 100, 6 ‘money‘: 15000, 7 }, 8 2:{‘name‘:‘Jack‘, 9 ‘role‘:‘police‘, 10 ‘weapon‘:‘B22‘, 11 ‘life_value‘: 100, 12 ‘money‘: 15000, 13 }, 14 3:{‘name‘:‘Rain‘, 15 ‘role‘:‘terrorist‘, 16 ‘weapon‘:‘C33‘, 17 ‘life_value‘: 100, 18 ‘money‘: 15000, 19 }, 20 4:{‘name‘:‘Eirc‘, 21 ‘role‘:‘police‘, 22 ‘weapon‘:‘B51‘, 23 ‘life_value‘: 100, 24 ‘money‘: 15000, 25 }, 26 } 27 28 print(roles[1]) #Alex 29 print(roles[2]) #Jack
1 def shot(by_who): 2 #开了枪后要减子弹数 3 pass 4 def got_shot(who): 5 #中枪后要减血 6 who[‘life_value’] -= 10 7 pass 8 def buy_gun(who,gun_name): 9 #检查钱够不够,买了枪后要扣钱 10 pass
继续按照这个思路设计，再完善一下代码，游戏的简单版就出来了，但是在往下走之前，我们来看看上面的这种代码写法有没有问题，至少从上面的代码设计中，我看到以下几点缺陷：
1 class Role(): 2 def __init__(self,name,role,weapon,life_value=100,money=15000):
#构造函数
#在实例化时做一些初始化工作 3 self.name = name ###实例变量（静态属性），作用域就是实例本身 4 self.role = role 5 self.weapon = weapon 6 self.life_value = life_value 7 self.money = money 8 9 def shot(self): ##类的方法，功能（动态属性） 10 print("shooting...") 11 12 def got_shot(self): 13 print("ah...,I got shot...") 14 15 def buy_gun(self,gun_name): 16 print("%s just bought %s" %(self.name,gun_name)) 17 18 r1 = Role(‘Alex‘,‘police‘,‘AK47‘) #把一个类变成一个具体的对象的过程叫实例化（初始化一个了类，生成一个角色） 19 # 20 r2 = Role(‘Jack‘,‘terrorist‘,‘B22‘) #生成一个角色（相当于role的一个实例） 21 r1.buy_gun("AK47") 22 #执行结果： 23 Alex just bought ak47
1 class Role(object): #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么 2 def __init__(self,name,role,weapon,life_value=100,money=15000): #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里 3 self.name = name #__init__中的第一个参数self,和这里的self都 是什么意思？ 看下面解释 4 self.role = role 5 self.weapon = weapon 6 self.life_value = life_value 7 self.money = money
上面的这个__init__()叫做初始化方法(或构造方法)， 在类被调用时，这个方法(虽然它是函数形式，但在类中就不叫函数了,叫方法)会自动执行，进行一些初始化的动作，所以我们这里写的 __init__(self,name,role,weapon,life_value=100,money=15000)就是要在创建一个角色时给它设 置这些属性，那么这第一个参数self是干毛用的呢？
初始化一个角色，就需要调用这个类一次：
1 r1 = Role(‘Alex‘,‘police‘,‘AK47’) #生成一个角色 , 会自动把参数传给Role下面的__init__(...)方法 2 r2 = Role(‘Jack‘,‘terrorist‘,‘B22’) #生成一个角色
我们看到，上面的创建角色时，我们并没有给__init__传值，程序也没未报错，是因为，类在调用它自己的__init__(…)时自己帮你给self参数赋值了，
1 r1 = Role(‘Alex‘,‘police‘,‘AK47’) #此时self 相当于 r1 , Role(r1,‘Alex‘,‘police‘,‘AK47’) 2 r2 = Role(‘Jack‘,‘terrorist‘,‘B22’)#此时self 相当于 r2, Role(r2,‘Jack‘,‘terrorist‘,‘B22’)
1 def buy_gun(self,gun_name): 2 print(“%s has just bought %s” %(self.name,gun_name) )
上面这个方法通过类调用的话要写成如下：
1 r1 = Role(‘Alex‘,‘police‘,‘AK47‘) 2 r1.buy_gun("B21”) #python 会自动帮你转成 Role.buy_gun(r1,”B21")
a、什么是类变量，类变量有什么用途？
b、类变量的用途:
大家共用的属性，为了节约内存
1 #########修改============== 2 class Role(): 3 n = 123 4 def __init__(self,name,role,weapon,life_value=100,money=15000): 5 self.name = name 6 self.role = role 7 self.weapon = weapon 8 self.life_value = life_value 9 self.money = money 10 11 def shot(self): 12 print("shooting...") 13 14 def got_shot(self): 15 print("ah...,I got shot...") 16 17 def buy_gun(self,gun_name): 18 print("%s just bought %s" %(self.name,gun_name)) 19 20 r1 = Role(‘Alex‘,‘police‘,‘AK47‘) #把一个类变成一个具体的对象的过程叫实例化（初始化一个了类，生成一个角色） 21 r1.name = "test1" 22 print(r1.n,r1.name) 23 r2 = Role(‘Jack‘,‘terrorist‘,‘B22‘) #生成一个角色 24 r2.name = "test2" 25 print(r2.n,r2.name) 26 ###执行结果 27 123 test1 28 123 test2 29 =================添加=================== 30 class Role(): 31 n = 123 32 def __init__(self,name,role,weapon,life_value=100,money=15000): 33 self.name = name 34 self.role = role 35 self.weapon = weapon 36 self.life_value = life_value 37 self.money = money 38 39 def shot(self): 40 print("shooting...") 41 42 def got_shot(self): 43 print("ah...,I got shot...") 44 45 def buy_gun(self,gun_name): 46 print("%s just bought %s" %(self.name,gun_name)) 47 48 r1 = Role(‘Alex‘,‘police‘,‘AK47‘) #把一个类变成一个具体的对象的过程叫实例化（初始化一个了类，生成一个角色） 49 r1.name = "test1" 50 r1.bullet_prove = True 51 print(r1.n,r1.name,r1.bullet_prove) 52 ###执行结果： 53 123 test1 True 54 只是对r1的添加 55 =================删除==================== 56 class Role(): 57 n = 123 58 def __init__(self,name,role,weapon,life_value=100,money=15000): 59 self.name = name 60 self.role = role 61 self.weapon = weapon 62 self.life_value = life_value 63 self.money = money 64 65 def shot(self): 66 print("shooting...") 67 68 def got_shot(self): 69 print("ah...,I got shot...") 70 71 def buy_gun(self,gun_name): 72 print("%s just bought %s" %(self.name,gun_name)) 73 74 r1 = Role(‘Alex‘,‘police‘,‘AK47‘) #把一个类变成一个具体的对象的过程叫实例化（初始化一个了类，生成一个角色） 75 r1.name = "test1" 76 r1.bullet_prove = True 77 print(r1.weapon) 78 del r1.weapon 79 print(r1.n,r1.name,r1.bullet_prove,r1.weapon) 80 ##执行结果： 81 Traceback (most recent call last): 82 File "C:/Users/Administrator/PycharmProjects/s14/day6/cs.py", line 51, in <module> 83 print(r1.n,r1.name,r1.bullet_prove,r1.weapon) 84 AttributeError: ‘Role‘ object has no attribute ‘weapon‘ 85 AK47 86 因为删除了weapon所以后面在打印就会报错
C、析构函数
作用：
在实例释放、销毁的时候执行的，通常用于做一些收尾工作，如关闭数据库连接，关闭打开的临时文件
1 class Role(): 2 n = 123 3 def __init__(self,name,role,weapon,life_value=100,money=15000): 4 self.name = name 5 self.role = role 6 self.weapon = weapon 7 self.life_value = life_value 8 self.money = money 9 def __del__(self): 10 print("%s 彻底死了" %self.name) 11 def shot(self): 12 print("shooting...") 13 14 def got_shot(self): 15 print("%s ah...,I got shot..." %self.name ) 16 17 def buy_gun(self,gun_name): 18 print("%s just bought %s" %(self.name,gun_name)) 19 20 r1 = Role(‘Alex‘,‘police‘,‘AK47‘) 21 r1.buy_gun("Ak47") 22 r1.got_shot() 23 del r1 ###在程序结束前执行 24 r2 = Role(‘Jack‘,‘terrorist‘,‘B22‘) 25 r2.got_shot() 26 #在程序或者实例释放的时候执行 27 28 ##执行结果： 29 Alex just bought Ak47 30 Alex ah...,I got shot... 31 Alex 彻底死了 32 Jack ah...,I got shot... 33 Jack 彻底死了
三、类成员的修饰符
类的所有成员在上一步骤中已经做了详细的介绍，对于每一个类的成员而言都有两种形式：
私有属性和公有属性的定义不同：私有属性命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
1 class C: 2 def __init__(self): 3 self.name = ‘公有属性‘ 4 self.__foo = "私有属性"
如何让私有属性可读，在类里面定义一个公有属性去调用私有属性，然后再外面调用刚刚定义的公有属性
私有属性和公有属性的访问限制不同：
静态字段
1 class C: 2 3 name = "公有静态字段" 4 5 def func(self): 6 print (C.name) 7 8 class D(C): 9 10 def show(self): 11 print (C.name) 12 13 14 C.name # 类访问 15 16 obj = C() 17 obj.func() # 类内部可以访问 18 19 obj_son = D() 20 obj_son.show() # 派生类中可以访问
1 class C: 2 3 def __init__(self): 4 self.__foo = "私有字段" 5 6 def func(self): 7 print (self.foo) # 类内部访问 8 9 class D(C): 10 11 def show(self): 12 print (self.foo) ＃ 派生类中访问 13 14 obj = C() 15 16 obj.__foo # 通过对象访问 ==> 错误 17 obj.func() # 类内部访问 ==> 正确 18 19 obj_son = D(); 20 obj_son.show() # 派生类中访问 ==> 错误
方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用
普通字段
ps：如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。
1 class C: 2 3 def __init__(self): 4 self.foo = "公有字段" 5 6 def func(self): 7 print self.foo # 类内部访问 8 9 class D(C): 10 11 def show(self): 12 print self.foo ＃ 派生类中访问 13 14 obj = C() 15 16 obj.foo # 通过对象访问 17 obj.func() # 类内部访问 18 19 obj_son = D(); 20 obj_son.show() # 派生类中访问
1 class C: 2 3 def __init__(self): 4 self.__foo = "私有字段" 5 6 def func(self): 7 print self.foo # 类内部访问 8 9 class D(C): 10 11 def show(self): 12 print self.foo ＃ 派生类中访问 13 14 obj = C() 15 16 obj.__foo # 通过对象访问 ==> 错误 17 obj.func() # 类内部访问 ==> 正确 18 19 obj_son = D(); 20 obj_son.show() # 派生类中访问 ==> 错误
私有方法：
1 class Role(): 2 n = 123 3 def __init__(self,name,role,weapon,life_value=100,money=15000): 4 self.name = name 5 self.role = role 6 self.weapon = weapon 7 self.life_value = life_value 8 self.money = money 9 def __shot(self): 10 print("shooting...") 11 12 def got_shot(self): 13 print("%s ah...,I got shot..." %self.name ) 14 15 def buy_gun(self,gun_name): 16 print("%s just bought %s" %(self.name,gun_name)) 17 18 19 r1 = Role(‘Alex‘,‘police‘,‘AK47‘) 20 r1.__shot() 21 ##执行结果; 22 Traceback (most recent call last): 23 File "C:/Users/Administrator/PycharmProjects/s14/day6/cs.py", line 49, in <module> 24 r1.__shot() 25 AttributeError: ‘Role‘ object has no attribute ‘__shot‘ 26 ##因为方法已经私有化，在外面是无法调用的
封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
第一步：将内容封装到某处
self 是一个形式参数，当执行 obj1 = Foo(‘wupeiqi‘, 18 ) 时，self 等于 obj1
当执行 obj2 = Foo(‘alex‘, 78 ) 时，self 等于 obj2
所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。
第二步：从某处调用被封装的内容
调用被封装的内容时，有两种情况：
1、通过对象直接调用被封装的内容
上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名
1 class Foo: 2 def __init__(self, name, age): 3 self.name = name 4 self.age = age 5 obj1 = Foo(‘wupeiqi‘, 18) 6 print (obj1.name) # 直接调用obj1对象的name属性 7 print (obj1.age) # 直接调用obj1对象的age属性 8 9 obj2 = Foo(‘alex‘, 73) 10 print (obj2.name) # 直接调用obj2对象的name属性 11 print (obj2.age) # 直接调用obj2对象的age属性
2、通过self间接调用被封装的内容
执行类中的方法时，需要通过self间接调用被封装的内容
1 class Foo: 2 3 def __init__(self, name, age): 4 self.name = name 5 self.age = age 6 7 def detail(self): 8 print self.name 9 print self.age 10 11 obj1 = Foo(‘wupeiqi‘, 18) 12 obj1.detail() # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18 13 14 obj2 = Foo(‘alex‘, 73) 15 obj2.detail() # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
继承是指这：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
例如：
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，如下所示：
1 class 猫： 2 3 def 喵喵叫(self): 4 print ‘喵喵叫‘ 5 6 def 吃(self): 7 # do something 8 9 def 喝(self): 10 # do something 11 12 def 拉(self): 13 # do something 14 15 def 撒(self): 16 # do something 17 18 class 狗： 19 20 def 汪汪叫(self): 21 print ‘喵喵叫‘ 22 23 def 吃(self): 24 # do something 25 26 def 喝(self): 27 # do something 28 29 def 拉(self): 30 # do something 31 32 def 撒(self): 33 # do something
上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：
动物：吃、喝、拉、撒
猫：喵喵叫（猫继承动物的功能）
狗：汪汪叫（狗继承动物的功能）
1 class 动物: 2 3 def 吃(self): 4 # do something 5 6 def 喝(self): 7 # do something 8 9 def 拉(self): 10 # do something 11 12 def 撒(self): 13 # do something 14 15 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 16 class 猫(动物)： 17 18 def 喵喵叫(self): 19 print ‘喵喵叫‘ 20 21 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 22 class 狗(动物)： 23 24 def 汪汪叫(self): 25 print ‘喵喵叫‘
1 class Animal: 2 3 def eat(self): 4 print "%s 吃 " %self.name 5 6 def drink(self): 7 print "%s 喝 " %self.name 8 9 def shit(self): 10 print "%s 拉 " %self.name 11 12 def pee(self): 13 print "%s 撒 " %self.name 14 15 16 class Cat(Animal): 17 18 def __init__(self, name): 19 self.name = name 20 self.breed ＝ ‘猫‘ 21 22 def cry(self): 23 print ‘喵喵叫‘ 24 25 class Dog(Animal): 26 27 def __init__(self, name): 28 self.name = name 29 self.breed ＝ ‘狗‘ 30 31 def cry(self): 32 print ‘汪汪叫‘ 33 34 35 # ######### 执行 ######### 36 37 c1 = Cat(‘小白家的小黑猫‘) 38 c1.eat() 39 40 c2 = Cat(‘小黑的小白猫‘) 41 c2.drink() 42 43 d1 = Dog(‘胖子家的小瘦狗‘) 44 d1.eat()
所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。
学习了继承的写法之后，我们用代码来是上述阿猫阿狗的功能：
1 class Animal: 2 3 def eat(self): 4 print "%s 吃 " %self.name 5 6 def drink(self): 7 print "%s 喝 " %self.name 8 9 def shit(self): 10 print "%s 拉 " %self.name 11 12 def pee(self): 13 print "%s 撒 " %self.name 14 15 16 class Cat(Animal): 17 18 def __init__(self, name): 19 self.name = name 20 self.breed ＝ ‘猫‘ 21 22 def cry(self): 23 print ‘喵喵叫‘ 24 25 class Dog(Animal): 26 27 def __init__(self, name): 28 self.name = name 29 self.breed ＝ ‘狗‘ 30 31 def cry(self): 32 print ‘汪汪叫‘ 33 34 # ######### 执行 ######### 35 36 c1 = Cat(‘小白家的小黑猫‘) 37 c1.eat() 38 39 c2 = Cat(‘小黑的小白猫‘) 40 c2.drink() 41 42 d1 = Dog(‘胖子家的小瘦狗‘) 43 d1.eat()
那么问题又来了，多继承呢？
1、Python的类可以继承多个类，Java和C#中则只能继承一个类
2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
1 class D: 2 3 def bar(self): 4 print ‘D.bar‘ 5 6 7 class C(D): 8 9 def bar(self): 10 print ‘C.bar‘ 11 12 13 class B(D): 14 15 def bar(self): 16 print ‘B.bar‘ 17 18 19 class A(B, C): 20 21 def bar(self): 22 print ‘A.bar‘ 23 24 a = A() 25 # 执行bar方法时 26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错 27 # 所以，查找顺序：A --> B --> D --> C 28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 29 a.bar()
1 class D(object): 2 3 def bar(self): 4 print ‘D.bar‘ 5 6 7 class C(D): 8 9 def bar(self): 10 print ‘C.bar‘ 11 12 13 class B(D): 14 15 def bar(self): 16 print ‘B.bar‘ 17 18 19 class A(B, C): 20 21 def bar(self): 22 print ‘A.bar‘ 23 24 a = A() 25 # 执行bar方法时 26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错 27 # 所以，查找顺序：A --> B --> C --> D 28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 29 a.bar()
经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
六、多态
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
1 class Animal: 2 def __init__(self, name): # Constructor of the class 3 self.name = name 4 def talk(self): # Abstract method, defined by convention only 5 raise NotImplementedError("Subclass must implement abstract method") 6 7 class Cat(Animal): 8 def talk(self): 9 return ‘Meow!‘ 10 11 class Dog(Animal): 12 def talk(self): 13 return ‘Woof! Woof!‘ 14 15 animals = [Cat(‘Missy‘), 16 Dog(‘Lassie‘)] 17 18 for animal in animals: 19 print animal.name + ‘: ‘ + animal.talk()
标签：
原文地址：http://www.cnblogs.com/youweilinux/p/5817408.html
