Pythonic способ создания контекстных менеджеров для объектов, принадлежащих классу

Ваш второй пример-самый прямой способ сделать это в На Python (т. е. наиболее подходящие для Python). Однако в вашем примере все еще есть ошибка. Если исключение возникает во время второй open(),

self.i = self.enter_context(open(self.in_file_name, 'r')
self.o = self.enter_context(open(self.out_file_name, 'w') # <<< HERE

Тогда self.i не будет выпущен, когда вы ожидаете, потому что Foo.__exit__() не будет вызван, если Foo.__enter__() успешно возвращается. Чтобы исправить это, оберните каждый вызов контекста в попробуйте-за исключением того, что вызовет Foo.__exit__(), когда произойдет исключение.

import contextlib
import sys

class Foo(contextlib.ExitStack):

    def __init__(self, in_file_name, out_file_name):
        super().__init__()
        self.in_file_name = in_file_name
        self.out_file_name = out_file_name

    def __enter__(self):
        super().__enter__()

        try:
            # Initialize sub-context objects that could raise exceptions here.
            self.i = self.enter_context(open(self.in_file_name, 'r'))
            self.o = self.enter_context(open(self.out_file_name, 'w'))

        except:
            if not self.__exit__(*sys.exc_info()):
                raise

        return self

Как упоминал @cpburnz, ваш последний пример лучше, но содержит ошибку, если второй открытый не удается. Устранение этой ошибки описано в документации стандартной библиотеки. Мы можем легко адаптировать фрагменты кода из документации ExitStack и пример для ResourceManager из 29.6.2.4 очистки в реализации __enter__ , чтобы получить класс MultiResourceManager:

from contextlib import contextmanager, ExitStack
class MultiResourceManager(ExitStack):
    def __init__(self, resources, acquire_resource, release_resource,
            check_resource_ok=None):
        super().__init__()
        self.acquire_resource = acquire_resource
        self.release_resource = release_resource
        if check_resource_ok is None:
            def check_resource_ok(resource):
                return True
        self.check_resource_ok = check_resource_ok
        self.resources = resources
        self.wrappers = []

    @contextmanager
    def _cleanup_on_error(self):
        with ExitStack() as stack:
            stack.push(self)
            yield
            # The validation check passed and didn't raise an exception
            # Accordingly, we want to keep the resource, and pass it
            # back to our caller
            stack.pop_all()

    def enter_context(self, resource):
        wrapped = super().enter_context(self.acquire_resource(resource))
        if not self.check_resource_ok(wrapped):
            msg = "Failed validation for {!r}"
            raise RuntimeError(msg.format(resource))
        return wrapped

    def __enter__(self):
        with self._cleanup_on_error():
            self.wrappers = [self.enter_context(r) for r in self.resources]
        return self.wrappers

    # NB: ExitStack.__exit__ is already correct

Теперь ваш класс Foo() тривиален:

import io
class Foo(MultiResourceManager):
    def __init__(self, *paths):
        super().__init__(paths, io.FileIO, io.FileIO.close)

Это хорошо, потому что нам ничего не нужно. попробуйте-за исключением блоков - вы, вероятно, используете только ContextManagers, чтобы избавиться от них в первую очередь!

Тогда вы можете использовать его, как вы хотели (Примечание MultiResourceManager.__enter__ возвращает список объектов, заданных переданным acquire_resource ()):

if __name__ == '__main__':
    open('/tmp/a', 'w').close()
    open('/tmp/b', 'w').close()

    with Foo('/tmp/a', '/tmp/b') as (f1, f2):
        print('opened {0} and {1}'.format(f1.name, f2.name))

Мы можем заменить io.FileIO на debug_file, как в следующем фрагменте, чтобы увидеть его в действии:

    class debug_file(io.FileIO):
        def __enter__(self):
            print('{0}: enter'.format(self.name))
            return super().__enter__()
        def __exit__(self, *exc_info):
            print('{0}: exit'.format(self.name))
            return super().__exit__(*exc_info)

Тогда мы видим:

/tmp/a: enter
/tmp/b: enter
opened /tmp/a and /tmp/b
/tmp/b: exit
/tmp/a: exit

Если бы мы добавили import os; os.unlink('/tmp/b') непосредственно перед циклом, мы бы увидели:

/tmp/a: enter
/tmp/a: exit
Traceback (most recent call last):
  File "t.py", line 58, in <module>
    with Foo('/tmp/a', '/tmp/b') as (f1, f2):
  File "t.py", line 46, in __enter__
    self.wrappers = [self.enter_context(r) for r in self.resources]
  File "t.py", line 46, in <listcomp>
    self.wrappers = [self.enter_context(r) for r in self.resources]
  File "t.py", line 38, in enter_context
    wrapped = super().enter_context(self.acquire_resource(resource))
FileNotFoundError: [Errno 2] No such file or directory: '/tmp/b'

Вы можете видеть, что /tmp / a закрыт правильно.

Я думаю, что использовать помощника лучше:

from contextlib import ExitStack, contextmanager

class Foo:
    def __init__(self, i, o):
        self.i = i
        self.o = o

@contextmanager
def multiopen(i, o):
    with ExitStack() as stack:
        i = stack.enter_context(open(i))
        o = stack.enter_context(open(o))
        yield Foo(i, o)

Использование близко к родному open:

with multiopen(i_name, o_name) as foo:
    pass

Ну, если вы хотите обрабатывать конечно для обработчиков файлов, самое простое решение-это просто передать обработчики файлов непосредственно в ваш класс вместо имен файлов.

with open(f1, 'r') as f1, open(f2, 'w') as f2:
   with MyClass(f1, f2) as my_obj:
       ...

Если вам не нужны пользовательские функции __exit__, Вы можете даже пропустить вложенные функции.

Если вы действительно хотите передать имена файлов в __init__, Ваша проблема может быть решена следующим образом:

class MyClass:
     input, output = None, None

     def __init__(self, input, output):
         try:
             self.input = open(input, 'r')
             self.output = open(output, 'w')
         except BaseException as exc:
             self.__exit___(type(exc), exc, exc.__traceback__)
             raise

     def __enter__(self):
         return self

     def __exit__(self, *args):
            self.input and self.input.close()
            self.output and self.output.close()
        # My custom __exit__ code

Итак, это действительно зависит от вашей задачи, у python есть много вариантов для работы. В конце концов-питонский способ сохранить ваш api прост.