Più variabili in un'istruzione 'with'?

È possibile dichiarare più di una variabile usando withun'istruzione in Python?

Qualcosa di simile a:

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 il problema è ripulire due risorse contemporaneamente?

È possibile in Python 3 dalla v3.1 e Python 2.7 . La nuova withsintassi supporta più gestori di contesto:

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

A differenza di contextlib.nested, questo garantisce che ae bavranno il loro __exit__()nome anche se C()o il suo __enter__()metodo solleva un'eccezione.

Puoi anche usare le variabili precedenti nelle definizioni successive (h / t Ahmad sotto):

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

contextlib.nested supporta questo:

import contextlib

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

   ...

Aggiornamento:
per citare la documentazione relativa a contextlib.nested:

Obsoleto dalla versione 2.7 : l'istruzione with ora supporta direttamente questa funzionalità (senza le stranezze a rischio di errori).

Vedi la risposta di Rafał Dowgird per maggiori informazioni.

Nota che se dividi le variabili in linee, devi usare le barre rovesciate per avvolgere le nuove linee.

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

Le parentesi non funzionano, poiché Python crea invece una tupla.

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

Poiché alle tuple manca un __enter__attributo, viene visualizzato un errore (non descrittivo e non identifica il tipo di classe):

AttributeError: __enter__

Se si tenta di utilizzare astra parentesi, Python rileva l'errore al momento dell'analisi:

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

SyntaxError: sintassi non valida

https://bugs.python.org/issue12782 sembra essere collegato a questo problema.

Penso che tu voglia fare questo invece:

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)

Da Python 3.3, puoi usare la classe ExitStackdal contextlibmodulo.

Può gestire un numero dinamico di oggetti sensibili al contesto, il che significa che si rivelerà particolarmente utile se non sai quanti file gestirai.

Il caso d'uso canonico menzionato nella documentazione sta gestendo un numero dinamico di file.

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

Ecco un esempio generico:

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)

Produzione:

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+ è possibile specificare più espressioni di contesto, che verranno elaborate come se withfossero nidificate più istruzioni:

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

è equivalente a

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

Questo significa anche che puoi usare l'alias dalla prima espressione nella seconda (utile quando lavori con connessioni / cursori db):

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