Múltiples variables en una declaración 'con'?

¿Es posible declarar más de una variable usando una withdeclaración en Python?

Algo como:

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)

... o es limpiar dos recursos al mismo tiempo el problema?

Es posible en Python 3 desde v3.1 y Python 2.7 . La nueva withsintaxis admite múltiples administradores de contexto:

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

A diferencia de la contextlib.nested, esto garantiza que ay btendrán su __exit__()'llama incluso si C()o no lo __enter__()método lanza una excepción.

También puede usar variables anteriores en definiciones posteriores (h / t Ahmad a continuación):

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

contextlib.nested apoya esto:

import contextlib

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

   ...

Actualización:
para citar la documentación, con respecto a contextlib.nested:

En desuso desde la versión 2.7 : la declaración with ahora admite esta funcionalidad directamente (sin los caprichos confusos propensos a errores).

Vea la respuesta de Rafał Dowgird para más información.

Tenga en cuenta que si divide las variables en líneas, debe usar barras invertidas para ajustar las nuevas líneas.

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

Los paréntesis no funcionan, ya que Python crea una tupla en su lugar.

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

Como las tuplas carecen de un __enter__atributo, obtienes un error (no descriptivo y no identifica el tipo de clase):

AttributeError: __enter__

Si intenta utilizarlo asentre paréntesis, Python detecta el error en el momento del análisis:

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

Error de sintaxis: sintaxis invalida

https://bugs.python.org/issue12782 parece estar relacionado con este problema.

Creo que quieres hacer esto en su lugar:

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)

Desde Python 3.3, puede usar la clase ExitStackdesde el contextlibmódulo.

Puede administrar una cantidad dinámica de objetos sensibles al contexto, lo que significa que resultará especialmente útil si no sabe cuántos archivos va a manejar.

El caso de uso canónico que se menciona en la documentación es administrar un número dinámico de archivos.

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

Aquí hay un ejemplo genérico:

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)

Salida:

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]

En Python 3.1+ puede especificar múltiples expresiones de contexto, y se procesarán como si se anidaran varias withdeclaraciones:

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

es equivalente a

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

Esto también significa que puede usar el alias de la primera expresión en la segunda (útil cuando se trabaja con conexiones / cursores db):

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