能否让with语句内调用的函数隐式获取with对象，无需显式传递？

好问题！Python本身并没有专门为这种场景设计的「魔法关键字」，但我们可以通过几种方式实现你想要的效果——让do_other_things()不用显式接收参数就能访问with语句里的上下文对象。下面给你拆解几种可行方案：

1. 自定义上下文管理器 + 模块级变量（单线程场景） #

如果你的代码是单线程运行的，可以直接用模块级变量来存储上下文对象，在进入with上下文时赋值，退出时清理：

# 模块级变量，用来临时存储上下文对象
_current_something = None

class SomethingContext:
    def __enter__(self):
        global _current_something
        # 这里替换成你实际获取对象的逻辑
        _current_something = "来自with上下文的对象"
        return _current_something

    def __exit__(self, exc_type, exc_val, exc_tb):
        global _current_something
        _current_something = None  # 退出上下文时清空，避免污染后续代码

def get_something():
    return SomethingContext()

然后你的do_other_things()就可以直接访问这个变量：

def do_other_things():
    if _current_something is None:
        raise RuntimeError("请在with get_something()上下文内调用此函数！")
    print(_current_something)

使用方式和你想要的一样：

with get_something() as something:
    do_other_things()  # 无需传参，直接访问上下文对象

⚠️ 注意：这种方式线程不安全，多线程环境下会出现变量被覆盖的问题。

2. 使用contextvars模块（Python 3.7+，线程安全） #

如果你需要支持多线程，Python标准库的contextvars是专门用来处理上下文绑定变量的，它能保证每个线程的上下文变量独立：

import contextvars

# 创建一个上下文变量，默认值为None
something_var = contextvars.ContextVar("something", default=None)

class SomethingContext:
    def __enter__(self):
        # 保存变量的当前状态，用于退出时重置
        self.token = something_var.set("来自with上下文的对象")
        return something_var.get()

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 恢复变量到进入上下文之前的状态
        something_var.reset(self.token)

def get_something():
    return SomethingContext()

do_other_things()的写法：

def do_other_things():
    something = something_var.get()
    if something is None:
        raise RuntimeError("请在with get_something()上下文内调用此函数！")
    print(something)

使用方式和之前完全一致，而且多线程环境下也不会有问题。

3. 装饰器封装（让函数更明确依赖上下文） #

可以写一个装饰器，自动把上下文变量注入到函数参数里，这样函数本身还是保持显式参数，但调用时不用手动传递：

# 复用上面的contextvars变量
def require_something(func):
    def wrapper(*args, **kwargs):
        something = something_var.get()
        if something is None:
            raise RuntimeError("请在with get_something()上下文内调用此函数！")
        # 把上下文对象作为第一个参数传给原函数
        return func(something, *args, **kwargs)
    return wrapper

然后do_other_things()可以写成：

@require_something
def do_other_things(something):
    print(something)

调用时依然不用传参：

with get_something() as something:
    do_other_things()  # 装饰器自动注入上下文对象

最后想说的话 #

虽然这些方法能实现隐式传递，但Python的设计哲学是「显式优于隐式」。隐式传递上下文对象会让代码的依赖关系变得模糊，调试时更难追踪变量来源。除非你有大量函数需要频繁访问这个上下文对象，否则显式传递参数其实是更清晰、更易维护的选择。

内容的提问来源于stack exchange，提问作者spmsh