Como faço para limpar corretamente um objeto Python?

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

    # ...

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

__del__(self)acima falha com uma exceção AttributeError. Entendo que o Python não garante a existência de "variáveis ​​globais" (dados de membros neste contexto?) Quando __del__()é invocado. Se for esse o caso e esse for o motivo da exceção, como posso garantir que o objeto seja destruído corretamente?

Eu recomendo usar a withdeclaração do Python para gerenciar recursos que precisam ser limpos. O problema com o uso de uma close()declaração explícita é que você precisa se preocupar com as pessoas que se esquecem de chamá-la ou se esquecem de colocá-la em um finallybloco para evitar que um recurso vaze quando ocorrer uma exceção.

Para usar a withinstrução, crie uma classe com os seguintes métodos:

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

No seu exemplo acima, você usaria

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)

Então, quando alguém quisesse usar sua classe, faria o seguinte:

with Package() as package_obj:
    # use package_obj

A variável package_obj será uma instância do tipo Package (é o valor retornado pelo __enter__método). Seu __exit__método será chamado automaticamente, independentemente de ocorrer ou não uma exceção.

Você pode até levar essa abordagem um passo adiante. No exemplo acima, alguém ainda pode instanciar o Package usando seu construtor sem usar a withcláusula Você não quer que isso aconteça. Você pode corrigir isso criando uma classe PackageResource que define o __enter__e __exit__métodos. Em seguida, a classe Package seria definida estritamente dentro do __enter__método e retornada. Dessa forma, o chamador nunca poderia instanciar a classe Package sem usar uma withinstrução:

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()

Você usaria isso da seguinte maneira:

with PackageResource() as package_obj:
    # use package_obj

A maneira padrão é usar 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)

Mas você deve ter em mente que isso persistirá em todas as instâncias criadas Packageaté que o Python seja encerrado.

Demonstração usando o código acima salvo como 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...

Como um apêndice à resposta de Clint , você pode simplificar PackageResourceusando contextlib.contextmanager:

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

Como alternativa, embora provavelmente não seja Pythonic, você pode substituir 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):
        ...

e simplesmente use with Package(...) as package.

Para simplificar , nomeie sua função de limpeza closee use contextlib.closing; nesse caso, você pode usar a Packageclasse não modificada with contextlib.closing(Package(...))ou substituí __new__-la pela mais simples

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

E esse construtor é herdado, então você pode simplesmente herdar, por exemplo

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

Eu não acho que é possível, por exemplo, remover membros antes de __del__ser chamado. Meu palpite seria que o motivo do seu AttributeError específico está em outro lugar (talvez você remova o self.file por engano em outro lugar).

No entanto, como os outros apontaram, você deve evitar o uso __del__. A principal razão para isso é que as instâncias com __del__não serão coletadas como lixo (elas serão liberadas somente quando a contagem de refechas chegar a 0). Portanto, se suas instâncias estiverem envolvidas em referências circulares, elas permanecerão na memória enquanto o aplicativo for executado. (Posso estar enganado sobre tudo isso, porém, eu precisaria ler os documentos do gc novamente, mas tenho certeza de que funciona assim).

Uma alternativa melhor é usar o fracoref.finalize . Veja os exemplos em Objetos do finalizador e Comparando finalizadores com os métodos __del __ () .

Eu acho que o problema poderia estar __init__se houver mais código do que o mostrado?

__del__será chamado mesmo quando __init__não for executado corretamente ou gerou uma exceção.

Fonte

Aqui está um esqueleto de trabalho mínimo:

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()

Importante: retornar a si mesmo

Se você é como eu, e ignora a return selfparte (da resposta correta de Clint Miller ), estará olhando para essa bobagem:

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

Espero que ajude a próxima pessoa.

Apenas envolva seu destruidor com uma instrução try / except e ela não emitirá uma exceção se seus globais já estiverem descartados.

Editar

Tente o seguinte:

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

Ele irá preencher a lista de arquivos na função del que é garantida a existência no momento da chamada. O proxy weakref é impedir que o Python ou você mesmo exclua a variável self.files de alguma forma (se for excluída, não afetará a lista de arquivos original). Se não for o caso de isso estar sendo excluído, mesmo que haja mais referências à variável, você poderá remover o encapsulamento do proxy.

Parece que a maneira idiomática de fazer isso é fornecer um close()método (ou similar) e chamá-lo explicitamente.