一、面向过程 VS 面向对象
1、编程范式
编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。
两种最重要的编程范式分别是面向过程编程和面向对象编程。
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（多态）
多态是面向对象的重要特性,简单说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作,
他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”,
因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定
三、面向对象编程(Object-Oriented Programming )介绍
无论用什么形式来编程，都要明确记住以下原则：
- 写重复代码是非常不好的低级行为
- 你写的代码需要经常变更
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编程的主要作用也是使你的代码修改和扩展变的更容易，函数编程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改。
开发一个简单的cs程序
先用非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
4个角色虽然创建好了，但是有个问题就是，每创建一个角色，我都要单独命名，name1,name2,name3,name4…，后面的调用的时候这个变量名你还都得记着，要是再让多加几个角色，估计调用时就很容易弄混啦，所以我们想一想，能否所有的角色的变量名都是一样的，但调用的时候又能区 分开分别是谁？
当然可以，我们只需要把上面的变量改成字典的格式就可以啦。
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
很好，这个以后调用这些角色时只需要roles[1],roles[2]就可以啦，角色的基本属性设计完了后，我们接下来为每个角色开发以下几个功能
- 被打中后就会掉血的功能
- 开枪功能
- 换子弹
- 买枪
- 跑、走、跳、下蹲等动作
- 保护人质（仅适用于警察）
- 不能杀同伴
我们可以把每个功能写成一个函数，类似如下：
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
继续按照这个思路设计，再完善一下代码，游戏的简单版就出来了，但是在往下走之前，我们来看看上面的这种代码写法有没有问题，至少从上面的代码设计中，我看到以下几点缺陷：
- 每个角色定义的属性名称是一样的，但这种命名规则是我们自己约定的，从程序上来讲，并没有进行属性合法性检测，也就是说role 1定义的代表武器的属性是weapon, role 2 ,3,4也是一样的，不过如果我在新增一个角色时不小心把weapon 写成了wepon , 这个程序本身是检测 不到的
- terrorist 和police这2个角色有些功能是不同的，比如police是不能杀人质的，但是terrorist可能，随着这个游戏开发的更复杂，我们会发现这2个角色后续有更多的不同之处，但现在的这种写法，我们是没办法 把这2个角色适用的功能区分开来的，也就是说，每个角色都可以直接调用任意功能，没有任何限制。
- 我们在上面定义了got_shot()后要减血，也就是说减血这个动作是应该通过被击中这个事件来引起的,我们调用 get_shot()，got_shot（）这个函数再调用每个角色里的life_value变量来减血。 但其实我不通过got_shot()，直接调用角色roles[role_id][‘life_value’] 减血也可以呀，但是如果这样调用的话，那可以就是简单粗暴啦，因为减血之前其它还应该判断此角色是否穿了防弹衣等，如果穿了的话，伤害值肯定要减 少，got_shot()函数里就做了这样的检测，你这里直接绕过的话，程序就乱了。 因此这里应该设计 成除了通过got_shot(),其它的方式是没有办法给角色减血的，不过在上面的程序设计里，是没有办法实现的。
- 现在需要给所有角色添加一个可以穿防弹衣的功能，那很显然你得在每个角色里放一个属性来存储此角色是否穿 了防弹衣，那就要更改每个角色的代码，给添加一个新属性，这样太low了，不符合代码可复用的原则
上面这4点问题如果不解决，以后肯定会引出更大的坑，这些问题其实能过OOP就可以很简单的解决。
A、构造函数
之前的代码改成用OOP中的“类”来实现的话如下：
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
先不考虑语法细节，相比函数式写法，上面用面向对象中的类来写最直接的改进有以下2点：
- 代码量少了近一半
- 角色和它所具有的功能可以一目了然看出来
接下来分解一下上面的代码分别是什么意思
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’)
你执行r1 = Role(‘Alex‘,‘police‘,‘AK47’)时，python的解释器其实干了两件事：
- 在内存中开辟一块空间指向r1这个变量名
- 调用Role这个类并执行其中的__init__(…)方法，相当于Role.__init__(r1,‘Alex‘,‘police‘,’AK47’),这么做是为什么呢？ 是为了把‘Alex‘,‘police‘,’AK47’这3个值跟刚开辟的r1关联起来，是为了把‘Alex‘,‘police‘,’AK47’这3个值跟刚开辟的r1关联起来，是为了把‘Alex‘,‘police‘,’AK47’ 这3个值跟刚开辟的r1关联起来，重要的事情说3次， 因为关联起来后，你就可以直接r1.name, r1.weapon 这样来调用啦。所以，为实现这种关联，在调用__init__方法时，就必须把r1这个变量也传进去，否则__init__不知道要把那3个参数跟谁关联 呀。
- 所以这个__init__(…)方法里的，self.name = name , self.role = role 等等的意思就是要把这几个值 存到r1的内存空间里。
后面那几个方法为什么也还需要self参数么？ 不是在初始化角色的时候 ，就已经把角色的属性跟r1绑定好了么？
good question, 先来看一下上面类中的一个buy_gun的方法：
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")
执行结果
#Alex has just bought B21
依然没给self传值 ，但Python还是会自动的帮你把r1 赋值给self这个参数，因为，你在buy_gun(..)方法中可能要访问r1的一些其它属性， 比如这里就访问 了r1的名字，怎么访问呢？你得告诉这个方法，于是就把r1传给了这个self参数，然后在buy_gun里调用 self.name 就相当于调用r1.name ，如果还想知道r1的生命值有多少，直接写成self.life_value就可以了。 说白了就是在调用类中的一个方法时，你得告诉人家你是谁。
总结：
- 上面的这个r1 = Role(‘Alex‘,‘police‘,‘AK47’)动作，叫做类的“实例化”， 就是把一个虚拟的抽象的类，通过这个动作，变成了一个具体的对象了， 这个对象就叫做实例
- 刚才定义的这个类体现了面向对象的第一个基本特性，封装，其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内容
2、类变量
a、什么是类变量，类变量有什么用途？
b、类变量的用途:
大家共用的属性，为了节约内存
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 属性，在内存里类似于下图来保存。
第二步：从某处调用被封装的内容
调用被封装的内容时，有两种情况：
- 通过对象直接调用
- 通过self间接调用
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）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代 码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
Pyhon不直接支持多态，但可以间接实现
通过Python模拟的多态
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()