"k in d" कैसे गलत हो सकता है, लेकिन "k.keys() में k" सच है?

Question

मेरे पास कुछ पायथन कोड है जो एक KeyError अपवाद फेंक रहा है। अब तक मैं ऑपरेटिंग वातावरण के बाहर पुन: उत्पन्न करने में सक्षम नहीं हूं, इसलिए मैं यहां एक कम परीक्षण केस पोस्ट नहीं कर सकता।

कोड है कि अपवाद को ऊपर उठाने के इस तरह एक पाश के माध्यम से पुनरावृत्ति है:

for k in d.keys(): 
    if condition: 
     del d[k] 

del[k] लाइन अपवाद फेंकता है। मैंने इसके आसपास try/except क्लॉज जोड़ा है और यह निर्धारित करने में सक्षम है कि k in d गलत है, लेकिन k in d.keys() सत्य है।

d की कुंजी पुरानी शैली के वर्ग उदाहरणों के बाध्य तरीके हैं।

कक्षा __cmp__ और __hash__ लागू करती है, इसलिए मैं अपना ध्यान केंद्रित कर रहा हूं।

Answer 1

k in d.keys() प्रत्येक कुंजी के लिए iteratively समानता का परीक्षण होगा, जबकि k in d__hash__ का उपयोग करता है, इसलिए आपके __hash__ को तोड़ दिया जा सकता है (यानी यह बराबर तुलना करने वाली वस्तुओं के लिए अलग हैश देता है)।

Answer 2

d आइटम हटाना नहीं है, जबकि इस पर पुनरावृत्ति, कुंजी आप एक सूची में हटाना चाहते हैं की दुकान और एक अन्य पाश में उन्हें हटा दें:

deleted = [] 
for k in d.keys(): 
    if condition: 
     deleted.append(k) 
for k in deleted: 
    del d[k] 

Answer 3

आप जो कर रहे हैं वह जावा में एक समवर्ती संशोधन अपवाद फेंक देगा। d.keys() जब आप इसे कॉल करते हैं तो कुंजी की एक सूची बनाता है, लेकिन वह सूची अब स्थिर है - d में संशोधन d.keys() के संग्रहीत संस्करण को नहीं बदलेगा। तो जब आप d.keys() से अधिक सक्रिय करते हैं लेकिन आइटम हटाते हैं, तो आप उस कुंजी को संशोधित करने की संभावना के साथ समाप्त होते हैं जो अब नहीं है।

आप d.pop(k, None) का उपयोग कर सकते हैं, जो k या None पर मैप किए गए मान को वापस कर देगा, यदि k मौजूद नहीं है। यह KeyError समस्या से बचाता है।

संपादित करें: स्पष्टीकरण के लिए, अधिक प्रेत डाउनमोड्स को रोकने के लिए (नकारात्मक प्रतिक्रिया के साथ कोई समस्या नहीं, केवल इसे रचनात्मक बनाएं और एक टिप्पणी छोड़ दें ताकि हम संभावित रूप से सूचनात्मक चर्चा कर सकें - मैं यहां सीखने के साथ-साथ सहायता भी कर रहा हूं):

यह सच है कि इस विशेष स्थिति में यह में गड़बड़ नहीं करना चाहिए। मैं इसे एक संभावित मुद्दे के रूप में ला रहा था, क्योंकि यदि वह प्रोग्राम के दूसरे हिस्से में एक ही तरह की कोडिंग योजना का उपयोग कर रहा है, जहां वह नहीं है तो वह डेटा संरचना का इलाज कैसे कर रहा है, इस बारे में सावधान/भाग्यशाली है, ऐसी समस्याएं उत्पन्न हो सकती हैं । वह एक शब्दकोश का भी उपयोग नहीं कर रहा है, बल्कि एक वर्ग जो कुछ तरीकों को लागू करता है ताकि आप इसे उसी तरह से इलाज कर सकें।

Answer 4

क्या, टूटा हुआ है हित के लिए की सरल उदाहरण:

>>> count = 0 
>>> class BrokenHash(object): 
...  def __hash__(self): 
...    global count 
...    count += 1 
...    return count 
... 
...  def __eq__(self, other): 
...    return True 
... 
>>> foo = BrokenHash() 
>>> bar = BrokenHash() 
>>> foo is bar 
False 
>>> foo == bar 
True 
>>> baz = {bar:1} 
>>> foo in baz 
False 
>>> foo in baz.keys() 
True