1、装饰器执行流程

装饰器可用于权限管理；

装饰器：将原函数替换为wrapper函数

def outer()
@outer  --- func1作为参数传入outer()
def wrapper()  --- wrapper()放入内存
return wrapper   --- 返回wrapper地址，Func1重新赋值为wrapper
Func1()  --- 调用func1函数
def wrapper()
print '验证'
def Func1()
print 'func1'

[root@localhost decorate]# python main.py
验证
func1
验证
func2
[root@localhost decorate]# cat main.py
#!/usr/bin/python27
#coding:utf-8def outer(fun):def wrapper():print '验证'fun()return wrapper@outer
def Func1():print 'func1'@outer
def Func2():print 'func2''''
Func1=
def wrapper():print '验证'fun()
'''Func1()
Func2()
[root@localhost decorate]#

带参数的装饰器

[root@localhost decorate]# python27 main1.py
验证
func1 alex
[root@localhost decorate]# cat main1.py
#!/usr/bin/python27
#coding:utf-8def outer(fun):def wrapper(arg):print '验证'fun(arg)return wrapper@outer
def Func1(arg):print 'func1',arg'''
Func1=
def wrapper(arg):print '验证'fun(arg)
'''Func1('alex')
[root@localhost decorate]#

在函数执行的前后，执行任意函数

def Filter(before_func,after_func): def outer(main_func):def wrapper(request,kargs): before_result = before_func(request,kargs)if(before_result != None): return before_result;main_result = main_func(request,kargs)if(main_result != None):return main_result;after_result = after_func(request,kargs)if(after_result != None):return after_result;return wrapperreturn outer @Filter(AccountFilter.Before, AccountFilter.After) def List(request,kargs):pass

2、类与对象

封装性：将name,age属性封装到self中

内存图

类的内存：                               对象的内存

|                                                 |

静态字段                            动态字段：self.name

动态方法、静态方法   --->引用      方法

[root@localhost ~]# python27 index.py
cxiong 29
xmzhang 28
中国
[root@localhost ~]# cat index.py
#!/usr/bin/python27
#coding:utf-8

class Person():
    nation='中国'    --- 静态字段：nation只属于class，静态字段只有一份，对象内存中不存在；
    def __init__(self,name,age):
        self.name=name  --- 动态字段：self.name属于对象
        self.age=age    ---动态字段：self.age属于对象

p1=Person('cxiong',29)
p2=Person('xmzhang',28)
print p1.name,p1.age
print p2.name,p2.age
print p1.nation
[root@localhost ~]#

注意：类不能访问动态字段；对象可以访问静态字段

静态字段、动态字段、静态方法、动态方法和装饰器

作用：提供统一的方法和数据，用于处理类的请求

[root@localhost ~]# cat index.py
#!/usr/bin/python27
#coding:utf-8class Person():#静态字段nation='中国'def __init__(self,name,age):#动态字段self.name=nameself.age=age#动态方法    def Eat(self):print self.name+' eating...'#静态方法  --- 不需要实例化类，即可调用方法@staticmethoddef Breath():print 'breathing...'#装饰器 --- 将方法访问形式作为字段形式访问@propertydef Sing(self):print self.name+' singing...'p1=Person('cxiong',29)
p2=Person('xmzhang',28)print p1.name,p1.age
print p2.name,p2.age
print p1.nation
p1.Eat()
p2.Eat()
Person.Breath()
p1.Sing

__dict__与dir()的区别

print m1.__dict__   ---类所有字段
{'_Person__gender': 'male', 'age': 29, '_man__gender': 'male', 'name': 'cxiong'}print dir(m1)   --- 类所有的方法及字段
['Breath', 'Eat', 'ShowGender', 'Sing', '_Person__gender', '__call__', '__class__', '__del__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_man__gender', 'age', 'name', 'nation', 'work']

3、面向对象与函数式编程的区别

静态方法与模块形式的区别：内存上没区别，区别在于，静态方法逻辑上属于类；

静态方法是面向对象语言解决对象重复构造方法时产生的，python模块化语言也可以解决；

多态：将相似的方法包装在同一个模块中；

python支持模块化编程，也支持反射；等同于面向对象编程java、.net

面向对象：可以创建模板

4、私有字段和私有方法

作用：安全

[root@localhost ~]# python index1.py
male
[root@localhost ~]# cat index1.py
#!/usr/bin/python27
#coding:utf-8class Person():#静态字段nation='中国'def __init__(self,name,age,gender):#动态字段self.name=nameself.age=age#私有字段self.__gender=gender#动态方法    def Eat(self):print self.name+' eating...'#静态方法@staticmethoddef Breath():print 'breathing...'#装饰器 @propertydef Sing(self):print self.name+' singing...'@property --- 私有字段不能被外部访问，但是可以使用方法访问def ShowGender(self):return self.__genderp1=Person('cxiong',29,'male')
p2=Person('xmzhang',28,'female')
print p1.ShowGender

只读私有字段和可改写私有字段

[root@localhost ~]# cat index1.py
#!/usr/bin/python27
#coding:utf-8class Person():   --- 没有继承object是可读可写；继承了object一个是可读，一个是可写#静态字段nation='中国'def __init__(self,name,age,gender):   --- 构造函数#动态字段self.name=nameself.age=age#私有字段self.__gender=gender#动态方法    def Eat(self):print self.name+' eating...'#静态方法@staticmethoddef Breath():print 'breathing...'#装饰器 @propertydef Sing(self):print self.name+' singing...'#只读私有字段@propertydef ShowGender(self):return self.__gender#可改私有字段@ShowGender.setterdef ShowGender(self,value):self.__gender=valuep1=Person('cxiong',29,'male')
p2=Person('xmzhang',28,'female')
print p1.ShowGender
p1.ShowGender='female'
print p1.ShowGender

