Mehrere Variablen in einer 'with'-Anweisung?

Ist es möglich, mehr als eine Variable mit a zu deklarieren? with Anweisung in Python ?

Etwas wie:

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)

... oder ist es das Problem, zwei Ressourcen gleichzeitig zu bereinigen?

Es ist in Python 3 seit v3.1 und Python 2.7 möglich . Die neue withSyntax unterstützt mehrere Kontextmanager:

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

Im Gegensatz zum contextlib.nestedgarantiert dies, dass aund bwird ihre __exit__()aufgerufen, auch wenn C()oder seine __enter__()Methode eine Ausnahme auslöst.

Sie können auch frühere Variablen in späteren Definitionen verwenden (h / t Ahmad unten):

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

contextlib.nested unterstützt dies:

import contextlib

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

   ...

Update:
Um die Dokumentation zu zitieren, betreffend contextlib.nested:

Veraltet seit Version 2.7 : Die with-Anweisung unterstützt diese Funktionalität jetzt direkt (ohne die verwirrenden fehleranfälligen Macken).

Siehe Rafał Dowgird Antwort für weitere Informationen.

Beachten Sie, dass Sie beim Aufteilen der Variablen in Zeilen Backslashes verwenden müssen, um die Zeilenumbrüche zu umbrechen.

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

Klammern funktionieren nicht, da Python stattdessen ein Tupel erstellt.

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

Da Tupeln ein __enter__Attribut fehlt , erhalten Sie einen Fehler (nicht beschreibend und identifiziert den Klassentyp nicht):

AttributeError: __enter__

Wenn Sie versuchen, asin Klammern zu verwenden, fängt Python den Fehler beim Analysieren ab:

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

SyntaxError: Ungültige Syntax

https://bugs.python.org/issue12782 scheint mit diesem Problem in Zusammenhang zu stehen.

Ich denke, Sie möchten dies stattdessen tun:

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)

Seit Python 3.3 können Sie die Klasse ExitStackaus dem contextlibModul verwenden.

Es kann eine dynamische Anzahl kontextsensitiver Objekte verwalten, was bedeutet, dass es sich als besonders nützlich erweist, wenn Sie nicht wissen, wie viele Dateien Sie verarbeiten werden.

Der in der Dokumentation erwähnte kanonische Anwendungsfall ist die Verwaltung einer dynamischen Anzahl von Dateien.

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

Hier ist ein allgemeines Beispiel:

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)

Ausgabe:

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]

In Python 3.1+ können Sie mehrere Kontextausdrücke angeben, die so verarbeitet werden, als wären mehrere withAnweisungen verschachtelt:

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

ist äquivalent zu

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

Dies bedeutet auch, dass Sie den Alias ​​aus dem ersten Ausdruck im zweiten verwenden können (nützlich, wenn Sie mit Datenbankverbindungen / Cursorn arbeiten):

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