面向过程其实就是把过程当做设计核心，根据问题的发展顺序，依次解决问题，尽可能的把过程中涉及到的问题完善解决。他有他的优点，当拿到一个问题时，可以方便的按执行的步骤写代码，但是当逻辑关系变得复杂时，有一个地方出现差错就会导致整个程序无从下手。
既然主要是说python，那我们还是回来说说python的面向对象，面向对象的编程语言还是很多的，例如C++、Java等等。
面向对象程序设计把计算机程序的执行看做一组对象的集合，每个对象之间进行消息的传送处理。有一个显著的优点就是，对某个对象进行修改，整个程序不会受到影响，自定义数据类型就是面向对象中的类的概念，而我们需要把他们的接口处理好就很好办了。说了这么多话，有些小白已经看不下去了，那接下来我们进入主题。
- 上面说了，自定义数据类型就是面向对象中的类的概念。我们先介绍一下待会儿会用到的一些术语：
1 # 我认为还是通过个例子更容易让人理解
2
3 # 首先我们定义一个类
4 class A(object): # 这是一个类，class是创建一个类的标志
5 # 类变量（类属性）：类属性是指类的属性，属性就是我们刚学编程的时候听过的变量。
6 x = 7
7 y = "asdf"
8
9 def __init__(self,name,age):
10 self.name = name
11 self.age = age
12
13 # 方法：方法就是在类外面我们写的函数，放在类里就叫做一个方法
14 def func(self):
15 c = 8 # 实例变量：定义在方法中的变量只作用于当前实例的类
16 print("Hello World!")
17
18 a = A() # 创建一个对象，实例化
上面的部分代码还需要再解释一下：
- object：
- 注意类名后面括号里有个参数object，他代表所有类的基类，也叫作超类。
- 这就有了一个新式类和旧式类的概念：
- 当用到多继承的时候，如果子类中没有想用的方法名或属性名，他会自动回到上面去找。那么按广度优先遍历的方法去寻找就是新式类（object）；深度优先（括号里啥也没有）。
- __init__()：构造函数，实例化的时候若不显示的定义，那么默认调用一个无参的，是初始化的意思。
一、封装
含义：对外面隐藏对象的属性和方法，仅提供接口。
作用：安全性（通过私有变量改变对外的使用），复用性
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 class Student(object):
5 def __init__(self, name, score):
6 # 属性仅前面有两个下划线代表私有变量，外部无法访问，因此我们定义了两个新的方法，这样可以避免外部通过score乱改分数，仅当我们自己知道接口才可以修改
7 self.__name = name
8 self.__score = score
9
10 def info(self):
11 print('name: %s ; score: %d' % (self.__name,self.__score))
12
13 def getScore(self):
14 return self.__score
15
16 def setScore(self, score):
17 self.__score = score
18
19 stu = Student('Tom',99)
20 print('修改前分数：',stu.getScore())
21 stu.info()
22 stu.setScore(59)
23 print('修改后分数：',stu.getScore())
24 stu.info()
封装还是比较好理解的，不过其中还有一些，比如析构函数，重写等等知识点最好在官方文档过一遍。
二、继承
2.1.1、含义
前面我们提到过，面向对象编程有个好处就是代码复用，而其中一种方法就是通过继承机制。继承就是说定义的一个新类，继承现有的类，获得现有类的非私有属性、方法。提到个私有，就是上面提到的那个前面加两个下划线的那个东西，他在外部无法调用，继承他的子类也不能。被继承的那个类称为基类、父类或超类，子类也可以叫做派生类。
2.1.2、特点
1、在继承中，基类的构造方法（__init__()方法）不会被自动调用，需要在子类的构造方法中专门调用。
2、在调用基类的方法时需要加上基类的类名前缀，并带上self参数变量。区别于在类中调用普通函数时不需要带self参数。
3、在python中，首先查找对应类型的方法，如果在子类中找不到对应的方法，才到基类中逐个查找。
2.2、单继承
直接上代码，仔细理解一下里面的关系，我把讲解都写在注释的地方。
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 # 这是定义了一个基类
5 class Person(object):
6 def __init__(self, name, age, money):
7 self.name = name
8 self.age = age
9 self.__money = money # 私有属性
10 # 被引入时，继承不了，但他们的set，get函数可以继承
11
12 def setMoney(self,money):
13 self.__money = money
14
15 def getMoney(self):
16 return self.__money
17
18 def run(self):
19 print("run")
20
21 def eat(self):
22 print("eat")
下面是定义的一个子类，继承自上方的类，来使用父类中的方法和属性：
1 # 由于我将每个类写在了不同的文件里，所以需要引入一下，这就和我们调用库一样
2 from 单继承的实现.person import Person
3
4 class Student(Person):
5 def __init__(self,name,age,stuid,money):
6 # 调用父类中的__init__()，supper括号中的内容，在python3以后可以不写，写上更安全些
7 super(Student,self).__init__(name,age,money) # 让父类的self当做子类的对象
8 # 子类可以由一些自己独有的属性或者方法
9 self.stuid = stuid
创建对象，通过子类使用父类的属性和方法：
1 from 单继承的实现.student import Student
2
3 stu = Student('Tom',18,111,999) # 创建Student对象
4 # 下列方法和属性均是在父类Person中定义的，在Student继承之后，便可以直接使用
5 print(stu.name, stu.age)
6 stu.run()
7 print(stu.getMoney())
2.3、多继承
上面的单继承要多理解一下，单继承理解了之后，多继承也就没什么了。
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 class Father(object):
5 def __init__(self,money):
6 self.money = money
7 def play(self):
8 print("play")
9 def func(self):
10 print("func1")
11
12 class Mother(object):
13 def __init__(self,facevalue):
14 self.facevalue = facevalue
15 def eat(self):
16 print("eat")
17 def func(self):
18 print("func2")
19
20
21 class Children(Father,Mother):
22 def __init__(self,money,facevalue):
23 # 多继承时调用父类的属性
24 Father.__init__(self,money)
25 Mother.__init__(self,facevalue)
26
27 def main():
28 c = Children(300,100)
29 print(c.money,c.facevalue)
30 c.play()
31 c.eat()
32 # 注意：如果多个父类中有相同的方法名，默认调用括号中前面的类
33 c.func()
34 if __name__ == "__main__":
35 main()
View Code
三、多态
- 多态：是指一种事物的多种形态
- 多态性：多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。
- eg：在python中的“+”号，它既可以表示数字的加法，也可以表示字符串的拼接，（__add__()）
1 class Animal(object):
2 def __init__(self, name):
3 self.name = name
4
5 def run(self):
6 pass
7
8 def animalRun(self):
9 self.run()
10
11
12 class Cat(Animal):
13 def run(self):
14 print('cat is running')
15
16
17 class Dog(Animal):
18 def run(self):
19 print('dog is running')
20
21
22 d = Dog('dog')
23 c = Cat('cat')
24
25 Animal.animalRun(c)
26 Animal.animalRun(d)
View Code
四、面向对象案例
下面给一个小程序，是模拟反恐精英，保卫者和敌人。主要是让大家看明白，只有简单的几个功能，希望大家可以从中理解面向对象的思想。python中，任何都是对象。
首先，这是我的几个类模块，分开来写比较清晰一点，写在一起也是没问题的。接下来我们一点一点的分析：
。。。。。。。。。。
得有人，好人和坏人
。。。。。。。。。。
人得有武器，先给他们两种：枪和手榴弹
。。。。。。。。。。
枪还有个弹夹也可以作为对象
。。。。。。。。。。
想想还有什么，差不多了吧，那么我们就开始写，想到什么再补充
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 from cs.person import Person
5
6 class Gengster(Person):
7
8 # 初始化，血量默认为100
9 def __init__(self, gun, grenade, blood=100):
10 self.gun = gun
11 self.grenade = grenade
12 self.blood = blood
13
14 # 人有开枪的功能
15 def fire(self,person):
16 person.blood.amount -= 5 # 对谁开枪，那个人就要减血
17 self.gun.shoot() # 这个人开枪，这又调用了枪的类，关于子弹的减少在枪的类里
18
19 # 扔手榴弹，实际上是和枪一样的
20 def fire2(self,person):
21 person.blood -= 10
22 self.grenade.damage() # 同样通过另一个类来控制数量的减少，使代码看起来简洁点
23
24 # 给弹夹里加子弹
25 def fillbullet(self):
26 self.gun.bulletbox.bulletcount += 10
27
28 # 补血，并保证满血只能是100
29 def fillblood(self,num):
30 self.blood += num
31 if self.blood > 100:
32 self.blood = 100
33 print("补血后血量：" + str(self.blood))
坏蛋
1 # 主要注释和上一个类似，这里不赘述
2
3 #!/usr/bin/env python
4 # -*- coding:utf-8 -*-
5
6 from cs.person import Person
7
8 class Profector(Person):
9
10 def __init__(self, gun, grenade, blood = 100):
11 self.gun = gun
12 self.grenade = grenade
13 self.blood = blood
14
15 def fire(self, person):
16 person.blood -= 5
17 self.gun.shoot()
18 print(str(person) + "血量减少5，剩余" + str(person.blood) )
19
20 def fire2(self,person):
21 person.blood -= 10
22 self.grenade.damage()
23
24 def fillbullet(self):
25 self.gun.bulletbox.bulletcount += 10
26
27 def fillblood(self,num):
28 self.blood += num
29 if self.blood > 100:
30 self.blood = 100
31 print("补血后血量：" + str(self.blood))
好人
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 class Gun(object):
5
6 # 初始化，把弹夹放里面，通过人来控制枪，再来控制弹夹
7 def __init__(self,bulletbox):
8 self.bulletbox = bulletbox
9
10 def shoot(self):
11 if self.bulletbox.bulletcount == 0:
12 print('没子弹了')
13 else:
14 self.bulletbox.bulletcount -= 1
15 print(str(self) + '开一枪，还剩%d颗子弹' % (self.bulletbox.bulletcount))
枪
1 # 与枪类似
2
3 #!/usr/bin/env python
4 # -*- coding:utf-8 -*-
5
6 class Grenade(object):
7
8 def __init__(self,grenadecount):
9 self.grenadecount = grenadecount
10
11 def damage(self):
12 if self.grenadecount == 0:
13 print('手雷没有了')
14 else:
15 self.grenadecount -= 1
16 print(str(self) + "轰他一炮，手雷还剩%d颗" % (self.grenadecount))
手榴弹
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 class Bulletbox(object):
5
6 # 弹夹只需控制数量就好了
7 def __init__(self,bulletcount):
8 self.bulletcount = bulletcount
弹夹
这下差不多了，人也有了，武器也有了，可以开展了
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 from cs.grenade import Grenade
5 from cs.gun import Gun
6 from cs.bulletbox import Bulletbox
7 from cs.gengster import Gengster
8 from cs.profector import Profector
9 # 参数：枪，手榴弹，血（默认100，且上限为100）
10
11 # 创建弹夹，枪，手榴弹的对象，以备人使用
12 bulletbox = Bulletbox(10)
13 gun = Gun(bulletbox)
14 grenade = Grenade(20)
15
16 # 创建人对象
17 good1 = Profector(gun,grenade)
18 good2 = Profector(gun,grenade)
19 bad1 = Gengster(gun,grenade)
20 bad2 = Gengster(gun,grenade)
21
22 print("好人1开枪打坏人1和2")
23 good1.fire(bad1)
24 good1.fire(bad2)
25 print("好人2开枪打坏人1和2")
26 good2.fire(bad1)
27 good2.fire(bad2)
28 print("坏人1炸好人1和2")
29 bad1.fire2(good1)
30 bad1.fire2(good2)
31 print("坏人2炸好人1和2")
32 bad2.fire2(good1)
33 bad2.fire2(good2)
34 print("坏人1补血3个")
35 bad1.fillblood(3)
main
现在这一套流程就结束了，刚开始看也许看不太懂，要仔细看一下每个类之间的关系，先想清楚了，再来看代码是如何实现的
有没有看出来点区别，面向过程编程是就事论事，而面向对象，先把对象找出来，通过对象之间的关系把他们联系起来。想想如果要用面向过程来实现这个，代码会写成什么样子呢。
然而并没有结束，记不记得前面的类中有两对是比较类似的，好人和坏人，枪和手榴弹（这个里面的类还不太一样），那么想到了什么没有，前面提到的继承的优点是什么来着，----复用。我们可以可以用继承来写一下呢，如果你说这个也没少几行代码嘛，那么，如果在实际当中你要创建成百上千的对象呢，难道还要每个都复制粘贴改代码吗，还占空间对不对。
那么我们写一个人类，毕竟好人和坏人都是人：
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 class Person(object):
5
6 def __init__(self, gun, grenade, blood):
7 self.gun = gun
8 self.grenade = grenade
9 self.blood = blood
10
11 def fire(self, person):
12 person.blood -= 5
13 self.gun.shoot()
14 print(str(person) + "血量减少5，剩余" + str(person.blood) )
15
16 def fire2(self, person):
17 person.blood -= 10
18 self.grenade.damage()
19 print(str(person) + "血量减少10，剩余" + str(person.blood) )
20
21 def fillbullet(self):
22 self.gun.bulletbox.bulletcount += 10
23
24 def fillblood(self,num):
25 self.blood += num
26 if self.blood > 100:
27 self.blood = 100
28 print(str(self) + "补血后血量：" + str(self.blood))
person
现在我们就不必把好人坏人都重写了，只需要继承一下人类就好了：
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 from cs.person import Person
5
6 class Profector(Person):
7
8 def __init__(self, gun, grenade, blood = 100):
9 super(Profector,self).__init__(gun, grenade, blood)
10
11
12 class Gengster(Person):
13
14 def __init__(self, gun, grenade, blood=100):
15 super(Gengster, self).__init__(gun, grenade, blood)
16
17 # 这里面有个supper，他就是对父类的继承
好人和坏人
我知道大家看的有点迷了，我把他整在一起了，不过还是建议大家先根据每个小模块学习，顺便理解一下引入自定义模块。下面是完整代码，可以直接粘贴：
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 class Bulletbox(object):
5 def __init__(self,bulletcount):
6 self.bulletcount = bulletcount
7
8
9 class Gun(object):
10 def __init__(self,bulletbox):
11 self.bulletbox = bulletbox
12
13 def shoot(self):
14 if self.bulletbox.bulletcount == 0:
15 print('没子弹了')
16 else:
17 self.bulletbox.bulletcount -= 1
18 print(str(self) + '开一枪，还剩%d颗子弹' % (self.bulletbox.bulletcount))
19
20
21 class Grenade(object):
22 def __init__(self,grenadecount):
23 self.grenadecount = grenadecount
24
25 def damage(self):
26 if self.grenadecount == 0:
27 print('手雷没有了')
28 else:
29 self.grenadecount -= 1
30 print(str(self) + "轰他一炮，手雷还剩%d颗" % (self.grenadecount))
31
32
33 class Person(object):
34 def __init__(self, gun, grenade, blood):
35 self.gun = gun
36 self.grenade = grenade
37 self.blood = blood
38
39 def fire(self, person):
40 person.blood -= 5
41 self.gun.shoot()
42 print(str(person) + "血量减少5，剩余" + str(person.blood) )
43
44 def fire2(self, person):
45 person.blood -= 10
46 self.grenade.damage()
47 print(str(person) + "血量减少10，剩余" + str(person.blood) )
48
49 def fillbullet(self):
50 self.gun.bulletbox.bulletcount += 10
51
52 def fillblood(self,num):
53 self.blood += num
54 if self.blood > 100:
55 self.blood = 100
56 print(str(self) + "补血后血量：" + str(self.blood))
57
58
59 class Profector(Person):
60 def __init__(self, gun, grenade, blood = 100):
61 super(Profector,self).__init__(gun, grenade, blood)
62
63
64 class Gengster(Person):
65 def __init__(self, gun, grenade, blood=100):
66 super(Gengster, self).__init__(gun, grenade, blood)
67
68
69 bulletbox = Bulletbox(10)
70 gun = Gun(bulletbox)
71 grenade = Grenade(20)
72
73 good1 = Profector(gun,grenade)
74 good2 = Profector(gun,grenade)
75 bad1 = Gengster(gun,grenade)
76 bad2 = Gengster(gun,grenade)
77
78 print("好人1开枪打坏人1和2")
79 good1.fire(bad1)
80 good1.fire(bad2)
81 print("好人2开枪打坏人1和2")
82 good2.fire(bad1)
83 good2.fire(bad2)
84 print("坏人1炸好人1和2")
85 bad1.fire2(good1)
86 bad1.fire2(good2)
87 print("坏人2炸好人1和2")
88 bad2.fire2(good1)
89 bad2.fire2(good2)
90 print("坏人1补血3个")
91 bad1.fillblood(3)
all
我在这里还想和大家一起看一下结果：
看一下有没有发现什么问题呢？
血量减少的人的对象还是正常的，然而看一下开枪的人。有没有发现好人1和好人2的对象时同一个地址呢，他们的子弹也是累积的递减；坏人使用手榴弹也是。为什么开枪的人会是这样，而受伤的人却是正常的呢？
提醒一下，我们前面创建的那些对象，有些是为了下一个对象调用而准备的，看看出错是在那个模块里错的，出错的和正确的他们之间有哪些不一样呢，而且出错的原理是什么呢？大家可以思考思考，评论区互相讨论一下。
今天就到这里了，大家多多互动，互相学习。希望路过的大佬指点指点。
原文http://www.cnblogs.com/yudanqu/p/9127496.html
欢迎关注我的博客或者公众号：https://home.cnblogs.com/u/Python1234/ Python学习交流
欢迎加入我的千人交流答疑群：125240963