Python 装饰器
1. 闭包(closure)
- 闭包是函数式编程的重要语法结构;
- 如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包;
# 示例一:
def test():
print("=== in test func ===")
# 调用函数
test()
# 引用函数, 直接书写函数名,表示引用函数;
# 在 ipython 中运行 test,会输出: <function __main__.test>
ret = test
print(id(ret))
print(id(test))
ret()
# 运行结果:
=== in test func ===
4409211080
4409211080
=== in test func ===
# 示例二: 闭包定义
# 定义一个函数
def test1(number):
# 在函数内部再定义一个函数,并且这个函数用到了外部函数(test1)的变量(number),
# 那么将这个函数以及用到的一些变量称之为闭包
def test_in(number_in):
print("in test_in 函数, number_in is %d" % number_in)
return number + number_in
# 其实,这里返回的就是闭包的结果
return test_in
# 给 test1 函数赋值,这个20就是给参数 number
# 此时, ret 指向 test_in, 也就是说, ret = test_in, number = 20
ret = test1(20)
# 注意,这里的100,其实是给参数 number_in
print(ret(100)) # 输出 120
#注意这里的200,其实是给参数 number_in
print(ret(200)) # 输出 220
2. 装饰器
# 示例一:
def foo():
print('foo')
foo # 表示是函数
foo() # 表示执行foo函数
# 示例二:
def foo():
print('foo')
foo = lambda x:x + 1
foo() # 执行下面的lambda表达式,而不再是原来的foo函数,因为foo这个名字被重新指向了另外一个匿名函数
# 示例三:装饰器之前代码
# 需求: 一个基础平台部门,负责提供底层的功能,如数据库操作,redis调用,监控API等功能
# 其他业务部门使用基础功能时,只需调用基础平台提供的功能即可;
========== 基础平台提供的功能 ===========
def f1():
print("f1")
def f2():
print("f2")
def f3():
print("f3")
def f4():
print("f4")
=========== 业务部门A 调用基础功能 ==========
f1()
f2()
f3()
f4()
========== 业务部门B 调用基础功能 ==========
f1()
f2()
f3()
f4()
# 示例四:装饰器
# 需求: 执行基础功能之前,需要先进行验证
# 写代码的开放封闭原则:
# 封闭: 已实现的功能代码块
# 开放: 对扩展开放
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
func()
return inner
# @w1 等价于 f1 = w1(f1), 此时, f1 指向 (inner 指向的函数体)
# 调用方,继续为 f1(),函数名不需要做修改(此处,为闭包)
@w1
def f1():
print('f1')
@w1
def f2():
print('f2')
@w1
def f3():
print('f3')
@w1
def f4():
print('f4')
# 示例五: 装饰器扩展
def makeBold(fn):
print("=== bold ===")
def wrapped():
print("=== 1 ===")
return "<b>" + fn() + "</b>"
return wrapped
def makeItalic(fn):
print("=== italic ===")
def wrapped():
print("=== 2 ===")
return "<i>" + fn() + "</i>"
return wrapped
@makeBold
@makeItalic
def test1():
print("=== 3 ===")
return "Hello world!"
print(test1())
# 输出:
# (前面两句,不调用test1()函数也会输出)
# === italic ===
# === bold ===
# === 1 ===
# === 2 ===
# === 3 ===
# <b><i>Hello world!</i></b>
# 示例六: 装饰器什么时间执行
def w1(func):
print("=== 正在装饰 ===")
def inner():
print("=== 正在验证权限 ===")
func()
return inner
# 只要Python 解释器执行到 @w1 这行代码,那么就会自动的进行装饰,
# 而不是等到调用f1()的时候才装饰
# 控制台会输出: === 正在装饰 ===
@w1
def f1():
print("=== f1 ===")
# 示例七: 被装饰的函数带有参数
def w1(func):
def inner(x, y): # 如果x,y没有定义,那么会导致f1(22, 33)调用失败
# 验证1
func(x, y) # 如果没有把x, y当做实参进行传递,那么,会导致调用f1(a, b)失败
return inner
@w1
def f1(a, b):
print('a = %d, b = %d' % (a, b))
f1(22, 33)
# 示例八: 被装饰的函数带有不定长参数
def w1(func):
def inner(*args, **kwargs):
# 验证1
func(*args, **kwargs)
return inner
@w1
def f2(a, b, c):
print('a = %d, b = %d, c = %d' % (a, b, c))
@w1
def f3(a, b, c, d):
print('a = %d, b = %d, c = %d, d = %d' % (a, b, c, d))
f2(11, 22, 33)
f3(11, 22, 33, 44)
# 示例九: 对带有返回值的函数装饰
def w1(func):
def inner():
print("=== 执行前 ===")
result = func()
print("=== 执行后 ===")
return result
return inner
@w1
def f1():
print("=== 功能代码 ===")
return "zhangsan"
name = f1()
print("查询到的姓名: %s" % name)
# 示例十: 通用装饰器((不)带参数,(不)带返回值)
def w1(func):
def inner(*args, **kwargs):
print("=== 执行前 ===")
result = func(*args, **kwargs)
print("=== 执行后 ===")
return result
return inner
@w1
def f1():
print("=== 功能代码 ===")
return "haha"
@w1
def f1(a):
print("=== 功能代码 ===")
print("输入的字符为: %s" % a)
# 示例十一: 装饰器带参数,在原有装饰器的基础上,设置外部变量
from time import ctime, sleep
def timefun_arg(pre="hello"):
def timefun(func):
def wrappedfunc():
print("%s called at %s %s" % (func.__name__, ctime(), pre))
return func()
return wrappedfunc
return timefun
@timefun_arg("noodles")
def foo():
print("I am Noodles")
@timefun_arg("google")
def too():
print("I am google")
foo()
sleep(2)
too()
# 输出:
foo called at Sat Mar 10 17:56:06 2018 noodles
I am Noodles
too called at Sat Mar 10 17:56:08 2018 google
I am google
# 备注:
# 1. 先执行timefun_arg("noodles")函数, 这个函数返回的结果是 timefun 函数的引用
# 2. @timefun
# 3. 使用 @timefun 对 foo 进行装饰
2.1 类装饰器
- 装饰器函数其实是这样一个接口约束,它必须接受一个callable对象作为参数,然后返回一个callable对象。
- 在Python中一般callable对象都是函数,但也有例外,只要某个对象重写了
__call__()方法,那么这个
对象就是callable的;
# 示例一: callable
class Test():
def __call__(self):
print("call me!")
t = Test()
t()
# 输出: call me!
# 对象(),会调用 __call__ 方法
# 示例: 类装饰器
class Test(object):
def __init__(self, func):
print("=== 初始化 ===")
print("func name is %s" % func.__name__)
self.__func = func
def __call__(self):
print("=== 装饰器中的功能 ===")
self.__func()
# 说明:
# 1, 当有Test来装作装饰器对test函数进行装饰的时候,首先会创建Test的实例对象,并且会把test这个函数
# 名当做参数传递到 __init__ 方法中;
#
# 2, test函数相当于指向了用Test创建出来的实例对象;
#
# 3, 当在使用test()进行调用时,就相当于让这个对象(),因此会调用这个对象的 __call__ 方法;
#
# 4. 为了能够在__call__ 方法中调用原来test指向的函数体,所以在__init__方法中就需要一个实例属性来保存
# 所以才有了 self.__func = func 这句代码,从而在调用 __call__ 方法中能够调用到test之前的函数体
@Test
def test():
print("=== test ===")
test()
参考资料:
