Dlaczego ustawić metodę ograniczoną do obiektu Pythona utworzyć odwołanie cykliczne?

Question

Pracuję w Pythonie 2.7 i lubię ten problem, który mnie zastanawia.

To najprostszy przykład:

>>> class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

>>> a = A() 
>>> del a 
DEL 

To jest OK, jak oczekiwano ... teraz próbuję zmienić metodę obiektu aa() i co się stało jest to, że po zmianie to nie mogę usuwać a więcej:

>>> a = A() 
>>> a.a = a.a 
>>> del a 

Wystarczy zrobić kilka czeków mam przed i po cesji wydrukować odniesienie a.a

>>> a = A() 
>>> print a.a 
<bound method A.a of <__main__.A object at 0xe86110>> 
>>> a.a = a.a 
>>> print a.a 
<bound method A.a of <__main__.A object at 0xe86110>> 

końcu użyłem modułu objgraph aby spróbować zrozumieć, dlaczego obiekt nie zostanie wydany:

>>> b = A() 
>>> import objgraph 
>>> objgraph.show_backrefs([b], filename='pre-backref-graph.png') 

>>> b.a = b.a 
>>> objgraph.show_backrefs([b], filename='post-backref-graph.png') 

Jak widać w post-backref-graph.png obrazie jest odniesienie __self__ w b, które nie mają dla mnie sensu, ponieważ self r Metodę metody instance należy zignorować (tak jak przed przypisaniem).

Ktoś może wyjaśnić, dlaczego to zachowanie i jak mogę obejść go?

Answer 1

Kiedy piszesz a.a, skutecznie działa:

A.a.__get__(a, A) 

ponieważ nie jesteś dostępu do pre-bound metodę ale klasy metodę który jest związany w czasie wykonywania.

Kiedy robisz

a.a = a.a 

skutecznie "cache" akt wiążący sposób. Ponieważ związana metoda ma odniesienie do obiektu (oczywiście, ponieważ musi przejść do funkcji self), tworzy to odwołanie cykliczne.

---

Więc jestem modelowania problemu jak:

class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

def log_all_calls(function): 
    def inner(*args, **kwargs): 
     print("Calling {}".format(function)) 

     try: 
      return function(*args, **kwargs) 
     finally: 
      print("Called {}".format(function)) 

    return inner 

a = A() 
a.a = log_all_calls(a.a) 

a.a() 

Można użyć słabe odwołania do związania na żądanie wewnątrz lof_all_calls jak:

import weakref 

class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

def log_all_calls_weakmethod(method): 
    cls = method.im_class 
    func = method.im_func 
    instance_ref = weakref.ref(method.im_self) 
    del method 

    def inner(*args, **kwargs): 
     instance = instance_ref() 

     if instance is None: 
      raise ValueError("Cannot call weak decorator with dead instance") 

     function = func.__get__(instance, cls) 

     print("Calling {}".format(function)) 

     try: 
      return function(*args, **kwargs) 
     finally: 
      print("Called {}".format(function)) 

    return inner 

a = A() 
a.a = log_all_calls_weakmethod(a.a) 

a.a() 

To jest naprawdę brzydka, więc wolałby go wydobyć, aby wykonać dekorator: weakmethod:

import weakref 

def weakmethod(method): 
    cls = method.im_class 
    func = method.im_func 
    instance_ref = weakref.ref(method.im_self) 
    del method 

    def inner(*args, **kwargs): 
     instance = instance_ref() 

     if instance is None: 
      raise ValueError("Cannot call weak method with dead instance") 

     return func.__get__(instance, cls)(*args, **kwargs) 

    return inner 

class A(object): 
    def __del__(self): 
     print("DEL") 
    def a(self): 
     pass 

def log_all_calls(function): 
    def inner(*args, **kwargs): 
     print("Calling {}".format(function)) 

     try: 
      return function(*args, **kwargs) 
     finally: 
      print("Called {}".format(function)) 

    return inner 

a = A() 
a.a = log_all_calls(weakmethod(a.a)) 

a.a() 

