Как правильно очистить объект Python?

class Package:
    def __init__(self):
        self.files = []

    # ...

    def __del__(self):
        for file in self.files:
            os.unlink(file)

__del__(self)выше не удается с исключением AttributeError. Я понимаю, что Python не гарантирует существование "глобальных переменных" (данные члена в этом контексте?), Когда __del__()вызывается. Если это так, и это является причиной исключения, как я могу убедиться, что объект разрушается должным образом?

Я бы рекомендовал использовать withоператор Python для управления ресурсами, которые необходимо очистить. Проблема с использованием явного close()выражения состоит в том, что вам нужно беспокоиться о людях, которые вообще не будут вызывать его или забывают поместить его в finallyблок, чтобы предотвратить утечку ресурсов при возникновении исключения.

Чтобы использовать withоператор, создайте класс с помощью следующих методов:

  def __enter__(self)
  def __exit__(self, exc_type, exc_value, traceback)

В вашем примере выше, вы бы использовали

class Package:
    def __init__(self):
        self.files = []

    def __enter__(self):
        return self

    # ...

    def __exit__(self, exc_type, exc_value, traceback):
        for file in self.files:
            os.unlink(file)

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

with Package() as package_obj:
    # use package_obj

Переменная package_obj будет экземпляром типа Package (это значение, возвращаемое __enter__методом). Его __exit__метод будет вызываться автоматически, независимо от того, происходит ли исключение.

Вы могли бы даже сделать этот подход еще дальше. В приведенном выше примере кто-то еще может создать экземпляр Package, используя его конструктор, не используя withпредложение. Вы не хотите, чтобы это произошло. Вы можете исправить это, создав класс PackageResource , который определяет __enter__и __exit__методы. Затем класс Package будет определен строго внутри __enter__метода и возвращен. Таким образом, вызывающая сторона никогда не сможет создать экземпляр класса Package без использования withинструкции:

class PackageResource:
    def __enter__(self):
        class Package:
            ...
        self.package_obj = Package()
        return self.package_obj

    def __exit__(self, exc_type, exc_value, traceback):
        self.package_obj.cleanup()

Вы бы использовали это следующим образом:

with PackageResource() as package_obj:
    # use package_obj

Стандартный способ заключается в использовании atexit.register:

# package.py
import atexit
import os

class Package:
    def __init__(self):
        self.files = []
        atexit.register(self.cleanup)

    def cleanup(self):
        print("Running cleanup...")
        for file in self.files:
            print("Unlinking file: {}".format(file))
            # os.unlink(file)

Но вы должны иметь в виду, что это будет сохраняться во всех созданных экземплярах Packageдо тех пор, пока Python не будет завершен.

Демонстрация с использованием приведенного выше кода, сохраненного как package.py :

$ python
>>> from package import *
>>> p = Package()
>>> q = Package()
>>> q.files = ['a', 'b', 'c']
>>> quit()
Running cleanup...
Unlinking file: a
Unlinking file: b
Unlinking file: c
Running cleanup...

В качестве приложения к ответу Клинта , можно упростить с PackageResourceпомощью contextlib.contextmanager:

@contextlib.contextmanager
def packageResource():
    class Package:
        ...
    package = Package()
    yield package
    package.cleanup()

В качестве альтернативы, хотя, вероятно, не как Pythonic, вы можете переопределить Package.__new__:

class Package(object):
    def __new__(cls, *args, **kwargs):
        @contextlib.contextmanager
        def packageResource():
            # adapt arguments if superclass takes some!
            package = super(Package, cls).__new__(cls)
            package.__init__(*args, **kwargs)
            yield package
            package.cleanup()

    def __init__(self, *args, **kwargs):
        ...

и просто использовать with Package(...) as package.

Короче говоря, назовите свою функцию очистки closeи используйте contextlib.closing, в этом случае вы можете использовать неизмененный Packageкласс через with contextlib.closing(Package(...))или переопределить его __new__на более простой

class Package(object):
    def __new__(cls, *args, **kwargs):
        package = super(Package, cls).__new__(cls)
        package.__init__(*args, **kwargs)
        return contextlib.closing(package)

И этот конструктор наследуется, так что вы можете просто наследовать, например,

class SubPackage(Package):
    def close(self):
        pass

Я не думаю, что члены экземпляра могут быть удалены до __del__вызова. Я предполагаю, что причина вашего конкретного AttributeError находится где-то еще (возможно, вы ошибочно удалили self.file в другом месте).

Однако, как отметили другие, вы должны избегать использования __del__ . Основная причина этого заключается в том, что экземпляры с __del__не будут собирать мусор (они будут освобождены только тогда, когда их рефконт достигнет 0). Поэтому, если ваши экземпляры участвуют в циклических ссылках, они будут жить в памяти до тех пор, пока выполняется приложение. (Хотя я могу ошибаться во всем этом, мне придется снова прочитать документы gc, но я уверен, что это работает так).

Лучшая альтернатива - это использовать weakref.finalize . См. Примеры в разделах Объекты финализатора и Сравнение финализаторов с методами __del __ () .

Я думаю, что проблема может быть в __init__ если есть больше кода, чем показано?

__del__ будет называться даже когда __init__ он не был выполнен должным образом или выдал исключение.

Источник

Вот минимальный рабочий скелет:

class SkeletonFixture:

    def __init__(self):
        pass

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass

    def method(self):
        pass


with SkeletonFixture() as fixture:
    fixture.method()

Важно: вернуть себя

Если вы похожи на меня и пропускаете return selfчасть ( правильного ответа Клинта Миллера ), вы будете пялиться на эту чушь:

Traceback (most recent call last):
  File "tests/simplestpossible.py", line 17, in <module>                                                                                                                                                          
    fixture.method()                                                                                                                                                                                              
AttributeError: 'NoneType' object has no attribute 'method'

Надеюсь, это поможет следующему человеку.

Просто оберните ваш деструктор оператором try / исключением, и он не выдаст исключение, если ваши глобальные переменные уже удалены.

редактировать

Попробуй это:

from weakref import proxy

class MyList(list): pass

class Package:
    def __init__(self):
        self.__del__.im_func.files = MyList([1,2,3,4])
        self.files = proxy(self.__del__.im_func.files)

    def __del__(self):
        print self.__del__.im_func.files

Он поместит список файлов в функцию del, которая гарантированно существует во время вызова. Прозрачный прокси-сервер запрещает Python или вам самим каким-либо образом удалять переменную self.files (если она будет удалена, это не повлияет на исходный список файлов). Если это не тот случай, когда он удаляется, хотя ссылок на переменную больше, вы можете удалить инкапсуляцию прокси.

Кажется, что идиоматический способ сделать это состоит в том, чтобы предоставить close()метод (или подобный), и вызвать его явно.