编程范式：
编程是，程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式，对这些不同的编程方式的特点进行归纳总结的出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。两种最重要的编程方式分别是面向过程编程和面向对象编程。再有一个就是之前了解过的函数式编程。

面向过程编程（Procedural Programming）：
面向过程编程，依赖procedures，一个procedures包含一组要被进行计算的步骤，比如写一个函数，函数中写了一堆代码，函数一被执行，将相当于执行了一组有步骤的代码。面向过程又被称为top-down-languages，就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你有也要跟着修改，举个例子，如果程序开头你设置了一个变量值为1，但如果其他子过程依赖这个值为1的变量才能正常运行，那如果你改了这个变量，那这个子过程你也要修改，加入又有一个其他子程序依赖这个子过程，那就会发生一连串的影响，随着程序越来越大，这种编程方式的维护难度会越来越高。

所以我们一般认为，如果你只写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护的，那还是用面向对象最方便了。

面向对象编程：

世界万物，皆可分类
世界万物，皆为对象

只要是对象，就肯定属于某种品类
只要是对象，就肯定有属性（他的功能，名字也可充当它的属性）

你是上帝–>创造>地球

山川，河流，大海，森林

飞禽 （属性）飞，吃虫子，下蛋，唱歌-------->[捏造]模板（对象）
布谷鸟 （属性）飞，吃虫子，下蛋，唱歌-------->改造模板
乌鸦 （属性）飞，吃虫子，下蛋，唱歌------->改造模板

几百种鸟

走兽 -------->[捏造]模板（对象）
狮子 （属性）森林之王-------->改造模板
老虎 （属性）百兽之王-------->改造模板

人 （属性）思考，说话，吃喝拉撒睡-------->[捏造]模型（对象）

OOP编程时利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为他可以时编程的维护和拓展变得更简单，并且可以大大提高程序开发效率，另外，基于面向对象的程序可以使他人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

面向对象的结果核心特性如下：
Class类(用类来提取共同属性，捏造模板)
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原理。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

Object对象（用类造出来的模板，就是对象，又叫实例，不代表具体实际的东西）
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之间有共性，亦有不同。

面向对象编程的三大特性：
Encapsulation封装（造对象的时候，有些东西是需要封装的）
在类中对数据的复制、内部调用对外部用户是透明的，这使类编程了一个胶囊或容器，里面包含着类的数据和方法。

Inheritance继承
一个类可以派生出子类、在这个父类里定义的属性、方法自动被子类继承。

Polymorphism多态
态是面向对象得重要特性，简单点说：“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物变现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来，再通过这个抽象的事物，与不同的事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作，他只要在九点的时候说“开始工作”即可，而不需要对销售人员说“开始销售工作”，会技术人员说“开始技术工作”，因为“员工”是一个抽象的事物，只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象，调用的方式是该子类型的方法。这里引用和调用方法的代码编程前就已经决定了，而引用所指向的对象可以在运行期间动态绑定。

面向对象编码（Object-Oriented Programming）介绍

# 实例：# 想描述狗# 1、先通过类定义一种对象(作用：捏模子)
class Dog:def __init__(self,name):self.name = namedef bulk(self):print('%s:wang wang wang!'% self.name)# 
d1 = Dog('Tom')
d2 = Dog('警长')
d3 = Dog('皇冠')d1.bulk()
d2.bulk()
d3.bulk()

打印结果：
Tom:wang wang wang!
警长:wang wang wang!
皇冠:wang wang wang!

无论用什么形式来编程，我们都要明确记住以下原则：
1、写重复代码是非常不好的低级行为
2、你写的代码需要经常变更

而函数编程与OOP的主要区别就是，OOP可以使程序更加容易扩展和易更改。形象一点理解就是，函数编程就好比刀，OOP编程就是枪，哪个更好用就显而易见了。

