जीसी WeakKeyDories में परिपत्र संदर्भ हटा नहीं है?

Question

मेरे पास एक ऐसी स्थिति है जिसमें मैं पहली वस्तु मौजूद होने तक एक ऑब्जेक्ट से दूसरे ऑब्जेक्ट में मैपिंग को बनाए रखना चाहता हूं। मेरा पहला विचार एक WeakKeyDictionary का उपयोग करना था।

import weakref 
import gc 

class M: 
    pass 

w = weakref.WeakKeyDictionary() 
m = M() 
w[m] = some_other_object 
del m 
gc.collect() 
print w.keys() 

यह ज्यादातर मामलों में ठीक काम करता है। हालांकि, उस मामले में जहां some_other_objectm है (या इसका संदर्भ है) M उदाहरण कचरा एकत्र नहीं किया जाएगा। (एक उदाहरण देखने के लिए, m साथ some_other_object की जगह)

बेशक

, अगर मैं वस्तु पर ही मानचित्रण संग्रहीत, यह कचरा एकत्र किया जाएगा जब मैं इसे नष्ट कर दिया:

import weakref 
import gc 

class M: 
    pass 

m = M() 
m.circular_reference = m 
r = weakref.ref(m) 
del m 
gc.collect() 
print r 

मैं परिणाम प्राप्त कर सकते हैं कमजोर मॉड्यूल का उपयोग करते हुए दूसरे उदाहरण का (यानी m को म्यूट किए बिना)?

दूसरे शब्दों में, क्या मैं किसी ऑब्जेक्ट को अपने आप को मैप करने के लिए कमजोर मॉड्यूल का उपयोग कर सकता हूं (या किसी अन्य ऑब्जेक्ट जिसमें इसका मजबूत संदर्भ है) और केवल ऑब्जेक्ट को याद रखें जब तक कि इसके अन्य संदर्भ न हों?

Answer 1

आपके पास इन उदाहरणों में वास्तव में परिपत्र संदर्भ नहीं हैं। अपने सर्कल प्रकार है:

WeakKeyDict -> मूल्य -> ​​कुंजी -> ...

तो dict मूल्य जिंदा है, जो बारी में महत्वपूर्ण जिंदा रहता है रहता है, और एक अलग तंत्र जो ऐसा नहीं करता के माध्यम से एक मजबूत संदर्भ शामिल है, कुंजी मूल्य को जीवित रखने के लिए निर्देश देता है। चूंकि यहां कोई उचित संदर्भ मंडल नहीं है, इसलिए जीसी किसी भी मुद्दे का पता नहीं लगाता है।(हालांकि, आपका दूसरा उदाहरण में एक परिपत्र संदर्भ होता है, यही कारण है कि यह पहले की तरह व्यवहार करता है)

मुझे संदेह है कि आपकी समस्या का एकमात्र समाधान यह सुनिश्चित करना है कि dict के मूल्यों में कभी भी मजबूत संदर्भ न हों (प्रत्यक्ष या अप्रत्यक्ष) dict में किसी भी कुंजी के लिए। यह srgerg प्रस्तावित के समान है, लेकिन सभी मूल्यों के कमजोर संदर्भ बनाने के बजाय, आप वाकई कमजोर होने के लिए कुंजी के संदर्भ चाहते हैं। उदाहरण के लिए:

import weakref 
import gc 

class M: 
    pass 

w = weakref.WeakKeyDictionary() 
key = M() 
val = M() 
val.keyRef = weakref.ref(val) 
w[key] = val 
print len(w) ## prints 1 
del key 
gc.collect() 
print len(w) ## prints 0 

इस तरह, वहाँ हमेशा मूल्यों को मजबूत संदर्भ हैं, लेकिन आप ध्यान से निर्धारित करने के लिए क्या dict से हटा दिया जाता चाबियाँ के लिए संदर्भ को नियंत्रित कर रहे हैं। आपके कार्यक्रम की जटिलता के आधार पर, यह लागू करने में समय लग सकता है, क्योंकि आपको चाबियों के सभी संदर्भ मैन्युअल रूप से ट्रैक करने की आवश्यकता है।

लेकिन शायद हम एक सरल समाधान प्रस्तावित कर सकता अगर आप हमें विशिष्ट समस्या के बारे में और अधिक बता ..

Answer 2

इस तरह के परिपत्र संदर्भों से निपटने में किसी के सिर की संभावना है, लेकिन, अवांछित, मैं वैसे भी आपके प्रश्न का उत्तर देने का प्रयास करूंगा।

एक अजगर शब्दकोश अपनी चाबियों और मानों दोनों के संदर्भों को संदर्भित करता है। WeakKeyDictionary स्टोर कमजोर इसकी चाबियों के संदर्भ, लेकिन मजबूत इसके मूल्यों के संदर्भ। तो आपके पहले उदाहरण में, यदि आप w[m] = m सेट करते हैं तो w में m का एक कमजोर संदर्भ है और m के लिए एक मूल्य के रूप में एक मजबूत संदर्भ है।

पायथन के कमजोर मॉड्यूल में एक वीकवेल्यू डिक्शनरी भी है जिसमें इसकी चाबियों के मजबूत संदर्भ और इसके मूल्यों के कमजोर संदर्भ हैं, लेकिन इससे आपकी समस्या हल नहीं होगी।

जो आप वास्तव में चाहते हैं वह एक शब्दकोश है जिसमें इसकी चाबियाँ और मूल्य दोनों के कमजोर संदर्भ हैं। निम्नलिखित कोड को स्पष्ट रूप से एक कमजोर संदर्भ शब्दकोश में प्रत्येक मान बनाता है:

import weakref 
import gc 

class M(): 
    pass 

class Other(): 
    pass 

m = M() 
w = weakref.WeakKeyDictionary() 
w[m] = weakref.ref(m) 
print len(w.keys()) # prints 1 
del m 
print len(w.keys()) # prints 0 

m = M() 
o = Other() 
o.strong_ref = m 
w[m] = weakref.ref(o) 
print len(w.keys()) # prints 1 
del m 
print len(w.keys()) # prints 1 
del o 
print len(w.keys()) # prints 0 

आप मूल्य एक कमजोर संदर्भ स्वचालित रूप से उप-classing WeakKeyDictionary से बना सकते हैं। नोट, हालांकि, यह नहीं वास्तविक WeakValueDictionary जैसा व्यवहार करता है क्योंकि इसमें कोई मान हटा दिए जाने पर शब्दकोश को सूचित करने के लिए कॉलबैक नहीं होता है।

class MyWeakKeyValueDictionary(weakref.WeakKeyDictionary): 
    def __init__(self): 
     weakref.WeakKeyDictionary.__init__(self) 

    def __setitem__(self, key, value): 
     weakref.WeakKeyDictionary.__setitem__(self, key, weakref.ref(value)) 

w2 = MyWeakKeyValueDictionary() 
m = M() 
w2[m] = m 
print len(w2.keys()) # prints 1 
del m 
print len(w2.keys()) # prints 0 

m = M() 
o = Other() 
o.strong_ref = m 
w2[m] = o 
print len(w2.keys()) # prints 1 
del m 
print len(w2.keys()) # prints 1 
del o 
print len(w2.keys()) # prints 0 

अंत में, हालांकि, मैं इस तरह वृत्तीय संदर्भ से निपटने के लिए और अधिक समस्याएं पैदा हो सकती की तुलना में यह लायक है की कोशिश कर रहा डर।