闭包
Python函数是支持嵌套的。如果在一个内部函数中对外部函数作用域(非全局作用域)的变量进行引用,那么内部函数就会被称为闭包。闭包需要满足如下3个条件:
1.存在于两个嵌套关系的函数中,并且闭包是内部函数;
2.内部函数引用了外部函数的变量(自由变量);
3.外部函数会把内部函数的函数名称返回。
示例:
装饰器的概念
1、装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
2、装饰器是一个函数,它需要接收一个参数,该参数表示被修饰的函数。例如,有如下一个装饰器函数:
def w1(func):
print(‘正在装饰’)
def inner():
print(‘正在验证权限’)
return inner()
- 装饰器是个嵌套函数
- 内部函数是一个闭包。
- 外部函数接收的是被修饰的函数(func)
3、通过在函数定义的前面添加@符号和装饰器名,实现装饰器对函数的包装。给f1函数加上装饰器,示例如下:
@w1
def f1():
print(’f1')
此时,程序会自动编译生成调用装饰器函数的代码,等价于: f1 = w1(f1)
多个装饰器
多个装饰器应用在一个函数上,调用顺序是从下至上。
@w1
@w2
def f1():
print(‘---f1---’)
执行顺序:先执行@w2,后执行@w1
带参数的装饰器
假设我们前文的装饰器需要完成的功能不仅仅是能在进入某个函数后打出log信息,而且还需指定log的级别,那么装饰器就会是这样的。
def logging(level):
def wrapper(func):
def inner_wrapper(*args, **kwargs):
print "[{level}]: enter function {func}()".format(
level=level,
func=func.__name__)
return func(*args, **kwargs)
return inner_wrapper
return wrapper
@logging(level='INFO') def say(something):
print "say {}!".format(something)
# 如果没有使用@语法,等同于
# say = logging(level='INFO')(say)
@logging(level='DEBUG') def do(something):
print "do {}...".format(something)
if __name__ == '__main__':
say('hello')
do("my work")
- 当带参数的装饰器被打在某个函数上时,比如@logging(level=‘DEBUG’),它其实是一个函数,会马上被执行,只要这个它返回的结果是一个装饰器时,那就没问题。
基于类实现的装饰器
装饰器函数其实是这样一个接口约束,它必须接受一个callable对象作为参数,然后返回一个callable对象。在Python中一般callable对象都是函数,但也有例外。只要某个对象重载了__call__()方法,那么这个对象就是callable的。
class Test():
def __call__(self):
print 'call me!'
t = Test()
t() # call me
像__call__
这样前后都带下划线的方法在Python中被称为内置方法,有时候也被称为魔法方法。重载这些魔法方法一般会改变对象的内部行为。上面这个例子就让一个类对象拥有了被调用的行为。
回到装饰器上的概念上来,装饰器要求接受一个callable对象,并返回一个callable对象(不太严谨,详见后文)。那么用类来实现也是也可以的。我们可以让类的构造函数__init__()
接受一个函数,然后重载__call__()
并返回一个函数,也可以达到装饰器函数的效果。
class logging(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print "[DEBUG]: enter function {func}()".format(
func=self.func.__name__)
return self.func(*args, **kwargs)
@logging
def say(something):
print "say {}!".format(something)
带参数的类装饰器
如果需要通过类形式实现带参数的装饰器,那么会比前面的例子稍微复杂一点。那么在构造函数里接受的就不是一个函数,而是传入的参数。通过类把这些参数保存起来。然后在重载__call__方法是就需要接受一个函数并返回一个函数。
class logging(object):
def __init__(self, level='INFO'):
self.level = level
def __call__(self, func): # 接受函数
def wrapper(*args, **kwargs):
print "[{level}]: enter function {func}()".format(
level=self.level,
func=func.__name__)
func(*args, **kwargs)
return wrapper #返回函数
@logging(level='INFO')
def say(something):
print "say {}!".format(something)
内置的装饰器
内置的装饰器和普通的装饰器原理是一样的,只不过返回的不是函数,而是类对象。
在了解这个装饰器前,你需要知道在不使用装饰器怎么写一个属性。
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
# create a property
x = property(getx, setx, delx, "I am doc for x property")
以上就是一个Python属性的标准写法,其实和Java挺像的,但是太罗嗦。有了@语法糖,能达到一样的效果但看起来更简单。
@property
def x(self): ...
# 等同于
def x(self): ...
x = property(x)
带有返回值的装饰器
def func(functionName):
def func_in():
return functionName()
return func_in
@func def test():
return ‘itheima’