疑问点 1：@app.get() 和下方 def 是不是绑定在一起？#

结论：是的，装饰器只修饰紧随其后的函数。它们在语法上必须连在一起，中间不能插入其他代码。

疑问点 2：谁装饰谁？#

@app.get("/api/profile") 装饰的是函数 get_profile。

疑问点 3：装饰器到底有什么用？#

它的作用是给普通函数打上“角色标记”，告诉框架：

这个函数用来处理 GET /api/profile 的网络请求。

等价的原生写法可以理解为：

1
def get_profile():
2
    return profile
3

4
app.add_api_route(path="/api/profile", endpoint=get_profile, methods=["GET"])

所以装饰器本质上是语法糖：把“路径注册”和“业务函数”写在一起，让代码更紧凑、更易读。

关键疑问 1：函数内部为什么还能定义函数？#

Python 支持嵌套函数。内层函数可以使用外层函数传进来的变量，这就是闭包的典型表现。

这里可以这样拆：

• timer：外层工厂函数
• wrapper：包装函数，负责新增逻辑（计时）

关键疑问 2：看不见 wrapper() 调用，它是怎么运行的？#

把语法糖展开：

1
@timer
2
def func1():
3
    pass
4

5
# 等价于
6

7
def func1():
8
    pass
9

10
func1 = timer(func1)

执行过程可以分成三步：

1. 代码加载阶段（定义时）：执行 timer(原始 func1)，生成 wrapper 函数对象；
2. 变量覆盖：名字 func1 不再指向原始函数，而是指向 wrapper；
3. 调用阶段：执行 func1()，实际上就是执行 wrapper()。

关键疑问 3：为什么是 return wrapper，不能写 return wrapper()？#

这两者完全不同：

• return wrapper：返回函数对象本身，后续可以随时调用；
• return wrapper()：立刻执行函数，返回执行结果（大多是 None）。

错误示范：

1
def deco(func):
2
    def inner():
3
        print("包装启动")
4
        func()
5
    return inner()  # 当场执行 inner，返回 None
6

7
@deco
8
def demo():
9
    print("demo执行")
10

11
demo()  # 报错 TypeError: 'NoneType' object is not callable

考题 1#

1
def deco(func):
2
    def inner():
3
        print("开始")
4
        func()
5
        print("结束")
6
    return inner
7

8
@deco
9
def hello():
10
    print("Hello")
11

12
hello()

输出：

1
开始
2
Hello
3
结束

理解方式：hello = deco(hello)，调用 hello() 时实际执行的是 inner()。

考题 2：时序大坑#

1
def deco(func):
2
    print("进入deco")
3
    def inner():
4
        print("inner运行")
5
        func()
6
    return inner
7

8
@deco
9
def test():
10
    print("执行test本体")
11

12
print("====分割线====")
13
test()

正确输出顺序：

1
进入deco
2
====分割线====
3
inner运行
4
执行test本体

核心知识点：@ 装饰器在函数定义阶段就执行外层代码，不等你调用函数。

带参数的装饰器：#

• app.get("路径") 先传入配置；
• 然后返回一个专属装饰器；
• 再由这个装饰器去包装业务函数。

执行流程#

1. 项目启动加载代码：只是在注册路由表；
2. 浏览器发起 HTTP 请求访问接口时，FastAPI 自动调用包装后的函数；
3. 框架自动把 return 的字典转成 JSON，并封装成 HTTP 响应。

我最后记住的是，装饰器的核心就是 @deco 等价于 f = deco(f)。它不是在改原函数的代码，而是把原函数交给另一个函数包一层，再把新的函数返回回来。