Как использовать менеджер контекста, чтобы избежать использования __del__ в python?

Я предлагаю использовать класс contextlib.contextmanager вместо написания класса, реализующего __enter__ и __exit__. Вот как это будет работать:

class MyWrapper(object):
    def __init__(self, device):
        self.device = device

    def open(self):
        self.device.open()

    def close(self):
        self.device.close()

    # I assume your device has a blink command
    def blink(self):
        # do something useful with self.device
        self.device.send_command(CMD_BLINK, 100)

    # there is no __del__ method, as long as you conscientiously use the wrapper

import contextlib

@contextlib.contextmanager
def open_device(device):
    wrapper_object = MyWrapper(device)
    wrapper_object.open()
    try:
        yield wrapper_object
    finally:
        wrapper_object.close()
    return

with open_device(device) as wrapper_object:
     # do something useful with wrapper_object
     wrapper_object.blink()

Строка, начинающаяся со знака at, называется декоратором. Он изменяет объявление функции на следующей строке.

Когда встречается оператор with, функция open_device() будет выполняться до оператора yield. Значение в операторе yield возвращается в переменной, которая является целью необязательного предложения as, в данном случае wrapper_object. После этого вы можете использовать это значение как обычный объект Python. Когда управление выходит из блока по любому пути, включая создание исключений, выполняется оставшееся тело функции open_device.

Я не уверен, что (а) ваш класс-оболочка добавляет функциональность к низкоуровневому API или (б) если это только то, что вы включаете, чтобы у вас мог быть менеджер контекста. Если (b), то вы, вероятно, можете полностью обойтись без него, поскольку contextlib позаботится об этом за вас. Вот как тогда может выглядеть ваш код:

import contextlib

@contextlib.contextmanager
def open_device(device):
    device.open()
    try:
        yield device
    finally:
        device.close()
    return

with open_device(device) as device:
     # do something useful with device
     device.send_command(CMD_BLINK, 100)

99% использования контекстного менеджера можно выполнить с помощью contextlib.contextmanager. Это чрезвычайно полезный класс API (и то, как он реализован, также представляет собой творческое использование низкоуровневой сантехники Python, если вам небезразличны такие вещи).

Проблема не в том, что вы используете его в классе, а в том, что вы хотите оставить устройство «открытым»: вы открываете его, а затем просто оставляете открытым. Контекстный менеджер предоставляет способ открыть некоторый ресурс и использовать его относительно коротким, ограниченным образом, убедившись, что он закрыт в конце. Ваш существующий код уже небезопасен, потому что, если произойдет какой-либо сбой, вы не можете гарантировать, что ваш __del__ будет вызван, поэтому устройство может остаться открытым.

Не зная точно, что это за устройство и как оно работает, трудно сказать больше, но основная идея заключается в том, что, если возможно, лучше открывать устройство только тогда, когда вам нужно его использовать, а затем сразу же закрывать. Итак, ваш processing — это то, что, возможно, нужно изменить на что-то вроде:

def processing(self, value):
     with self.device:
        if value:
            something_else()

Если self.device — правильно написанный менеджер контекста, он должен открывать устройство в __enter__ и закрывать его в __exit__. Это гарантирует, что устройство будет закрыто в конце блока with.

Конечно, для некоторых видов ресурсов это невозможно (например, потому что открытие и закрытие устройства теряет важное состояние или является медленной операцией). Если это ваш случай, вы застряли в использовании __del__ и живете с его ловушками. Основная проблема заключается в том, что нет надежного способа оставить устройство «открытым», но при этом гарантировать, что оно будет закрыто даже в случае какого-либо необычного сбоя программы.

Я не совсем уверен, что вы спрашиваете. Экземпляр диспетчера контекста может быть членом класса — вы можете повторно использовать его в любом количестве предложений with, а методы __enter__() и __exit__() будут вызываться каждый раз.

Итак, как только вы добавили эти методы в MyWrapper, вы можете создать его в MyClass так же, как и выше. И тогда вы бы сделали что-то вроде:

def my_method(self):
    with self.mydevice:
        # Do stuff here

Это вызовет методы __enter__() и __exit__() для экземпляра, созданного вами в конструкторе.

Однако предложение with может охватывать только функцию — если вы используете предложение with в конструкторе, оно вызовет __exit__() перед выходом из конструктора. Если вы хотите сделать это, единственный способ — использовать __del__(), у которого есть свои проблемы, как вы уже упоминали. Вы можете открывать и закрывать устройство, когда вам это нужно, используя with, но я не знаю, соответствует ли это вашим требованиям.