Plusieurs variables dans une instruction «avec»?

Est-il possible de déclarer plusieurs variables à l'aide d'une withinstruction en Python?

Quelque chose comme:

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)

... ou nettoyer deux ressources en même temps est-il le problème?

C'est possible dans Python 3 depuis la v3.1 et Python 2.7 . La nouvelle withsyntaxe prend en charge plusieurs gestionnaires de contexte:

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

Contrairement à la contextlib.nested, cela garantit que aet baura leur __exit__()appelé même siC() la __enter__()méthode ou lève une exception.

Vous pouvez également utiliser des variables antérieures dans des définitions ultérieures (h / t Ahmad ci-dessous):

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

contextlib.nested soutient ceci:

import contextlib

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

   ...

Mise à jour:
Pour citer la documentation, concernantcontextlib.nested :

Déconseillé depuis la version 2.7 : l'instruction with prend désormais directement en charge cette fonctionnalité (sans les bizarreries sujettes à confusion).

Voir la réponse de Rafał Dowgird pour plus d'informations.

Notez que si vous divisez les variables en lignes, vous devez utiliser des barres obliques inversées pour encapsuler les nouvelles lignes.

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

Les parenthèses ne fonctionnent pas, car Python crée à la place un tuple.

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

Comme les tuples n'ont pas d' __enter__attribut, vous obtenez une erreur (non descriptive et n'identifie pas le type de classe):

AttributeError: __enter__

Si vous essayez d'utiliser asentre parenthèses, Python détecte l'erreur au moment de l'analyse:

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

ErreurDeSyntaxe: Syntaxe invalide

https://bugs.python.org/issue12782 semble être lié à ce problème.

Je pense que vous voulez le faire à la place:

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)

Depuis Python 3.3, vous pouvez utiliser la classe ExitStackdu contextlibmodule.

Il peut gérer un nombre dynamique d'objets contextuels, ce qui signifie qu'il s'avérera particulièrement utile si vous ne savez pas combien de fichiers vous allez gérer.

Le cas d'utilisation canonique mentionné dans la documentation gère un nombre dynamique de fichiers.

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

Voici un exemple générique:

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)

Production:

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]

Dans Python 3.1+, vous pouvez spécifier plusieurs expressions de contexte, et elles seront traitées comme si plusieurs withinstructions étaient imbriquées:

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

est équivalent à

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

Cela signifie également que vous pouvez utiliser l'alias de la première expression dans la seconde (utile lorsque vous travaillez avec des connexions / curseurs db):

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