概述
面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...”
类的定义
类定义，像函数定义一样，在执行时才会起作用。你可以把类定义放在任何地方比如if语句的分支，或者在函数内部。 在实际应用时，定义在类中的语句通常都是函数定义，但是其它语句也是允许出现的，并且有的时候非常有用。 当进入一个类定义时，一个新的名称空间被创建，并且被当作局部域来使用。
类的书写格式
关键字为：class
创建对象，类名称后加括号即可
注：执行方法必须是 obj = foo() 创建一个对象 再用对象执行内方法，如：ret = obj.start()
class line: def __init__(self, data):#构造方法 try: p = int(data) except Exception as e: p = 1 self.p = int(p) def start(self):#方法 ret = (self.p - 1) * 10 return ret def end(self):#方法 ret = self.p * 10 return ret
特殊方法*
构造方法
__init__，默认对象调用类的时候，会执行init方法，创建基础值，
class game: foo = 100#字段 blue = 100 sjjy = 100 money = 0 def __init__(self, name, sex="男"):#创建基础信息 ''' 构造方法 创建人物信息 :param name: :param sex: ''' self.name = name # 昵名 self.sex = sex # 性别 self.leves = 1 # 等级 self.gjl = 10 # 攻击力 self.foo = 100 # 血 self.foosj = 100 # 升级后的最大血量 self.blue = 100 # 蓝 self.bluesj = 100 # 升级后最大蓝量 self.jinyan = 0 # 当前经验值 self.sjjy = 100 # 升级所需要的经验 self.money = 0 # 用户金额#本段代码来自 海瑞博客http://www.hairuinet.com/post/44.html
注：obj = 类（）就会执行构造方法
三大特性
1.封装
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：将内容封装到某处，使用时从某处调用被封装的内容
直接调用案例：
class foo: def __init__(self,name,age,sex="男"): self.name = name self.age = age self.sex = sexobj1 = foo("hairui",25)#执行时，self 就是obj1obj2 = foo("zjw",20)#执行时，self 就是obj2print("obj1的姓名：%s,年龄:%s,性别：%s"%(obj1.name,obj1.age,obj1.sex))print("obj2的姓名：%s,年龄:%s,性别：%s"%(obj2.name,obj2.age,obj2.sex))#obj1的姓名：hairui,年龄:25,性别：男#obj2的姓名：zjw,年龄:20,性别：男 class foo: def __init__(self,name,age,sex="男"): self.name = name self.age = age self.sex = sex def show(self): print("%s的姓名：%s,年龄:%s,性别：%s"%(self,self.name,self.age,self.sex))obj1 = foo("hairui",25)#执行时，self 就是obj1obj2 = foo("zjw",20)#执行时，self 就是obj2obj1.show()obj2.show()# <__main__.foo object at 0x102185320>的姓名：hairui,年龄:25,性别：男# <__main__.foo object at 0x102185358>的姓名：zjw,年龄:20,性别：男 综上所述，对于封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。
2.继承
1.继承父类，子承父业
案例：
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
class zoon: def eat(self): print("%s吃粮" % self.name) def drink(self): print("%s喝水" % self.name) def la(self): print("%s拉set" % self.name) def sha(self): print("%s潵野" % self.name)class cat(zoon): def __init__(self,name): self.name = name def cry(self): print("%s喵喵叫" % self.name)class dog(zoon): def __init__(self,name): self.name = name def cry(self): print("%s汪汪叫" % self.name)cat1 = cat("二黑")cat1.drink()cat1.cry()dog1 = dog("旺旺")dog1.drink()dog1.cry() 所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。
2.重写
class f: def f1(self): print("i am f1") def f2(self): print("i am f2") class s(f):#继承 def s1(self): print("i am s1") def f2(self):#重写父类方法 super(s,self).f2()#推荐使用。使用父类的方法 print("i am s.f2") f.f2(self)#使用父类的方法 obj = s() obj.s1() obj.f2() super(派生类,self).基类方法(）派生类方法中使用基类方法，推荐使用，可读性强
基类.基类方法(派生类的self) 同上，不推荐使用
3.多继承
Python的类可以继承多个类，Java和C#中则只能继承一个类
Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找
经典类
class D: def bar(self): print 'D.bar'class C(D): def bar(self): print 'C.bar'class B(D): def bar(self): print 'B.bar'class A(B, C): def bar(self): print 'A.bar'a = A()# 执行bar方法时# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错# 所以，查找顺序：A --> B --> D --> C# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了a.bar()经典类多继承
新式类
class D(object): def bar(self): print 'D.bar'class C(D): def bar(self): print 'C.bar'class B(D): def bar(self): print 'B.bar'class A(B, C): def bar(self): print 'A.bar'a = A()# 执行bar方法时# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错# 所以，查找顺序：A --> B --> C --> D# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了a.bar()新式类多继承
3.多态
Python 原生就是多态，无须关注过多
崇尚鸭子类型
class F1: passclass S1(F1): def show(self): print 'S1.show'class S2(F1): def show(self): print 'S2.show'def Func(obj): print obj.show()s1_obj = S1()Func(s1_obj) s2_obj = S2()Func(s2_obj) Python “鸭子类型”