Python的装饰器把我绕晕了,原来带参和不带参区别这么大

简介: 本文深入剖析Python装饰器加括号与不加括号的本质区别:`@decorator`是直接用函数本身作装饰器;`@decorator()`则是先调用函数,用其返回值作装饰器。通过真实踩坑案例,厘清无参/带参装饰器的执行逻辑、类实现方式及使用规范,助你彻底掌握装饰器核心原理。(239字)

讲个真事儿。

上个月我写一个内部工具,要给十几个函数统一加日志。心想,用装饰器呗,优雅又省事。于是写了个带日志级别的装饰器,让每个函数自己指定日志等级:

def log(level):
   def decorator(func):
       def wrapper(*args, **kwargs):
           print(f"[{level}] 调用 {func.__name__}")
           return func(*args, **kwargs)
       return wrapper
   return decorator

@log("INFO")
def get_user():
   return {"name": "张三"}

@log("DEBUG")
def calculate():
   return 42

运行没问题,完美。我心里还美滋滋的。

后来有个函数不需要指定级别,我就想:那简单,把括号去掉用默认值不就完了?于是改成了这样:

@log
def test_func():
   return "hello"

结果,程序直接报错,说log函数缺少参数。我盯着屏幕看了十分钟,就多了对括号的事,怎么差别这么大?

那一刻我才真正搞明白,装饰器加不加括号,背后是两种完全不同的逻辑。

代理 IP 使用小技巧 让你的数据抓取效率翻倍 (77).png

先搞明白装饰器本质是什么

在聊括号之前,咱们先把装饰器的本质搞清楚。

一句话总结:装饰器就是一个函数,它接收一个函数作为参数,返回一个新的函数。

语法糖@decorator等价于:

@decorator
def func():
   pass

# 等价于
def func():
   pass
func = decorator(func)

看到了吗?@decorator就是**把func传进decorator()这个函数里,然后把返回值重新赋值给func**。

关键点:装饰器在定义函数的时候就已经执行了,不是调用的时候才执行。

搞明白这个,咱们再来看加括号和不加括号到底差在哪。

加括号 vs 不加括号,到底差在哪儿

用一句话说清楚:

  • @log —— 把log本身当作装饰器,直接传入被装饰的函数
  • @log() —— 先调用log(),把它的返回值当作装饰器

你看,加括号是先执行函数调用,把结果当作装饰器。不加括号是直接把函数本身当作装饰器。

这两个返回的东西完全不一样:

  • log是一个函数,它接收一个函数作为参数
  • log()是调用了log,它返回的是另一个函数

形状一样,但一个是原函数,一个是返回值。

场景一:无参装饰器——千万别加括号

最常见的装饰器写法:

def timer(func):
   def wrapper(*args, **kwargs):
       start = time.time()
       result = func(*args, **kwargs)
       print(f"耗时: {time.time() - start}")
       return result
   return wrapper

@timer  # ✅ 正确,不加括号
def slow_function():
   time.sleep(1)

如果你手贱写成@timer():

@timer()  # ❌ 报错
def slow_function():
   time.sleep(1)

为什么报错?因为timer()先被执行,返回的是wrapper这个函数。然后Python把slow_function传给了wrapper。但wrapper接收的参数格式是(*args, **kwargs),它不接收一个函数作为参数,所以报错。

这就好比你本来应该把门牌号告诉快递员,结果你把门牌号告诉了物业,物业又说“我不收快递”,快递就送不到了。

无参装饰器的正确写法(用类实现)

除了用函数,还可以用类来实现无参装饰器:

class my_decorate(object):
   def __init__(self, f):
       """装饰器不带参数时,函数作为参数传给构造器"""
       print("进入到 __init__")
       self.f = f
   
   def __call__(self, *args):
       print("进入 __call__")
       self.f(*args)
       print("结束 __call__")

@my_decorate
def myFunction(arg1, arg2):
   print('myFunction arguments:', arg1, arg2)

myFunction("say", "hello")

输出:

进入到 __init__
进入 __call__
myFunction arguments: say hello
结束 __call__

注意,__init__只被调用了一次。因为用类作为装饰器,会先创建类实例,然后再去执行这个实例。执行过程等价于:

myDecorate = my_decorate(myFunction)
myDecorate('say', 'hello')

被装饰器修饰的函数,最终类型实际上是装饰器本身。