Gotowe!

---

FWIW to nie tylko Python 3.4 nie ma tych problemów, ma też wbudowaną wersję dla Ciebie.

Answer 2

Odpowiedź Veedrac na temat metody związanej z odniesieniem do instancji jest tylko częścią odpowiedzi. garbage collector CPython za umie wykryć i obsługiwać odwołań cyklicznych - z wyjątkiem, gdy jakiś obiekt, który jest częścią cyklu ma metodę __del__, jak wspomniano tutaj https://docs.python.org/2/library/gc.html#gc.garbage:

obiektów, które __del__() metod i są częścią cyklu odniesienia powoduje, że cały cykl odniesienia jest nieodgrywalny, w tym obiekty niekoniecznie w cyklu, ale dostępne tylko z niego. Python nie zbiera takich cykli automatycznie, ponieważ, ogólnie rzecz biorąc, , nie jest możliwe, aby Python odgadł bezpieczną kolejność wykonywania metod. (...) Zasadniczo lepiej jest uniknąć problemu, nie tworząc cykli zawierających obiekty metodami __del__(), a śmieci można w tym przypadku sprawdzić, aby sprawdzić, czy nie zostały utworzone takie cykle.

IOW: usuń swoją metodę __del__, a wszystko powinno być w porządku.

EDIT: wrt/komentarz:

Używam go na obiekt jako funkcja a.a = functor(a.a). Po wykonaniu testu chciałbym zastąpić funktor oryginalną metodą.

Wtedy rozwiązaniem jest jasne i proste:

a = A() 
a.a = functor(a.a) 
test(a) 
del a.a 

Dopóki jawnie wiążą go, a ma żadnego „a” instancja atribute, więc spojrzał na klasy i nowa method instancja jest zwracana (Aby uzyskać więcej informacji na ten temat, patrz: https://wiki.python.org/moin/FromFunctionToMethod). Ta instancja method jest następnie wywoływana i (zwykle) odrzucana.

Answer 3

Co do tego, dlaczego Python to robi. Technicznie wszystkie obiekty zawierają odwołania kołowe, jeśli mają metody. Jednak odśmiecanie może potrwać znacznie dłużej, jeśli odśmiecacz musiałby przeprowadzić jawne kontrole metod obiektów, aby upewnić się, że zwolnienie obiektu nie spowoduje problemu. W związku z tym Python przechowuje metody oddzielnie od obiektu __dict__. Tak więc, pisząc a.a = a.a, śledzisz metodę samą w sobie w polu a obiektu. W związku z tym istnieje wyraźne odniesienie do metody, która zapobiega właściwemu uwolnieniu obiektu.

Rozwiązaniem twojego problemu nie jest zachowywanie "pamięci podręcznej" oryginalnej metody i po prostu usunięcie zmiennej shadowed, gdy skończysz. Spowoduje to wyłączenie metody i udostępnienie jej ponownie.

>>> class A(object): 
...  def __del__(self): 
...   print("del") 
...  def method(self): 
...   print("method") 
>>> a = A() 
>>> vars(a) 
{} 
>>> "method" in dir(a) 
True 
>>> a.method = a.method 
>>> vars(a) 
{'method': <bound method A.method of <__main__.A object at 0x0000000001F07940>>} 
>>> "method" in dir(a) 
True 
>>> a.method() 
method 
>>> del a.method 
>>> vars(a) 
{} 
>>> "method" in dir(a) 
True 
>>> a.method() 
method 
>>> del a 
del 

Tutaj vars pokazuje, co jest w atrybucie obiektu __dict__. Zwróć uwagę, że __dict__ nie zawiera odniesienia do samej siebie, nawet jeśli a.__dict__ jest prawidłowe. dir tworzy listę wszystkich atrybutów osiągalnych z danego obiektu. Tutaj widzimy wszystkie atrybuty i metody obiektu oraz wszystkie metody i atrybuty jego klas i ich podstawy.To pokazuje, że związana metoda a jest przechowywana w miejscu oddzielnym, gdzie przechowywane są atrybuty a.