Python装饰器原理与实战：从闭包到多层装饰器

理解装饰器的基础：作用域与函数特性

要掌握装饰器，首先需要理解Python的作用域机制与函数的“一等公民”特性。Python的作用域分为全局和局部两种：全局变量定义在文件级别，而局部变量定义在函数内部。作用域之间存在访问限制，全局作用域无法直接访问局部变量，但局部作用域可以访问全局变量。若局部作用域尝试直接修改全局变量，会引发错误；当局部未定义变量时，Python会向外层作用域查找，若外层也未找到，则抛出异常。

在函数层面，函数名本质上指向内存空间的地址。这使得函数名可以作为值传递、作为返回值，或者作为参数传递给其他函数。只要满足上述任一条件，该函数即可被视为高级函数。这是实现装饰器“传入被装饰函数名，内部返回装饰函数名”且不修改源代码与调用方式的基础。

闭包的形成条件

装饰器的核心是闭包（Closure）。闭包由函数及其引用的外部环境组成，具有自带作用域和延迟计算的特点。并非所有包含内部函数的结构都是闭包，必须同时满足两个条件：

1. 内部定义了函数。
2. 内部函数引用了非全局的外部作用域变量。

如果仅定义内部函数而不引用外部变量，或者仅引用全局变量，均不构成闭包。以下代码展示了闭包的典型结构：

def outer():
  x = 1
  def inner():
    print("x=%s" %x)
    print("inner func excuted")
  print("outer func excuted")
  return inner # 返回内部函数名

outer()

执行上述代码，将输出内部函数的执行结果，并返回内部函数的内存地址。通过查看 inner.__closure__，可以确认闭包中保存的外部变量单元格：

def outer():
  x = 1
  y = 2
  def inner():
    print("x= %s" %x)
    print("y= %s" %y)
  print(inner.__closure__)
  return inner

outer()

输出结果将显示指向整数对象的单元格地址，证明闭包成功捕获了外部变量。

无参装饰器：计算执行时间

最简单的装饰器用于计算函数的执行时间。其核心逻辑是：在内部函数中记录开始与结束时间，调用原函数，并打印耗时。以下是一个无参装饰器的实现：

import time, random

def outer(func): # 将index的地址传递给func
  def inner():
    start_time = time.time()
    func()  # func保存了外部index函数的地址
    end_time = time.time()
    print("运行时间为%s"%(end_time - start_time))
  return inner # 返回inner的地址

def index():
  time.sleep(random.randrange(1, 5))
  print("welcome to index page")

index = outer(index) # 语法糖等效操作：将inner地址重新赋值给index
index()

虽然上述代码实现了功能，但原函数若带有参数，该装饰器将无法适用。因此，需要引入 *args 和 **kwargs 来处理变参数函数。

有参装饰器：保留返回值与处理参数

一个完善的装饰器应当保留被装饰函数的返回值，并支持任意参数。以下是带有计时功能的有参装饰器示例：

def timmer(func):
  def wrapper(*args,**kwargs):
    start_time = time.time()
    res=func(*args,**kwargs) # 接收原函数返回值
    stop_time=time.time()
    print('run time is %s' %(stop_time-start_time))
    return res # 保留并返回原函数结果
  return wrapper

def home(name):
  time.sleep(random.randrange(1,3))
  print('welecome to %s HOME page' %name)
  return 123123123123123123123123123123123123123123

home = timmer(home) # 等效于 @timmer

通过 home = timmer(home) 的赋值操作，实现了装饰器的功能。使用 @timmer 语法糖可以达到完全相同的效果，且调用方式无需修改。

多层装饰器与执行顺序

当函数同时应用多个装饰器时，执行顺序遵循“从下往上”包裹，但“从上往下”执行的原则。以下代码展示了 @auth 和 @timmer 同时作用于 index 函数的情况：

import time
import random

def timmer(func):
  def wrapper():
    start_time = time.time()
    func()
    stop_time=time.time()
    print('run time is %s' %(stop_time-start_time))
  return wrapper

def auth(func):
  def deco():
    name=input('name: ')
    password=input('password: ')
    if name == 'egon' and password == '123':
      print('login successful')
      func() # 调用被装饰的函数（即timmer返回的wrapper）
    else:
      print('login err')
  return deco

@auth  # index = auth(timmer(index))         
@timmer # index = timmer(index)
def index():
  time.sleep(3)
  print('welecome to index page')

index()

在上述结构中，@timmer 位于下方，首先执行，将 index 包装为计时函数；随后 @auth 位于上方，将计时函数包装为认证函数。最终调用 index() 时，流程为：先执行认证逻辑，验证通过后调用计时逻辑，最后执行原函数。以上就是Python装饰器从原理到多层应用的详细内容，更多关于Python高级特性的资料请关注本站其它相关文章！