Je ne comprends pas ce comportement de python del

vous ne pouvez pas supposer que __del__ sera jamais appelé - ce n'est pas un endroit pour espérer que les ressources sont automatiquement désallouées. Si vous voulez vous assurer qu'une ressource (Non-mémoire) est libérée, vous devez faire une release() ou méthode similaire et ensuite appeler explicitement (ou l'utiliser dans un context manager comme souligné par Thanatos dans les commentaires ci-dessous).

au moins, vous devriez lire le __del__ documentation très proche, et alors vous ne devriez probablement pas essayer d'utiliser __del__ . (Se référer également à la gc.garbage documentation pour d'autres mauvaises choses au sujet de __del__ )

au lieu de del , vous pouvez utiliser l'opérateur with .

http://effbot.org/zone/python-with-statement.htm

tout comme avec les objets filetype, vous pouvez quelque chose comme

with Dummy('d1') as d:
    #stuff
#d is guaranteed to be out of scope

del ne pas appeler __del__

del dans la façon dont vous utilisez supprime une variable locale. __del__ est appelée lorsque l'objet est détruit. Python en tant que langage ne donne aucune garantie quant au moment où il détruira un objet.

CPython comme l'implémentation la plus courante de Python, utilise le comptage de référence. En conséquence, del fonctionnera souvent comme vous l'attendez. Cependant, il ne fonctionnera pas dans le cas que vous avez une référence cycle.

d3 -> d3.func -> d3

Python ne détecte pas cela et ne nettoie pas tout de suite. Et pas seulement des cycles de référence. Si une exception est jeter vous voulez probablement encore appeler votre destructeur. Cependant, Python conservera généralement les variables locales dans le cadre de son traceback.

la solution ne doit pas dépendre de la méthode __del__ . Utilisez plutôt un gestionnaire de contexte.

class Dummy:
   def __enter__(self):
       return self

   def __exit__(self, type, value, traceback):
       print "Destroying", self

with Dummy() as dummy:
    # Do whatever you want with dummy in here
# __exit__ will be called before you get here

cela est garanti à travailler, et vous pouvez même vérifier les paramètres pour voir si vous manipulez une exception et faire quelque chose de différent dans ce cas.

un exemple complet de gestionnaire de contexte.

class Dummy(object):
    def __init__(self, name):
        self.name = name
    def __enter__(self):
        return self
    def __exit__(self, exct_type, exce_value, traceback):
        print 'cleanup:', d
    def __repr__(self):
        return 'Dummy(%r)' % (self.name,)

with Dummy("foo") as d:
    print 'using:', d

print 'later:', d

Il me semble que le véritable cœur de la question est ici:

ajouter les fonctions est dynamique (à l'exécution) et non connu à l'avance

je sens que ce que vous recherchez vraiment est une manière flexible de lier différentes fonctionnalités à un objet représentant un État de programme, également connu sous le nom de polymorphisme. Python le fait très bien, pas en attachant/détachant des méthodes, mais en instanciant différentes classes. Je suggère regardez à nouveau votre organisation de classe. Peut-être avez-vous besoin de séparer un objet de données principal, persistant des objets d'état transitoire. Utilisez le a-a paradigme plutôt que est-a: chaque fois que l'état change, vous envelopper les données du noyau dans un objet d'état, ou vous assignez le nouvel objet d'État à un attribut du noyau.

si vous êtes sûr que vous ne pouvez pas utiliser ce genre de Pythonic OOP, vous pouvez toujours travailler autour de votre problème un autre en définissant toutes vos fonctions dans la classe pour commencer et en les liant ensuite à des attributs d'instance supplémentaires (à moins que vous compiliez ces fonctions à la volée à partir de l'entrée de l'utilisateur):

class LongRunning(object):
    def bark_loudly(self):
        print("WOOF WOOF")

    def bark_softly(self):
        print("woof woof")


while True:
    d = LongRunning()
    d.bark = d.bark_loudly
    d.bark()

    d.bark = d.bark_softly
    d.bark()

une solution alternative à l'utilisation de weakref est de lier dynamiquement la fonction à l'instance seulement quand elle est appelée en remplaçant __getattr__ ou __getattribute__ sur la classe pour retourner func.__get__(self, type(self)) au lieu de juste func pour les fonctions liées à l'instance. C'est ainsi que se comportent les fonctions définies sur la classe. Malheureusement (pour certains cas d'utilisation) python n'exécute pas la même logique pour les fonctions attachées à l'instance elle-même, mais vous pouvez la modifier pour le faire. J'ai avait des problèmes similaires avec des descripteurs liés à des instances. La Performance ici n'est probablement pas aussi bonne que d'utiliser weakref , mais c'est une option qui fonctionnera de manière transparente pour toute fonction assignée dynamiquement avec l'utilisation de seulement des builtins python.

si vous vous trouvez à faire cela souvent, vous pourriez vouloir un metaclass personnalisé qui fait la liaison dynamique des fonctions de niveau d'instance.

une Autre alternative est d'ajouter la fonction directement à l' classe, qui exécutera alors correctement la reliure quand il est appelé. Pour beaucoup de cas d'utilisation, cela aurait quelques maux de tête impliqués: à savoir, correctement namespace les fonctions afin qu'elles ne se heurtent pas. L'id d'instance pourrait être utilisé pour cela, mais, depuis que l'id disponible n'est pas garantie unique sur la durée de vie du programme, vous aurez besoin de réfléchir un peu pour s'assurer qu'il fonctionne pour votre cas d'utilisation... en particulier, vous devez probablement vous assurer que vous supprimez la fonction de classe quand un objet va out of scope, et donc son adresse id/memory est à nouveau disponible. __del__ est parfait pour ça :). Alternativement, vous pouvez effacer toutes les méthodes namespaced à l'instance sur la création d'objet (dans __init__ ou __new__ ).

une autre alternative (plutôt que de jouer avec les méthodes magiques de python) est d'ajouter explicitement une méthode pour appeler vos fonctions liées dynamiquement. Ceci a l'inconvénient que vos utilisateurs ne peuvent pas appeler votre fonction en utilisant python normal syntaxe:

class MyClass(object):
    def dynamic_func(self, func_name):
        return getattr(self, func_name).__get__(self, type(self))

    def call_dynamic_func(self, func_name, *args, **kwargs):
        return getattr(self, func_name).__get__(self, type(self))(*args, **kwargs)

    """
    Alternate without using descriptor functionality:
    def call_dynamic_func(self, func_name, *args, **kwargs):
        return getattr(self, func_name)(self, *args, **kwargs)
    """

Juste pour faire de ce post, je vais vous montrer votre weakref option:

import weakref
inst = MyClass()
def func(self):
    print 'My func'
#  You could also use the types modules, but the descriptor method is cleaner IMO
inst.func = func.__get__(weakref.ref(inst), type(inst))