# Author:JM'''参考游戏，枪战类游戏。恐怖分子和警察，除了角色不同，其他基本都一样，每个人都有生命值、武器等。
先用非oop的方式写出游戏的基本角色。
'''
# role 1
name = "Alex"
role = "terrorist"
weapon = "AK47"
life_value = 100# role 2
name = "Jack"
role = "police"
weapon = "B22"
life_value = 100
'''
上面定义了一个恐怖分子Alex和一个警察Jack，但只2个人不好玩呀，一杀就死了，没意思，
所以再加一个恐怖分子和警察。'''# role 3
name = "Rain"
role = "terrorist"
weapon = "C33"
life_value = 100
money3 = 10000# role 2
name = "Eric"
role = "police"
weapon = "B51"
life_value = 100
money4 = 10000

以上案例中，每创建一个角色，都得单独命名，后面调用这个变量时还得记着，角色一多，调用时就容易混。所以，是否可以所有的变量名都是一样的，调用时却可以区分呢？
当然可以，只需将上面变量改成字典的格式：

roles = {1：{"name":"Alex","role":"terrorist","weapon":"AK47","life_value":100,"money":15000,},2:{"name":"Jack","role":"police","weapon":"B22","life_value":100,"money":15000,},3:{"name":"Rain","role":"terrorist","weapon":"C33","life_value":100,"money":15000,},4:{"name":"Eric","role":"police","weapon":"B51","life_value":100,"money":15000,},}
print(roles[1]) #Alex
print(roles[2]) #Jack

接下来，为角色开发功能：
1、被打中后久会掉血的功能
2、开枪功能
3、换子弹
4、买枪
5、跑、走、跳、下蹲等动作
6、保护人质（仅用于警察）
7、不能杀同伴
8、……
我们可以把每个功能写成一个函数，类似如下：

def shot(by_who):# 开了枪后要减子弹pass
def get_shot():#中枪后要减血who["life_value"] -= 10pass
def buy_gun(who,gun_name):#检查钱够不够，买了枪后要口钱pass

上面代码设计中的几种缺陷：
1、每个角色定义的属性名称是一样的，但这种命名规则是我们自己约定的，从程序上来讲，并没有进行属性合法性校验，也就是说，role1定义的代表武器的属性是weapon，role2、3、4也是一样，不过如果在新建角色时不小心将weapon写成了wepon，这个程序本身是检测不到的。也即，每建立一个属性，都要认为确认每个属性名不要写错。
2、terrorist喝police这2个角色有些功能是不同的，比如police是不能杀人的，但是terrorist可以，随着这个游戏开发的越来越复杂，我们也会发现这2个角色后续应该有更多不同之处，但现在这种写法，我们是没办法把这2个角色用的功能区分开的，也就是说，每个角色都可以调用任意功能，而没有限制。
3、我们在上面定义了got_shot()后要减血，也就是说减血这个动作是应该通过被击中这个事件来引起的，我们调用got_shot()这个函数，然后再调用每个角色的life_value变量来减血，但其实我不通过got_shot()，直接调用角色roles[role_id][“life_value”]减血也可以呀，但是如果这样调用的话，那可以就是简单粗暴啦，因为减血之前其他还应该判断此角色是否穿了防弹衣等，如果穿了的话，伤害值肯定要减少，got_shot()函数里就想了这样的检测，你这里直接快过的话，程序就乱了。因此这里应该设计成除了通过got_shot()，其他的方法是没有办法给角色减血的，不过在上面的程序设计中，是没办法实现的。
4、现在需要给所有角色添加一个可以穿防弹衣的功能，那很显然你得在每个角色里放一个属性来存储此角色是否穿了防弹衣，那要更改每个角色的代码，给添加一个新属性，这样太low，不符合代码可复用的原则。

# 类的定义
class Role(object):def __init__(self,name,role,weapon,life_value=100,money=15000):# 构造函数# 作用：在实例化时，做一些类的初始化的工作self.name = nameself.role = roleself.weapon = weaponself.life_value = life_valueself.money = moneydef shot(self):print("shooting……")def got_shot(self):print("ah...,I got shot...")def buy_gun(self,gun_name):print("%s just bought %s"% (self.name,gun_name))

类当中的构造函数，主要作用是用来初始化数据，方便日后实例化对象的调用。

Role(‘Alex’,‘police’,‘AK47’),调用类，实例化（初始化一个类，相当于造了一个对象，克隆了一份共有属性并使其具有个性化属性）
—需要在内存里存起来，方便调用，否则造了的对象用过就没了，
或者再写一个Role(‘Alex’,‘police’,‘AK47’)来调用的话， 相当于又造了一个新的对象，在内存里不是一样的地址的
—存在变量里

r1 = Role('Alex','police','AK47') #生成一个角色
r2 = Role('Jack','terrorist','B22') #生成一个角色r1.buy_gun('AK47')

打印结果：
Alex just bought AK47

把一个类变成一个具体对象的过程，叫实例化。
实例化过程中如果想要传参数，语法定义，只能通过__init__()方法，而且必须在如上例中的位置，而不能在class Role后。

class Role(object):def __init__(self,name,role,weapon,life_value=100,money=15000):self.name = nameself.role = roleself.weapon = weaponself.life_value = life_valueself.money = moneydef shot(self):print("shooting……")def got_shot(self):print("ah...,I got shot...")def buy_gun(self,gun_name):print("%s just bought %s"% (self.name,gun_name))print(Role) # 只要不通过Role()来调用，这个功能实际上只是查看类Role的函数体

打印结果：
<class ‘main.Role’>

上述这个过程中，说明这个类，和函数或变量一样，运行后，在内存中是存在的。当然，只不过如果没有变量名赋给它，也是要用完就销毁的。

# 函数中的执行方式：直接传参
# 实际执行方式：将变量本身也传了进去
Role(r1,'Alex','Police',15000)
r1.name = 'Alex'
r1.role = 'Police'
r1.money = 15000# 即为：
Role(self,'Alex','Police',15000)
self.name = 'Alex'
self.role = 'Police'
self.money = 15000

调用类中的方法：
如：r1.buy_gun()
就等同于：Role.buy_gun(r1)—所以如上述的例子中，每写一个def函数，都要有一个self参数来接收r1、r2……,如“def shot(self)”中的self就是用来接收实例化的对象的。self相当于是谁调用了它，它就是谁了。通过上面的例子感受一下：

class Role(object):def __init__(self,name,role,weapon,life_value=100,money=15000):#构造函数self.name = nameself.role = roleself.weapon = weaponself.life_value = life_valueself.money = moneydef shot(self):print("%s shooting……"% self.name)r2 = Role('Jack','terrorist','B22') #生成一个角色
r2.shot()     # Role.shot(r2)

打印结果：
Jack shooting……