面向过程编程

顺序写代码&＃xff0c;类似与简单的shell脚本&＃xff0c;代码在逻辑上是从上到下顺序执行


函数式编程

函数用来实现功能&＃xff0c;使用的时候直接调用函数即可&＃xff0c;不需要重复编写代码
面向对象

将函数封装到类里面&＃xff0c;相对来说更直观&＃xff0c;代码也会简单一些&＃xff0c;使用的时候根据类生成实例&＃xff0c;调用方法、属性、字段即可


python也是支持OOP的一种开发语言&＃xff0c;&＃xff08;Object Oriented Programming&＃xff0c;OOP&＃xff0c;面向对象程序设计&＃xff09;&＃xff0c;
面向对象变编程&＃xff0c;抽象出类似事物的属性&＃xff0c;然后可以更好的重用代码&＃xff0c;降低了开发的难度&＃xff0c;使编程
可以像搭积木一样完成
面向对象编程有几个很重要的特性优点&＃xff1a;
封装
继承
多态 &＃xff08;在python中不做介绍&＃xff0c;用处不大&＃xff09;


在说上面三个特性前&＃xff0c;先来了解几个概念
1. 对象 和 类
什么是对象&＃xff1f;我们平时见的书、人、办公桌、自行车等都可以称为对象&＃xff0c;对象会有一些固定和非固定的部分&＃xff0c;对象包括属性和行为&＃xff0c;属性就是对象身上静态的部分&＃xff0c;行为就是对象身上动态的部分。将一大类对象的属性和行为抽象出来&＃xff0c;就有了类&＃xff0c;所以类就是对象的属性和行为的封装后载体。
举个栗子&＃xff1a;
有个笑话是&＃xff1a;秋天你把老婆埋到土里&＃xff0c;秋天你就会有好多个老婆&＃xff0c;一个老婆洗衣&＃xff0c;一个老婆做饭&＃xff0c;一个老婆给你捶腿&＃xff0c;一个老婆给你揉肩。
这些个老婆有些东西都是共同的&＃xff0c;有些东西是不同的&＃xff0c;比如说&＃xff0c;她们都有发型&＃xff0c;肤色&＃xff0c;身高&＃xff0c;体重等
有些东西时不同的&＃xff0c;比如说洗衣服、做饭、捶腿、揉肩。

类的定义&＃xff1a;

class wife():def cook(self):print "cooking"def chicken(self,food):print "cooking food is %s" % foodclass 关键字
wife  类名称
self  必须写&＃xff0c;指对象自身&＃xff0c;即类实例化以后的对象类的实例化laopo01 &＃61; wife&＃xff08;&＃xff09;  #实例化类wife&＃xff0c;生成实例laopo01&＃xff0c;也可以叫对象
laopo01.cook&＃xff08;&＃xff09;    #执行 laopo01的cook方法
laopo01.chicken("宫保鸡丁")  # 执行chicken方法laopo02 &＃61; wife&＃xff08;&＃xff09;  #实例化类wife&＃xff0c;生成实例laopo02&＃xff0c;也可以叫对象
laopo02.cook&＃xff08;&＃xff09;    #执行 laopo02的cook方法
laopo02.chicken("宫保鸡丁")  # 执行chicken方法


类的封装&＃xff1a;
封装的意思就是把事物共有的东西抽象出来&＃xff0c;然后将抽象出来的东西打包到一起&＃xff0c;就像上面的例子&＃xff0c;老婆们都可以吃饭&＃xff0c;走路&＃xff0c;都有眼耳口鼻手&＃xff0c;这些是共有的东西抽象后&＃xff0c;封装到一起就是一个wife类。


class food():def __init__(self,meat,efood):self.meat &＃61; meat     # 封装字段 meatself.efood &＃61; efood   #  封装字段 efood

    def outp(self):print self.meat,self.efood   # 调用字段的第一种方法fo &＃61; food()
fo.meat     #调用字段的第二种方法
fo.efood

调用方法
第一种   类中内部调用&＃xff0c;使用self直接调用封装在类中的字段
第二种   生成实例对象后调用&＃xff0c;使用fo对象的 meat字段

类的继承&＃xff1a;
继承就是&＃xff0c;父与子的关系&＃xff0c;子身上会有父身上的一些特性&＃xff0c;他们也会有共同的一些东西&＃xff0c;也有一些不同的东西。java和c# 部支持多继承&＃xff0c; 但是python 是支持多继承的

简单例子&＃xff1a;
class dongwu:passclass cat(dongwu):passclass dog(dongwu):passclass ecat(cat,dongwu):

    pass


类的多态 &＃xff08;可参考其他语言&＃xff0c;python中作用不大,不做介绍&＃xff09;&＃xff1a;
多态性就是上面的例子中&＃xff0c;一个共有的wife类可以用来制作多个老婆&＃xff0c;wife就是制造laopo时使用的一个模板。



python类中的特殊方法

__init__也叫构造方法&＃xff0c;在初始化实例的时候会立即自动调用&＃xff0c;并且这个方法没有返回值obj&＃61; Foo() #执行 __init_____call__obj()      # 执行__call____del__类似于析构函数&＃xff0c;__dict__查看类或对象中的所有成员__str__如果一个类中定义了__str__方法&＃xff0c;那么在打印 对象 时&＃xff0c;默认输出该方法的返回值class Foo:def __str__(self):return &＃39;wupeiqi&＃39;obj &＃61; Foo()print obj# 输出&＃xff1a;wupeiqi



