参考博客：http://www.cnblogs.com/alex3714/articles/5188179.html
一.面向对象介绍
class
object
封装
继承
多态
语法
属性
方法
构造函数
析构函数
私有方法，私有属性
类变量
实例变量
1.编程范式：
1）面向过程编程（Procedural Programming)：
又被称为top-down languages,程序从上到下一步步执行，从头到尾。
缺点：一次性，维护难度大。
2）面向对象编程（Object-Oriented Programming OOP）：
利用“类”和”对象“来创建各种模型来实现对真实世界的描述。
优点：使编程的维护和扩展变得简单，大大提高程序开发效率，
容易理解，团队开发变得容易。
2.面向对象编程：
1）class类：
对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象都具备的属性、共同的方法。
2) object对象：
一个对象即是一个类实例化后的实例。一个类必须经过实例化后才能在程序中调用；一个类可以实
例化多个对象，每个对象可以有不同的属性。
3）三大特性：
Encapsulation封装：在类中对数据的赋值、内部调用对外部用户是透明（用户不可见）的，
这使类变成了一个胶囊或者容器，里面包含着类的数据和方法。
Inheritance继承：一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。
Ploymorphism多态：
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，
指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对
父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系
列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。
比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，
而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物,
只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,
调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,
而引用所指向的对象可以在运行期间动态绑定。
3.定义类：
class Dog:
def __init__(self,name):
self.name = name
def bulk(self):
print("%s : wang wang wang" % self.name)
d1 = Dog("hah ")
d2 = Dog("hehh")
d3 = Dog("jajj")
d1.bulk()
d2.bulk()
d3.bulk()
4.构造函数
class Role(object):
n = 123 #类变量
name = '我是类name'
n_list = [] #增加一个列表
#定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么
def __init__(self,name,role,weapon,life_value=100,money=15000):
#构造函数
#初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
#__init__中的第一个参数self,和这里的self都 是什么意思？
self.name = name #等价于 r1.name = name #实例变量(静态属性），作用域就是实例本身。
self.role = role
self.weapon = weapon
self.life_value = life_value
self.__life_value = life_value #私有属性，前面加两个下划线
self.money = money
def shot(self): # 类的方法，功能（动态属性）
print("shooting!")
print(Role.n)
r1 = Role('xiaolaizi','police','98K') #把一个类变成一个具体对象的过程叫实例化
r1.name = "小赖子" #改名
r1.bullet_prove = True #添加类中没有的一个属性
r1.n_list.append("from r1") #往类变量列表中添加内容
print(r1.n,r1.name,r1.n_list)
r2 = Role('xiaomazi','police','mini14')
print(r2.n,r2.name,r2.n_list)
5. 类变量与实例变量区别：
对象先调用实例变量，找不到再去类变量里面找。
实例变量可以修改，增加，删除 （del）。
实例变量：每个对象各自特有的属性；
类变量: 共有的属性。
6.类变量的作用及析构函数
类变量的用途：大家公用的属性，节省开销。
析构函数：在实例释放（就是自己写了 del 某某某之后）、销毁的时候自动执行的，通常用于做一些收尾工作，如关闭一些数据库连接，关闭打开的临时文件。
只有你自己del r1这个实例对象，python才会销毁r1对应的内存。（哪怕是你创建了r1这个内存之后再也不用了，python
也不会去给你删除，因为他不知道你用不用，只有当你摘去r1这个门牌号，python 才会拆了这座房子）
7. 私有方法，已有属性
前面加两个下划线，只能在内部访问。
8.类的继承
1 class People:
2 """类的继承,父类"""
3 def __init__(self,name,age):
4 self.Name = name #self.name = name
5 self.Age = age #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。
6
7 def eat(self):
8 print("%s is eating ..." % self.Name)
9
10 def sleep(self):
11 print("%s is sleeping ..." % self.Name)
12
13 def talk(self):
14 print("%s is talking ..." % self.Name)
15
16 class Man(People):
17 def piao(self):
18 print("%s is piaoing ..." % self.Name)
19
20 #def sleep(self): #覆盖了父类方法
21 # print("man is sleeping ...")
22 # print("-"*20)
23
24 def sleep(self): #重构父类的方法
25 People.sleep(self) #既执行父类的方法，又执行子类的方法
26 print("+" * 20)
27 print("man is sleeping ...")
28
29 class Women(People):
30 def get_birth(self):
31 print("%s is born a baby" % self.Name)
32
33
34 m1 = Man("xiaolaizi",22)
35 w1 = Women("xiaolizi",24)
36 m1.eat()
37 m1.piao()
38 m1.sleep()
39 w1.get_birth()
问题来了，那么怎么在父类的基础上只给Man类增加除了name ,age 之外的属性呢，而不影响Women子类？
1 class People:
2 """类的继承,父类"""
3 def __init__(self,name,age):
4 self.Name = name #self.name = name
5 self.Age = age #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。
6
7 def eat(self):
8 print("%s is eating ..." % self.Name)
9
10 def sleep(self):
11 print("%s is sleeping ..." % self.Name)
12
13 def talk(self):
14 print("%s is talking ..." % self.Name)
15
16 class Man(People):
17 def __init__(self,name,age,money): #对构造函数进行重构
18 People.__init__(self,name,age)
#等价于 super(Man,self).__init__(name,age) 优点是不用写父类名（哈哈哈）
19 self.money = money
20 print("%s 一生下来就有钱。。。。" % self.Name)
21
22 def piao(self):
23 print("%s is piaoing ..." % self.Name)
24
25 def sleep(self): #重构父类的方法
26 People.sleep(self) #既执行父类的方法，又执行子类的方法
27 print("man is sleeping ...")
28
29 class Women(People):
30 def get_birth(self):
31 print("%s is born a baby" % self.Name)
32 m1 = Man("xiaolaizi",22,1000)
33 w1 = Women("xiaolizi",24)
34 m1.eat()
35 m1.piao()
36 m1.sleep()
37 w1.get_birth()
多继承：
1 class People(object): #新式类 父类1
2 """类的继承,父类"""
3 def __init__(self,name,age):
4 self.Name = name #self.name = name
5 self.Age = age #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。
6
7 def eat(self):
8 print("%s is eating ..." % self.Name)
9
10 def sleep(self):
11 print("%s is sleeping ..." % self.Name)
12
13 def talk(self):
14 print("%s is talking ..." % self.Name)
15
16 class Relation(object): #父类2
17 def make_friend(self,obj):
18 print("%s is making friends with %s" %(self.Name,obj.Name))
19
20
21 class Man(People,Relation): #多继承 继承的顺序从左到右
22 def __init__(self,name,age,money): #对构造函数进行重构
23 #People.__init__(self,name,age)
24 super(Man,self).__init__(name,age) #新式类的写法
25
26 self.money = money
27 print("%s 一生下来就有钱。。。。" % self.Name)
28
29 def piao(self):
30 print("%s is piaoing ..." % self.Name)
31
32 def sleep(self): #重构父类的方法
33 People.sleep(self) #既执行父类的方法，又执行子类的方法
34 print("man is sleeping ...")
35
36 class Women(People,Relation):
37 def get_birth(self):
38 print("%s is born a baby" % self.Name)
39 m1 = Man("xiaolaizi",22,1000)
40 w1 = Women("xiaolizi",24)
41 m1.make_friend(w1)
执行结果：
xiaolaizi 一生下来就有钱。。。。
xiaolaizi is making friends with xiaolizi
那么问题来了，父类2 没有构造函数，怎么就传进去参数了呢？
那是因为我们已经在父类1继承了name,age 属性（哈哈哈）