“with”中的多个变量 陈述？

Question

是否可以在 Python 中使用 with 语句声明多个变量？

比如：

from __future__ import with_statement

with open("out.txt","wt"), open("in.txt") as file_out, file_in:
    for line in file_in:
        file_out.write(line)

...或者同时清理两个资源是问题所在？

Answer 1

Python 3 自 v3.1 和 Python 2.7。 新的 with 语法支持多个上下文管理器：

with A() as a, B() as b, C() as c:
    doSomething(a,b,c)

与 contextlib.nested 不同，这保证 a 和 b 将拥有其 __exit__()C() 或其 __enter__() 方法引发异常，> 也会被调用。

您还可以在后面的定义中使用前面的变量 (h/t Ahmad下面）：

with A() as a, B(a) as b, C(a, b) as c:
    doSomething(a, c)

从 Python 3.10 开始，您可以使用括号：

with (
    A() as a, 
    B(a) as b, 
    C(a, b) as c,
):
    doSomething(a, c)

Answer 2

请注意，如果将变量拆分为行，则在 Python 3.10 之前，必须使用反斜杠来换行。

with A() as a, \
     B() as b, \
     C() as c:
    doSomething(a,b,c)

括号不起作用，因为 Python 创建了一个元组。

with (A(),
      B(),
      C()):
    doSomething(a,b,c)

由于元组缺少 __enter__ 属性，因此您会收到错误（非描述性且无法识别类类型）：

属性错误：__enter__ 
  

如果您尝试在括号内使用 as，Python 将在解析时捕获错误：

with (A() as a,
      B() as b,
      C() as c):
    doSomething(a,b,c)

SyntaxError：语法无效 
  

这个问题什么时候能修复？

此问题在 https://bugs.python.org/issue12782 中跟踪。

Python 在 PEP 617 中宣布他们将用新的解析器替换原来的解析器。 因为Python的原始解析器是LL(1)，所以它 无法区分“多个上下文管理器”with (A(), B()): 和“元组值”with (A(), B())[0]：。

新的解析器可以正确解析括号包围的多个上下文管理器。 新的解析器已在 3.9 中启用。 据报道，在 Python 3.10 中删除旧解析器之前，此语法仍将被拒绝，并且此语法更改已在 3.10 发行说明。 但在我的测试中，它也适用于 trinket.io 的 Python 3.9.6。

Answer 3

contextlib.nested 支持此功能：

import contextlib

with contextlib.nested(open("out.txt","wt"), open("in.txt")) as (file_out, file_in):

   ...

更新：
引用文档，关于 contextlib.nested< /a>:

自版本 2.7 起已弃用：with 语句现在支持此功能
直接使用功能（没有令人困惑的容易出错的怪癖）。

有关更多信息，请参阅Rafał Dowgird 的回答。

Answer 4

从Python 3.3开始，您可以使用类 ExitStack 来自 contextlib 模块。

它可以管理动态数量的上下文感知对象，这意味着如果您不知道要处理多少个文件，它将特别有用。

文档中提到的规范用例是管理动态数量的文件。

with ExitStack() as stack:
    files = [stack.enter_context(open(fname)) for fname in filenames]
    # All opened files will automatically be closed at the end of
    # the with statement, even if attempts to open files later
    # in the list raise an exception

这是一个通用示例：

from contextlib import ExitStack

class X:
    num = 1

    def __init__(self):
        self.num = X.num
        X.num += 1

    def __repr__(self):
        cls = type(self)
        return '{cls.__name__}{self.num}'.format(cls=cls, self=self)

    def __enter__(self):
        print('enter {!r}'.format(self))
        return self.num

    def __exit__(self, exc_type, exc_value, traceback):
        print('exit {!r}'.format(self))
        return True

xs = [X() for _ in range(3)]

with ExitStack() as stack:
    print(stack._exit_callbacks)
    nums = [stack.enter_context(x) for x in xs]
    print(stack._exit_callbacks)
print(stack._exit_callbacks)
print(nums)

输出：

deque([])
enter X1
enter X2
enter X3
deque([<function ExitStack._push_cm_exit.<locals>._exit_wrapper at 0x7f5c95f86158>, <function ExitStack._push_cm_exit.<locals>._exit_wrapper at 0x7f5c95f861e0>, <function ExitStack._push_cm_exit.<locals>._exit_wrapper at 0x7f5c95f86268>])
exit X3
exit X2
exit X1
deque([])
[1, 2, 3]

Answer 5

我想你想这样做：

from __future__ import with_statement

with open("out.txt","wt") as file_out:
    with open("in.txt") as file_in:
        for line in file_in:
            file_out.write(line)

Answer 6

从 Python 3.10 开始，有一个新功能 括号上下文管理器，它允许如下语法：

with (
    A() as a,
    B() as b
):
    do_something(a, b)

Answer 7

在 Python 3.1+ 中，您可以指定多个上下文表达式，它们将被视为嵌套了多个 with 语句：

with A() as a, B() as b:
    suite

相当于

with A() as a:
    with B() as b:
        suite

这也意味着您可以在第二个表达式中使用第一个表达式中的别名（在使用数据库连接/游标时很有用）：

with get_conn() as conn, conn.cursor() as cursor:
    cursor.execute(sql)

Answer 8

您还可以单独创建上下文管理器（__init__方法）并输入上下文（__init__方法） >__enter__ 方法）以增加可读性。 编写以下代码，而不是编写

with Company(name, id) as company, Person(name, age, gender) as person, Vehicle(brand) as vehicle:
    pass

因此，您可以

company = Company(name, id)
person = Person(name, age, gender)
vehicle = Vehicle(brand)

with company, person, vehicle:
    pass

此代码：请注意，在 with 语句之外创建上下文管理器会让人觉得所创建的对象也可以在该语句之外进一步使用。 如果您的上下文管理器不是这样，则错误的印象可能会与可读性尝试相对应。

文档说：

大多数上下文管理器的编写方式意味着它们只能在 with 语句中有效使用一次。 这些单次使用上下文管理器必须在每次使用时重新创建 - 尝试第二次使用它们将触发异常或无法正常工作。

这种常见限制意味着通常建议直接在使用上下文管理器的 with 语句的标头中创建上下文管理器。