场景二:带参装饰器——必须加括号

这就是我踩坑的场景。当装饰器需要参数时,你必须多包一层:

def log(level):
   def decorator(func):
       def wrapper(*args, **kwargs):
           print(f"[{level}] 调用 {func.__name__}")
           return func(*args, **kwargs)
       return wrapper
   return decorator

# 使用
@log("INFO")  # ✅ 加括号,传参数
def get_user():
   return {"name": "张三"}

执行顺序是这样的:

  1. 先执行log("INFO"),返回decorator函数
  2. Python把get_user传进decorator,返回wrapper
  3. 最终get_user被替换成wrapper

整个过程等价于:

get_user = log("INFO")(get_user)

先执行log("INFO"),返回的是decorator函数,再调用返回的函数,参数是get_user函数,返回值最终是wrapper函数。

带参装饰器的正确写法(用类实现)

用类实现带参装饰器,结构会发生较大变化:

class my_decorate(object):
   def __init__(self, arg1, arg2, arg3):
       """带参数时,__init__接收的是装饰器的参数,不是函数"""
       print("进入 __init__()")
       self.arg1 = arg1
       self.arg2 = arg2
       self.arg3 = arg3
   
   def __call__(self, f):
       """函数作为参数传给__call__方法"""
       print("进入 __call__()")
       def wrapped_f(*args):
           print("进入 wrapped_f()")
           print("装饰器参数:", self.arg1, self.arg2, self.arg3)
           f(*args)
           print('执行完函数myfunction')
       return wrapped_f

@my_decorate("hello", "world", 1)
def myFunction(*args):
   if len(args) > 0:
       print('this is myFunction args: %s' % str(args))
   else:
       print('this is myFunctions')

myFunction('hello', 'myfunction')

输出:

进入 __init__()
进入 __call__()
进入 wrapped_f()
装饰器参数: hello world 1
this is myFunction args: ('hello', 'myfunction')
执行完函数myfunction

关键区别:装饰器带参数时,不能在__init__中接收函数作为参数,因为__init__的参数是装饰器自己的参数。函数是在__call__方法中接收的。

场景三:带参装饰器,解决实际问题

回到开头那个场景。不带参数的装饰器只能打印固定的字符串:

def decorator(fun):
   def wrapper(*args, **kwargs):
       print("Method is running")
       return fun()
   return wrapper

但如果我们想打印不同的信息,就需要带参数的装饰器:

def decorator_par(name):
   def decorator(fun):
       def wrapper(*args, **kwargs):
           print("Method {} is running".format(name))
           return fun()
       return wrapper
   return decorator

@decorator_par("A")
def A():
   print("I am A")

@decorator_par("B")
def B():
   print("I am B")

A()  # 输出: Method A is running \n I am A
B()  # 输出: Method B is running \n I am B

可以看到,在不改变方法调用代码的情况下,实现了在不同方法之前打印特定的信息。

带参数的装饰器,本质上就是在不带参数的装饰器外面再封装一层。这多出来的一层,就是为了接收装饰器自己的参数。

场景四:装饰器既要带参又要无参——能兼容吗?

有些场景下,你可能希望同一个装饰器既能不带参数使用,也能带参数使用。比如:

@logged
def f1():
   pass

@logged(level=logging.CRITICAL)
def f2():
   pass

这时候就需要在装饰器内部做判断。但说实话,这种写法比较复杂,而且容易引入歧义。一般情况下,建议明确区分:需要参数就用带参版本,不需要就用无参版本,不要试图让一个装饰器同时兼容两种用法。

总结

对比项 无参装饰器 @log 带参装饰器 @log("INFO")
嵌套层数 2层(decorator + wrapper) 3层(outer + decorator + wrapper)
执行时机 定义时直接装饰 先执行外层函数获取装饰器,再装饰
适用场景 功能固定,不需要额外配置 需要根据不同情况调整行为

记住最核心的一句话:

  • @log —— 把log本身当作装饰器
  • @log() —— 先调用log(),把返回值当作装饰器

加不加括号,决定了Python把谁当作装饰器。这个区别,搞明白了就不会再踩坑了。