5、析构函数及__call__方法

[root@localhost ~]# python index1.py
male
female
解释器要销毁person了...
解释器要销毁person了...
[root@localhost ~]# cat index1.py
#!/usr/bin/python27
#coding:utf-8class Person(object):#静态字段nation='中国'#构造函数def __init__(self,name,age,gender):#动态字段self.name=nameself.age=age#私有字段self.__gender=gender#析构函数，用于销毁对象时使用；一般不使用，常用于操作文件def __del__(self):print '解释器要销毁person了...'def __call__(self):print 'call'#动态方法    def Eat(self):print self.name+' eating...'#静态方法@staticmethoddef Breath():print 'breathing...'#装饰器 @propertydef Sing(self):print self.name+' singing...'#只读私有字段，property常用于私有字段@propertydef ShowGender(self):return self.__gender#可改私有字段@ShowGender.setterdef ShowGender(self,value):self.__gender=valuep1=Person('cxiong',29,'male')
p2=Person('xmzhang',28,'female')
print p1.ShowGender
p1.ShowGender='female'
print p1.ShowGender
p1()  #执行__call__方法[root@localhost ~]# python index1.py
male
female
call
解释器要销毁person了...
解释器要销毁person了...

6、继承

[root@localhost ~]# python index1.py
work hard...
cxiong singing...
breathing...
解释器要销毁person了...
[root@localhost ~]# cat index1.py
#!/usr/bin/python27
#coding:utf-8class Person(object):#静态字段nation='中国'#构造函数def __init__(self,name,age,gender):#动态字段self.name=nameself.age=age#私有字段self.__gender=gender#析构函数def __del__(self):print '解释器要销毁person了...'#动态方法    def Eat(self):print self.name+' eating...'#def __call__(self):print 'call'#静态方法@staticmethoddef Breath():print 'breathing...'#装饰器 @propertydef Sing(self):print self.name+' singing...'#只读私有字段@propertydef ShowGender(self):return self.__gender#可改私有字段@ShowGender.setterdef ShowGender(self,value):self.__gender=value#man继承Person类，私有方法__gender无法继承
class man(Person):#重写__init__方法def __init__(self):self.name='cxiong'self.__gender='male'#新增work方法def work(self):print 'work hard...'m1=man()
m1.work()
m1.Sing
m1.Breath()

7、新式类与经典类的区别

新式类：继承object，字段为只读和可写两种；

经典类：不继承object，字段均为读写

使用新式类的原因：经典类存在多继承bug，深度优先，而非广度优先，请参考以下内容

https://docs.python.org/release/2.2.3/whatsnew/sect-rellinks.html

[root@localhost ~]# cat index1.py
#!/usr/bin/python27
#coding:utf-8class Person(object):#静态字段，Person.nation获取nation='中国'#构造函数def __init__(self,name,age,gender):#动态字段self.name=nameself.age=age#私有字段self.__gender=genderprint 'person init...'#析构函数def __del__(self):print '解释器要销毁person了...'#动态方法    def Eat(self):print self.name+' eating...'#def __call__(self):print 'call'#静态方法@staticmethoddef Breath():print 'breathing...'#装饰器 @propertydef Sing(self):print self.name+' singing...'#只读私有字段@propertydef ShowGender(self):return self.__gender#可改私有字段@ShowGender.setterdef ShowGender(self,value):self.__gender=value#man继承Person类
class man(Person):#重写__init__方法def __init__(self):self.name='cxiong'self.__gender='male'print 'man init...'#调用父类的init方法1Person.__init__(self,'cxiong',29,'male')#调用父类的init方法2super(man,self).__init__('cxiong',29,'male')#新增work方法def work(self):print 'work hard...'m1=man()
m1.work()
m1.Sing
m1.Breath()[root@localhost ~]# python index1.py
man init...
person init...
person init...
work hard...
cxiong singing...
breathing...
解释器要销毁person了...
[root@localhost ~]#

8、多继承

python特有的特性

[root@localhost ~]# python multiple.py
this is D
save method from --A--
[root@localhost ~]# cat multiple.py
#!/usr/bin/python27
#coding:utf-8class A:def __init__(self):print 'this is A'def save(self):print 'save method from --A--'class B(A):def __init__(self):print 'this is B'class C(A):def __init__(self):print 'this is C'def save(self):print 'save method from --C--'class D(B,C):def __init__(self):print 'this is D'c=D()
c.save()
[root@localhost ~]# vim multiple.py
[root@localhost ~]# python multiple.py
this is D
save method from --C--
[root@localhost ~]# cat multiple.py
#!/usr/bin/python27
#coding:utf-8class A(object):def __init__(self):print 'this is A'def save(self):print 'save method from --A--'class B(A):def __init__(self):print 'this is B'class C(A):def __init__(self):print 'this is C'def save(self):print 'save method from --C--'class D(B,C):def __init__(self):print 'this is D'c=D()
c.save()
[root@localhost ~]#

9、接口

规范：抽象类+抽象方法=接口

from abc import ABCMeta, abstractmethod
class Bar:__metaclass__ = ABCMeta  @abstractmethod    def Fun(self):passclass Foo(Bar):    def __init__(self):print '__init__'Foo()