面向过程编程
顺序写代码，类似与简单的shell脚本，代码在逻辑上是从上到下顺序执行
函数式编程
函数用来实现功能，使用的时候直接调用函数即可，不需要重复编写代码
面向对象
将函数封装到类里面，相对来说更直观，代码也会简单一些，使用的时候根据类生成实例，调用方法、属性、字段即可
python也是支持OOP的一种开发语言，（Object Oriented Programming，OOP，面向对象程序设计），
面向对象变编程，抽象出类似事物的属性，然后可以更好的重用代码，降低了开发的难度，使编程
可以像搭积木一样完成
面向对象编程有几个很重要的特性优点：
封装
继承
多态 （在python中不做介绍，用处不大）
在说上面三个特性前，先来了解几个概念
1. 对象 和 类
什么是对象？我们平时见的书、人、办公桌、自行车等都可以称为对象，对象会有一些固定和非固定的部分，对象包括属性和行为，属性就是对象身上静态的部分，行为就是对象身上动态的部分。将一大类对象的属性和行为抽象出来，就有了类，所以类就是对象的属性和行为的封装后载体。
举个栗子：
有个笑话是：秋天你把老婆埋到土里，秋天你就会有好多个老婆，一个老婆洗衣，一个老婆做饭，一个老婆给你捶腿，一个老婆给你揉肩。
这些个老婆有些东西都是共同的，有些东西是不同的，比如说，她们都有发型，肤色，身高，体重等
有些东西时不同的，比如说洗衣服、做饭、捶腿、揉肩。
类的定义：
class wife():
def cook(self):
print "cooking"
def chicken(self,food):
print "cooking food is %s" % food
class 关键字
wife 类名称
self 必须写，指对象自身，即类实例化以后的对象
类的实例化
laopo01 = wife（） #实例化类wife，生成实例laopo01，也可以叫对象
laopo01.cook（） #执行 laopo01的cook方法
laopo01.chicken("宫保鸡丁") # 执行chicken方法
laopo02 = wife（） #实例化类wife，生成实例laopo02，也可以叫对象
laopo02.cook（） #执行 laopo02的cook方法
laopo02.chicken("宫保鸡丁") # 执行chicken方法类的封装：
封装的意思就是把事物共有的东西抽象出来，然后将抽象出来的东西打包到一起，就像上面的例子，老婆们都可以吃饭，走路，都有眼耳口鼻手，这些是共有的东西抽象后，封装到一起就是一个wife类。
class food(): def __init__(self,meat,efood): self.meat = meat # 封装字段 meat self.efood = efood # 封装字段 efood
def outp(self): print self.meat,self.efood # 调用字段的第一种方法 fo = food() fo.meat #调用字段的第二种方法 fo.efood
调用方法 第一种 类中内部调用，使用self直接调用封装在类中的字段 第二种 生成实例对象后调用，使用fo对象的 meat字段
类的继承：
继承就是，父与子的关系，子身上会有父身上的一些特性，他们也会有共同的一些东西，也有一些不同的东西。java和c# 部支持多继承， 但是python 是支持多继承的
简单例子： class dongwu: pass class cat(dongwu): pass class dog(dongwu): pass class ecat(cat,dongwu):
pass
类的多态 （可参考其他语言，python中作用不大,不做介绍）：
多态性就是上面的例子中，一个共有的wife类可以用来制作多个老婆，wife就是制造laopo时使用的一个模板。
python类中的特殊方法
__init__ 也叫构造方法，在初始化实例的时候会立即自动调用，并且这个方法没有返回值 obj= Foo() #执行 __init___ __call__ obj() # 执行__call__ __del__ 类似于析构函数， __dict__ 查看类或对象中的所有成员 __str__ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值 class Foo: def __str__(self): return 'wupeiqi' obj = Foo() print obj # 输出：wupeiqi
关于经典类和新式类
经典类和新式类的区别在于，新式类继承自 object，
经典类 class dongwu: pass 新式类（推荐使用） class dongwu（object）: pass
需要注意的一点：
在有相同继承管理的情况下，经典类和新式类的继承查找顺序不同
经典类 class A: pass class B（A）: pass class C（A）: pass class D(B,C): pass 在使用经典类的时候，在类D继承多个类的时候，如果被继承的类中有相同的方法，会按照深度优先的方法进行查找。 即：先在B中查找，再在A中查找，然后在C中查找 新式类 class A（object）: pass class B（A）: pass class C（A）: pass class D(B,C): pass 在使用新式类的时候，在类D继承多个类的时候，如果被继承的类中有相同的方法，会按照广度优先的方法进行查找。 即：先在B中查找，再在C中查找，然后在A中查找 当类是经典类时，多继承情况下，会按照深度优先方式查找 当类是新式类时，多继承情况下，会按照广度优先方式查找 经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
类成员
类有三种成员 方法、字段、属性，三种成员又可以细分：
类成员
1字段
a普通字段
b静态字段
2方法
a 普通方法
b 类方法
c静态方法
3属性
a普通属性
简单的例子来说明类成员的区别
class Foo(object):
static_filed = "static_field"
def __init__(self,name):
self.name=name # 字段
pass
def fun(self): #普通方法，可以加其他参数
print "fun"
pass
att_01 = property(fun) # 定义属性的另外一种方法
@classmethod
def cfun(cls): # 类方法 ,不能加其他参数
print cls ,"classmethod" #cls== class，含义是：类本身
pass
@staticmethod
def sfun(): #可以加其他参数
print "staticmethod"
pass
@property
def att(self): #属性，很少用
return "att"
pass
obj=Foo('aa')
print obj.name # 字段
obj.fun() # 方法
print obj.att # 属性
print obj.static_filed # 不建议使用该方式调用静态字段
print Foo.static_filed # 建议使用该方式调用静态字段
Foo.cfun() # 类方法
Foo.sfun() #可以加其他参数#属性和方法的区别
# 属性也是方法的一种；区别是属性前面有装饰器 @property ，调用的时候不用加括号
#普通方法 对象调用
#类方法 类调用，只能有一个参数，自动把当前类座位参数传递给方法 ，调用时 无需创建对象
#静态方法 类似与一个函数 调用时 无需创建对象
#属性的定义方法
#只适用与新式类的 属性的特性
class Foo(object): @property def att(self): #属性，很少用到 return "att" pass @att.setter def att(self,values): print "att.setter" @att.deleter def att(self,values): print "att.deleter"
成员修饰符
类成员分公有成员和私有成员
两者的区别是
私有成员开头以两个下划线开头，且不能被子类继承，外部无法调用，（有一种特殊情况可以调用，不推荐使用）
class Foo(object): pub = "public" #公有成员 , __priv = "private" # 私有成员,前面多了两个下划线，外部无法调用 def foo(self): print self.__priv # 调用私有字段 print "pub fun" def __foo(self): #私有方法，外部无法调用， print "private fun" def show(self): print self.__foo() #调用私有方法 aa = Foo() print Foo.__priv print aa.priv print aa._Foo__priv #特殊方法，不建议使用 _classname__var
参考 http://www.cnblogs.com/wupeiqi/p/4493506.html
http://www.timesnotes.com/?p=126
http://timesnotes.blog.51cto.com/1079212/1719752