目录
相关文章
|
2月前
|
TensorFlow 算法框架/工具 Python
Python的虚拟环境把我整不会了,原来venv和conda背后藏着这么多坑
本文通过实习生踩坑经历,深入对比Python虚拟环境工具venv与conda的核心差异:venv轻量专注包隔离,但绑定Python版本;conda全能自包含,支持多版本及系统级依赖。二者逻辑迥异,混用易致环境崩溃。文末给出选型指南与Poetry+pyenv现代方案建议。(239字)
331 0
|
Linux 网络安全 网络协议
CentOS 7下iptables配置添加修改规则端口方法
Linux CentOS 7默认没有安装iptables,默认的防火墙是firewalld,云吞铺子分享CentOS 7系统下iptables安装、iptables规则配置(放行或者禁用端口)教程方法: 以下大致步骤为:先关闭firewalld防火墙,然后按照iptables,最后配置添加或者禁用端口规则,详细如下: 检查firewalld并禁用 安装iptables之前先检查下当前CentOS 7系统下的firewalld防火墙状态,如果是开启状态,需要先关闭firewalld防火墙。
10043 0
|
Linux
CentOS 7 设置日系统时间为中国时区并启用NTP同步
一、CentOS 7 设置日系统时间为中国时区并启用NTP同步 在CentOS 6版本,时间设置有date、hwclock命令,从CentOS 7开始,使用了一个新的命令timedatectl。 yum install ntp //安装ntp服务 systemctl enable ntpd //.
10052 0
|
28天前
|
人工智能 运维 监控
从告警风暴到根因候选:AIOps 落地的四层技术拆解
本文沿着告警生命周期拆解 AIOps 的四层能力:动态基线检测、五类降噪收敛、统一建模下的多智能体诊断、自愈处置与知识沉淀,并说明每层的能力边界与建设顺序,帮运维团队判断该从哪一步落地。
|
2月前
|
人工智能 监控 安全
零代码改造:让 AI Agent Sandbox 不再是黑盒
OBI 基于 eBPF 在内核与库函数层零代码拦截通信,自动生成调用链与指标,内置 OpenAI、Anthropic、Gemini、Qwen 及自定义 LLM 网关的 GenAI 语义追踪,覆盖 LLM、工具、MCP 与 RAG 全链路,从性能、成本、安全三个维度透视沙箱执行。
679 21
|
2月前
|
人工智能 安全 前端开发
刚刚 GPT-6 Astra 发布,全球最强,AGI 时代到来!
OpenAI 正式推出 GPT-6 Astra 模型,带大家看看这次 GPT 有哪些提升,跟 Claude Fable 5.1 有什么差距?AI 编程能力如何?AGI 真的来了么?
1104 0
|
2月前
|
缓存 运维 安全
一直以为deepcopy很安全,直到线上数据全乱了才幡然醒悟
一篇真实技术复盘:程序员用 `deepcopy` 生成订单快照,却因共享引用、性能瓶颈与不可拷贝对象引发线上数据错乱。文章详解四大深坑及安全替代方案,提醒开发者——“安全”不等于盲目复制。(239字)
128 0
|
2月前
|
数据采集 安全 Java
从入门到放弃,Python的GIL锁比我想象的还要‘坑’
本文以亲身踩坑经历切入,揭秘Python多线程“越优化越慢”的真相——GIL(全局解释器锁):它保障了单核时代的内存安全,却制约了多核下CPU密集型任务的并行;I/O密集型任务仍可高效并发。文章厘清误解、剖析原理,并给出多进程、异步、C扩展及Python 3.13自由线程等实用绕过方案。(239字)
311 0
|
2月前
|
算法 安全 C++
Python的类属性把我带进沟里了,原来实例查找和类查找顺序这么反直觉
本文以真实踩坑案例切入,深入剖析Python类属性与实例属性的核心区别:查找时“先实例后类”,但赋值与修改行为截然不同。重点揭示可变类属性(如列表、字典)引发的共享陷阱,并用“公共储物柜vs私人抽屉”生动比喻助你彻底理解。
146 0
|
2月前
|
存储 JSON 数据格式
Python的生成器把我内存救活了,原来return和yield差距这么大
本文通过真实案例对比`return`与`yield`:前者一次性加载50万条JSON数据致内存飙至14GB,后者用生成器逐行处理仅耗80MB。深入剖析二者在执行机制、内存模型及编程思维(批处理vs流式)的本质差异,并详解生成器的惰性求值、状态保持、一次性等特性及典型应用场景。
122 0

热门文章

最新文章