关于经典类和新式类

经典类和新式类的区别在于&＃xff0c;新式类继承自 object&＃xff0c;

经典类
class dongwu:pass新式类&＃xff08;推荐使用&＃xff09;
class dongwu&＃xff08;object&＃xff09;:pass

需要注意的一点&＃xff1a;

在有相同继承管理的情况下&＃xff0c;经典类和新式类的继承查找顺序不同

经典类
class A:pass
class B&＃xff08;A&＃xff09;:pass
class C&＃xff08;A&＃xff09;:pass
class D(B,C):pass在使用经典类的时候&＃xff0c;在类D继承多个类的时候&＃xff0c;如果被继承的类中有相同的方法&＃xff0c;会按照深度优先的方法进行查找。
即&＃xff1a;先在B中查找&＃xff0c;再在A中查找&＃xff0c;然后在C中查找新式类
class A&＃xff08;object&＃xff09;:pass
class B&＃xff08;A&＃xff09;:pass
class C&＃xff08;A&＃xff09;:pass
class D(B,C):pass
在使用新式类的时候&＃xff0c;在类D继承多个类的时候&＃xff0c;如果被继承的类中有相同的方法&＃xff0c;会按照广度优先的方法进行查找。
即&＃xff1a;先在B中查找&＃xff0c;再在C中查找&＃xff0c;然后在A中查找当类是经典类时&＃xff0c;多继承情况下&＃xff0c;会按照深度优先方式查找当类是新式类时&＃xff0c;多继承情况下&＃xff0c;会按照广度优先方式查找
经典类和新式类&＃xff0c;从字面上可以看出一个老一个新&＃xff0c;新的必然包含了跟多的功能&＃xff0c;也是之后推荐的写法&＃xff0c;从写法上区分的话&＃xff0c;如果 当前类或者父类继承了object类&＃xff0c;那么该类便是新式类&＃xff0c;否则便是经典类。



类成员

类有三种成员 方法、字段、属性&＃xff0c;三种成员又可以细分&＃xff1a;

类成员
    1字段
            a普通字段
             b静态字段
    2方法
            a 普通方法
            b 类方法
             c静态方法
    3属性
            a普通属性


简单的例子来说明类成员的区别

class Foo(object):static_filed &＃61; "static_field"def __init__(self,name):self.name&＃61;name           # 字段passdef fun(self):              #普通方法&＃xff0c;可以加其他参数print "fun"passatt_01 &＃61; property(fun)    # 定义属性的另外一种方法&＃64;classmethoddef cfun(cls):              # 类方法 ,不能加其他参数print cls ,"classmethod"  #cls&＃61;&＃61; class&＃xff0c;含义是&＃xff1a;类本身pass&＃64;staticmethoddef sfun():                 #可以加其他参数print "staticmethod"pass&＃64;propertydef att(self):              #属性&＃xff0c;很少用return "att"passobj&＃61;Foo(&＃39;aa&＃39;)
print obj.name  # 字段
obj.fun() # 方法
print obj.att   # 属性
print obj.static_filed  # 不建议使用该方式调用静态字段
print  Foo.static_filed  # 建议使用该方式调用静态字段
Foo.cfun()      # 类方法
Foo.sfun()      #可以加其他参数

#属性和方法的区别
# 属性也是方法的一种&＃xff1b;区别是属性前面有装饰器 &＃64;property &＃xff0c;调用的时候不用加括号
#普通方法 对象调用
#类方法 类调用&＃xff0c;只能有一个参数&＃xff0c;自动把当前类座位参数传递给方法 &＃xff0c;调用时 无需创建对象
#静态方法 类似与一个函数 调用时 无需创建对象

#属性的定义方法

#只适用与新式类的 属性的特性

class Foo(object):&＃64;propertydef att(self):              #属性&＃xff0c;很少用到return "att"pass&＃64;att.setterdef att(self,values):print "att.setter"&＃64;att.deleterdef att(self,values):print "att.deleter"



成员修饰符

类成员分公有成员和私有成员

两者的区别是

私有成员开头以两个下划线开头&＃xff0c;且不能被子类继承&＃xff0c;外部无法调用&＃xff0c;&＃xff08;有一种特殊情况可以调用&＃xff0c;不推荐使用&＃xff09;

class Foo(object):pub &＃61; "public"      #公有成员  ,__priv &＃61; "private"  # 私有成员,前面多了两个下划线&＃xff0c;外部无法调用def foo(self):print self.__priv  # 调用私有字段print "pub fun"def __foo(self):        #私有方法&＃xff0c;外部无法调用&＃xff0c;print "private fun"def show(self):print self.__foo()  #调用私有方法aa &＃61; Foo()
print Foo.__priv
print aa.privprint aa._Foo__priv   #特殊方法&＃xff0c;不建议使用 _classname__var


参考 http://www.cnblogs.com/wupeiqi/p/4493506.html

http://www.timesnotes.com/?p&＃61;126

http://timesnotes.blog.51cto.com/1079212/1719752