前面我们已经一路学到了函数、作用域、推导式、lambda、迭代器、生成器、yield。到这里，很多人会开始碰到一个看起来有点高级、但其实非常实用的东西：装饰器。
很多新手第一次听到“装饰器”这个词，会本能觉得它很抽象。总感觉这东西像是框架里才会出现的魔法语法，好像离自己还很远。其实不是。
你可以先把装饰器理解成一句特别接地气的话：
在不改原函数代码的前提下，给这个函数额外加一点能力。
这句话特别重要。 因为它直接说出了装饰器最核心的价值。
不是重写函数。 不是复制函数。 不是手动到函数内部加代码。 而是在外面包一层，让函数多出新功能。
这一章，我们就把这个思路讲透。
一、先别急着看 @，先看你平时是怎么“给函数加功能”的
比如你现在有一个函数：
defsay_hello(): print('你好')
调用：
say_hello()
输出：
你好
这当然没问题。
但假设现在你有了一个新需求：
每次函数执行前，都先打印一句“函数开始执行”。
很多人第一反应会这么改：
defsay_hello(): print('函数开始执行') print('你好')
这当然能实现。 但如果以后还有 10 个函数、100 个函数，也都想加这种“执行前打印日志”的功能呢？
难道每个函数都进去手改一遍？
这时候你就会发现，问题不在于“能不能做到”，而在于：
有没有一种更统一、更优雅、更少侵入的做法。
这就是装饰器出场的原因。
二、装饰器到底要解决什么问题
它主要解决的是下面这类需求：
一个函数原本已经写好了 你不想去改它内部逻辑 但你想给它额外加点东西
比如：
执行前打印日志 执行后记录时间 统计运行耗时 做权限检查 做输入校验 做缓存 做异常处理包装
你会发现，这些增强功能往往有个共同特点：
它们不是函数本来的业务逻辑，但又很想统一加在函数外层。
比如一个函数本来只是算总价。 你不想把“打印日志”“记录耗时”这种辅助逻辑硬塞进函数内部。 因为那会让原函数越来越臃肿。
所以装饰器本质上是在帮你做一件事：
把“核心逻辑”和“附加逻辑”分开。
这就是它特别值钱的地方。
三、先看一个最朴素的“包一层”思路
还是这个函数：
defsay_hello(): print('你好')
如果我们不改它本身，而是在外面包一层，可以写成：
defwrapper(): print('函数开始执行') say_hello()
然后调用：
wrapper()
输出：
函数开始执行你好
你会发现，这已经有点装饰器的味道了。
原函数 say_hello() 没改。 我们只是新写了一个 wrapper()，把它包起来，并在前面额外加了一句日志。
所以从最朴素的角度看，装饰器的本质其实就是：
用一个外层函数，把原函数包起来。
四、为什么这种“包一层”的思路特别重要
因为它让你第一次真正看见了装饰器的核心结构。
装饰器看起来高级， 但底层并不神秘。 它最本质的动作就是：
先拿到一个函数 再在外面包一个新函数 新函数里做额外增强 最后再去调用原函数
你只要把这个骨架想通，后面那个 @ 语法就不再吓人了。
很多人学装饰器学晕，往往不是因为原理太难，而是因为一上来就盯着 @ 和嵌套函数写法，看起来太密了。 其实你现在先把“包一层增强功能”想明白，后面就会特别顺。
五、那怎么把“包一层”做成可复用的东西
刚才我们写的是：
defwrapper(): print('函数开始执行') say_hello()
但这还不够灵活。 因为它写死了只能包 say_hello()。
如果我们想让这个“增强功能”可以包别的函数，就得把原函数当参数传进去。
例如：
defdecorator(func):defwrapper(): print('函数开始执行') func()return wrapper
然后：
defsay_hello(): print('你好')say_hello = decorator(say_hello)say_hello()
输出：
函数开始执行你好
这里就非常关键了。
我们定义了一个 decorator(func)。 它接收一个函数 func。 然后在里面定义了一个 wrapper()。wrapper() 先加额外逻辑，再调用原函数。 最后返回这个 wrapper()。
这就已经是一个真正意义上的装饰器雏形了。
六、这段代码一定要彻底看懂
看这句：
say_hello = decorator(say_hello)
它非常核心。
你可以把它翻译成人话：
把原来的 say_hello 函数交给 decoratordecorator 返回一个增强后的新函数 再让变量名 say_hello 指向这个增强后的版本
所以以后你再调用：
say_hello()
实际上调用的已经不是最初那个裸函数了， 而是“被包过一层”的新函数。
这就是为什么装饰器能做到：
看起来还是调用原函数名，但实际已经附加了新功能。
这点非常巧妙，也非常重要。
七、现在终于可以正式理解：装饰器是什么
你现在可以把装饰器总结成一句更完整的话了：
装饰器本质上是一个函数，它接收另一个函数作为参数，并返回一个增强后的新函数。
这就是装饰器最核心的定义。
你别管后面会不会出现 @。 也别急着背“闭包”“高阶函数”这些词。 你现在只要把上面这句话真正理解透，装饰器的主干就已经通了。
关键词只有三个：
接收函数 包一层 返回新函数
这就是装饰器。
八、为什么装饰器离不开“函数可以作为参数传递”
因为装饰器本质上就是在操作函数。
而前面你已经学过：
函数名本身也可以当值来传 函数可以作为参数传给别的函数 函数也可以作为返回值返回出来
这些能力看起来分散， 其实到了装饰器这里，就全都串起来了。
所以装饰器并不是一块凭空冒出来的孤立知识。 它其实是前面函数高级能力的一次集中应用。
换句话说：
如果函数不能当参数传、不能被返回，那装饰器根本就做不出来。
这也是为什么这一章会排在生成器之后，而不是排在函数最前面。
九、先不要急着 @，再看一个更直观的例子
比如我们写一个函数，用来计算两个数相加：
defadd(): print(3 + 5)
现在想让它执行前先打印一句提示。
装饰器写法：
defdecorator(func):defwrapper(): print('准备执行函数') func()return wrapperdefadd(): print(3 + 5)add = decorator(add)add()
输出：
准备执行函数8
你看，这时候感觉是不是越来越顺了。
装饰器并没有改 add() 函数内部代码。 它只是把 add() 放进包装函数里，再加上额外逻辑。
这就是“不改原函数也能增强功能”的真正含义。
十、装饰器最常见的增强方式有哪些
你现在先有个感觉就行。
执行前打印日志 执行后打印日志 统计函数耗时 记录调用次数 判断用户是否登录 做简单权限校验 统一异常捕获 缓存函数结果
这些都是特别常见的装饰器使用场景。
它们有个共同点：
逻辑往往是“附加型”的。 不是函数本来的业务核心。 但又很希望统一加上。
所以装饰器特别适合处理这种“横着切过去”的增强需求。
你以后学框架时，会越来越频繁碰到它。
十一、现在终于可以看 @ 语法了
前面那句：
say_hello = decorator(say_hello)
其实 Python 给了一个更好看的写法：
@decoratordefsay_hello(): print('你好')
然后你直接：
say_hello()
输出结果还是：
函数开始执行你好
也就是说：
@decoratordefsay_hello(): ...
本质上就等价于：
defsay_hello(): ...say_hello = decorator(say_hello)
这就是 @ 的真实含义。
它不是新魔法。 它只是 Python 给你提供的一种更简洁、更直观的装饰器语法糖。
十二、为什么很多人一看到 @ 就慌
因为看起来像“贴了一个特殊标签”。 但你现在应该知道，它的本质其实非常朴素：
把下面定义的函数，交给上面的装饰器处理。
所以以后你一看到：
@somethingdeffunc(): ...
脑子里先不要慌。 先自动翻译成：
func = something(func)
只要你能这样翻译，@ 基本就不再神秘了。
十三、装饰器里为什么总要写嵌套函数
因为你既要“接收原函数”，又要“返回一个新的包装函数”。
比如：
defdecorator(func):defwrapper(): print('开始执行') func()return wrapper
外层 decorator 负责接收原函数。 内层 wrapper 负责真正增强执行过程。 最后再把 wrapper 返回出去。
所以嵌套函数并不是装饰器里故意写复杂， 而是因为它真的符合这件事的结构需要。
这也是为什么你会发现，装饰器几乎天然长成“函数里面套函数”的样子。
十四、一个特别关键的问题：如果原函数有参数怎么办
前面为了让你先看清主干，我们用的例子都是无参数函数。 但真实函数当然经常有参数。
比如：
defadd(a, b): print(a + b)
如果还写成之前那个 wrapper()，就不够用了。 因为原函数调用时需要参数。
这时候就要把包装函数也写成能接参数的形式：
defdecorator(func):defwrapper(a, b): print('开始执行') func(a, b)return wrapper@decoratordefadd(a, b): print(a + b)add(3, 5)
输出：
开始执行8
这说明什么？
说明装饰器不是只能包无参函数。 但包装函数必须和原函数调用方式匹配。
这也是装饰器为什么一进入真实项目，就经常会看到 *args 和 **kwargs。
不过这一步我们先不急着展开太深，下一章还会继续进阶。
十五、为什么装饰器特别像“插电式增强”
这是个很好记的理解方式。
原函数就像一台原装机器。 装饰器就像一个外接模块。 你不用拆机器内部结构， 只要把增强模块接上去，机器就会多出新功能。
比如：
原函数负责“算结果” 装饰器额外给你“打印日志”
原函数负责“发请求” 装饰器额外给你“统计耗时”
原函数负责“写数据” 装饰器额外给你“做权限判断”
你会发现，装饰器特别适合这种“外插增强”的思路。
这也是为什么它在框架和工程化代码里特别常见。
十六、先看一个特别接近真实开发的小例子：记录函数执行前后
deflog_decorator(func):defwrapper(): print('函数开始执行') func() print('函数执行结束')return wrapper@log_decoratordeftest(): print('这里是函数主体')test()
输出：
函数开始执行这里是函数主体函数执行结束
这个例子特别好。 因为它已经非常像真实项目里的装饰器用途了。
函数本身只是干自己的业务。 而装饰器在外面统一加上日志行为。
这就比你去每个函数内部手动复制粘贴日志代码要清爽得多。
十七、装饰器为什么特别适合做“通用增强”
因为一旦某种增强逻辑不是只服务一个函数，而是很多函数都可能需要，那装饰器就会特别有价值。
比如：
十几个函数都想打印执行日志 十几个接口都想先检查登录状态 十几个操作都想统计耗时
如果你每个函数都自己写一遍，那重复度会很高。 而装饰器能把这类“共性增强”抽出来，统一复用。
所以从设计角度看，装饰器特别适合做这种事情：
把重复的外层附加逻辑，抽成一个可复用的增强层。
这和前面学函数抽取重复逻辑，其实是一脉相承的。 只是现在抽的，不再是普通步骤逻辑，而是函数外层行为。
十八、一个特别常见的误区：以为装饰器只是为了写得花
不是。
装饰器当然看起来有点“语法感”， 尤其第一次看到 @ 和嵌套函数时，很容易让人觉得它像某种高级写法展示。 但它真正的价值绝对不是“显得会 Python”。
它真正解决的是很现实的问题：
不改原函数 又能统一增强 还能减少重复代码
这不是花哨，而是实用。
所以你以后看装饰器，一定不要从“酷不酷”去理解， 而是从“它帮我减少了什么重复劳动”去理解。
十九、本章小练习
你可以做两个特别适合巩固的练习。
练习 1 写一个装饰器，让函数执行前打印一句：
开始执行函数
然后装饰一个简单函数，比如打印“Hello Python”。
练习 2 写一个装饰器，让函数执行前后分别打印提示语。 比如：
函数开始函数结束
然后装饰一个加法函数，观察输出顺序。
这两个练习虽然不复杂，但特别重要。 因为装饰器最难的不是语法，而是“包一层增强”的那个感觉。 只要你亲手写两遍，这个感觉会快很多。
二十、本章总结
这一章最重要的，是先把装饰器的核心本质看清楚。
装饰器本质上是一个函数，它接收另一个函数作为参数，并返回一个增强后的新函数。 它最核心的价值，是在不改原函数代码的前提下，为原函数附加新功能。 装饰器底层依赖的是：函数可以作为参数传递，也可以作为返回值返回。@decorator 只是更简洁的语法糖，本质上等价于：
func = decorator(func)
装饰器特别适合处理那些“不是业务核心、但很多函数都想统一加上”的附加逻辑，比如日志、耗时统计、权限校验等。 你现在不用急着追求写复杂装饰器，先把“包一层增强”这个核心感觉真正建立起来最重要。
下一章我们继续往前走，把装饰器真正推进到能用的阶段：099｜闭包与作用域进阶：理解函数的高级能力。
