再看前置认知，函数也是个“东西”

在 Python 里函数和数字、字符串一样。是一个可以传来传去的对象。你可以把函数存进变量、当作参数传给另一个函数、甚至让一个函数返回另一个函数。

这个认知是理解装饰器的地基。如果觉得抽象，可以这样理解：

一旦接受了“函数是个能传来传去的东西”。后面的一切都是水到渠成，

第一步先这方面。手动包装函数

从最朴素的思路来看，把函数当作参数传进去，在调用前后加上额外逻辑。

def fun:
print
def wrapper1:
print
func # 调用原函数
print
wrapper1

运行输出的观点是。

装饰前置逻辑
我是原函数
装饰后置逻辑

wrapper1 接收了 fun先打印前置逻辑，再替你调用 fun最终打印后置逻辑。原函数被完整地“包”在了中间。

使用者痛点：每次想要包装都得手动写 wrapper1代码重复且易忘记。

说到接下来。函数可以重新赋值

函数名本质上就是一个指向函数对象的变量名，所以可以重新赋值。

def wrapper2:
print
return func # 不加括号不调用，直接返回函数对象本身
fun = wrapper2 # 将自身作为参数传递。返回并赋值给 fun

装饰前置逻辑

注意：这里 "我是原函数" 因为 wrapper2 没有调用原函数，只是返回了原函数的引用。

赋值之后fun 变成了 wrapper2 的返回值——也就是原函数本身。执行 fun 仍然可以调用原函数，没丢。

User Pain Point：If you assign a wrapper that runs logic during assignment。you lose control over when extra behavior happens. We need a way to defer execution until function is actually called.

：返回一个全新的函数

再看主要技巧，在 wrapper 里面再套一层内部函数，外层直接返回内部函数对象。内部函数定义时不会执行,只有被调用时才执行。

def decorator:
def wrapper:
print
func # 调用原函数
print
return wrapper # 返回 wrapper 函数对象，不调用它
fun = decorator # 赋值新函数 wrapper 给 fun。此时 wrapper 内容没被调用
fun # 此时 fun 就是全新的 wrapper

装饰前置逻辑
我是原函数
装饰后置逻辑

• 赋值阶段：fun = decorator 调用 decorator 把原 fun 传进去。 内部定义了 wrapper 但没有调用它，只是把 wrapper 这个函对象返回出来并赋给 fun. 此时 wrapper`里的代码一行都没跑。
• 调用阶段: fun此时调 用的是已经被替换成 wrapper。其实，wrapper 执行 前置 → 原函 数 → 后置。完整包装效果在这一刻显现。

User Pain Point:The two‑step process often confuses beginners—y think decorator runs immediately,but it only runs when wrapped function is invoked.

三个必须想通的关键问题

问题 ：为什么参数放在最外层？

If you try to move func 参数到内层wrapper ,you'll lose reference to original function.

def decorator:
def wrapper:
print
func
print
return func
return wrapper
fun = decorator # 返回的是 wrapper 函数。并覆盖了 fun 名称
fun # 报错，因为左侧 fun 已经是 wrapper，需要一个参数，而右侧已经不是原始 fun 了

必须把参数放在最外层，这样原函 数 在赋值 替 换之前就被 “捕获”进闭 包，不会因为变量名 被 覆盖而 丢失。

问题 ：原函 数 有 参数怎么办？

真实业务 函数 往往 带 参数，如 add 。使用 *args,**kwargs 能 接 收 任意 参数。

 def log_decorator:
def inner:
print
res = func # 把参数传 给 原 函数，接 收 返回 值
print
return res # 必须把 原 函数 返回 值 返回 出 去！很 容 易 漏
return inner
def add:
return a + b
add = log_decorator
print) 

 准备调用函 数 add
函 数执行完毕 

问题 ：装 饰 器 到 底 解 决 了 什么 问题？

本 质 :  装 饰 器 利 用 闭 包 + 函数 对 象 赋 值，在 不 修改 原 函数 源 代码、不 修改 原 函数 调 用 方 式 的 前 提 下为 已 有 函 数 动 态 增 加 附 加 功 能。

痛点	说明
A. 重复代码冗余 B. 入侵业务代码 C. 职责混杂 D. 无法灵活	A. 多个函 数 都 要 加 相 同 附 加 逻 辑，不 想 每 个 都 抄 一 遍；B. 不 想 改 原 有 業務 代 碼，只 在 外 圍 包 裹；C. 功 能 解 耦，各司其职，提高 可读性与可维护性；D. 可 多 次 堆叠，多 装 饰 器 按需 开关。如 搭 积 木 一 样 組 合。

至于@语法糖。一行代码背后藏着什么

手写 fun = decorator 太 常 用，于 是 Python 发 明 了 @ 符号 来 替 你 干 那 件事。两 种 写 法 完 全 等价：

def outer:
def inner:
print
func
print
return inner
# 写法1：手写赋值
def hello:
print
hello = outer # 等价于下面的 @outer
# 写法2：@语法糖简写
@outer
def hello:
print

@outer 就是 一个 快 捷 方 式，它 在 定义 完 hello 后 自动 执 行 hello = outer 。仅 此 而 已，但 正 是 这 “仅 此 而 已”，给 新 手 挖 了 不 少 坑。

坑 ：隐藏了赋值替换动作

手写 hello = outer 时你 能 清 晰 看 到变量 hello 被 覆盖 指 向 新 的 inner。而 @ outer 一 行 看 不 出 来，大 脑 难 以 捕 捉： hello 已 经 不 是 原 来 的 那 个 函数 了。

坑 ：多层带参装饰器嵌套混乱

def log:
def deco:
def inner:
pass
return inner
return deco
@log
def test:
pass

展开后的等价代码是：

temp = log # 得到真正用于装饰的 deco 函数
test = temp # 再用它包装 test

@log 是两 步：先 执 行 log 得到 一个 装 饰 器，再 用 那 个 装 饰 器 包 装 test。其实，中 间 临 时 变 量 被 隐 藏。使 链 条 看 起 来 很 混 烦。

坑 ：叠加装饰器执行顺序反直觉

@A
@B
def f:
pass

从展开后是来看，

# 先执行内层 B 包裹 f → f = B
# 再用 A 包裹上一步结果 → f = A

真实执行顺序为：从下往上包从外往里穿。

Cronic口诀： 装饰从下往上包，执行从外往里穿。按理说，

坑 ：被装饰函数元信息丢失

普通装饰器会把被包装后的名字改成内部 >inner。导致调试、日志等场景出现误导信息。

import functools
def log_decorator:
@functools.wraps # 保留 name、doc 等元信息
def inner:
print
return func
return inner
@log_decorator
def add:
"""两数相加"""
return a + b
print # 输出: add，而不是 inner
print # 输出: 两数相加

functools.wraps 到底干了什么？不过，

@functools.wraps 本质上是把原函 数 的元信息复制到包装后的内部函 数上。下面给出一个极简版实现帮助理解：

def my_wraps:
def decorator:
wrapper.__name__ = func.__name__
wrapper.__doc__ = func.__doc__
wrapper.__module__ = func.__module__
wrapper.__qualname__ = func.__qualname__
wrapper.__annotations__= func.__annotations__
return wrapper
return decorator

Cronic提示： 官方实现还会同步 dict 与 wrapped 等属性，这里仅保留主要思路。

从展开过程来看，

• #1 >temp_decorator=my_wraps: 得到内部 >decorator.
• #2 >inner=temp_decorator: 把inner 的元信息替换为原始 func 的元信息。

​

...

---