python जांचें कि किसी दिए गए कुंजी को किसी शब्दकोश में पहले से मौजूद है या नहीं




dictionary (16)

मैं कोशिश / छोड़कर उपयोग करें; यदि एक अपवाद फेंक दिया जाता है, तो कुंजी में कुंजी मौजूद नहीं है। उदाहरण:

st = 'sdhfjaks'
d = {}
try:
    print d['st']
except Exception, e:
    print 'Key not in the dictionary'

मैं परीक्षण करना चाहता था कि कुंजी के मान को अपडेट करने से पहले एक कुंजी में एक कुंजी मौजूद है या नहीं। मैंने निम्नलिखित कोड लिखा:

if 'key1' in dict.keys():
  print "blah"
else:
  print "boo"

मुझे लगता है कि यह काम पूरा करने का यह सबसे अच्छा तरीका नहीं है। क्या शब्दकोश में कुंजी के लिए परीक्षण करने का कोई बेहतर तरीका है?


आप has_key () विधि का उपयोग कर सकते हैं:

if dict.has_key('xyz')==1:
    #update the value for the key
else:
    pass

या यदि नहीं मिला तो डिफ़ॉल्ट मान सेट करने के लिए dict.get विधि:

mydict = {"a": 5}

print mydict["a"]            #prints 5
print mydict["b"]            #Throws KeyError: 'b'

print mydict.get("a", 0)     #prints 5
print mydict.get("b", 0)     #prints 0

ईएएफपी का उपयोग करने के बारे में क्या (अनुमति से क्षमा मांगना आसान है):

try:
   blah = dict["mykey"]
   # key exists in dict
except KeyError:
   # key doesn't exist in dict

अन्य एसओ पोस्ट देखें:

पाइथन या कोशिश में बनाम कोशिश कर रहे हैं

पायथन में सदस्य अस्तित्व की जांच


मैं इसके बजाय setdefault विधि का उपयोग करने की सिफारिश करेंगे। ऐसा लगता है जैसे यह सब कुछ आप चाहते हैं।

>>> d = {'foo':'bar'}
>>> q = d.setdefault('foo','baz') #Do not override the existing key
>>> print q #The value takes what was originally in the dictionary
bar
>>> print d
{'foo': 'bar'}
>>> r = d.setdefault('baz',18) #baz was never in the dictionary
>>> print r #Now r has the value supplied above
18
>>> print d #The dictionary's been updated
{'foo': 'bar', 'baz': 18}

आप इसे छोटा कर सकते हैं:

if 'key1' in dict:
    ...

हालांकि, यह सबसे अच्छा कॉस्मेटिक सुधार है। आपको विश्वास क्यों है कि यह सबसे अच्छा तरीका नहीं है?


आपको चाबियाँ कॉल करने की ज़रूरत नहीं है:

if 'key1' in dict:
  print "blah"
else:
  print "boo"

यह बहुत faster क्योंकि यह एक रैखिक खोज करने के विरोध में शब्दकोश के हैशिंग का उपयोग करता है, जो कुंजी को कॉल करता है।


जिस तरीके से आप परिणाम प्राप्त कर सकते हैं वे हैं:

जो बेहतर है 3 चीजों पर निर्भर है:

  1. क्या शब्दकोश 'सामान्यतः कुंजी है' या 'सामान्य रूप से कुंजी नहीं है'।
  2. क्या आप ऐसी स्थितियों का उपयोग करना चाहते हैं जैसे ... और ... elseif ... else?
  3. शब्दकोश कितना बड़ा है?

और पढ़ें: http://paltman.com/try-except-performance-in-python-a-simple-test/

'इन' या 'if' के बजाय प्रयास / ब्लॉक का उपयोग करें:

try:
    my_dict_of_items[key_i_want_to_check]
except KeyError:
    # Do the operation you wanted to do for "key not present in dict".
else:
    # Do the operation you wanted to do with "key present in dict."

पाइथन में शब्दकोश एक प्राप्त ('कुंजी', डिफ़ॉल्ट) विधि है। इसलिए यदि कोई कुंजी नहीं है तो आप केवल एक डिफ़ॉल्ट मान सेट कर सकते हैं।

values = {...}
myValue = values.get('Key', None)

सबसे आसान यह है कि यदि आप जानते हैं कि कौन सी कुंजी (कुंजी नाम) देखना है:

# suppose your dictionary is
my_dict = {'foo': 1, 'bar': 2}
# check if a key is there
if 'key' in my_dict.keys():   # it will evaluates to true if that key is present otherwise false.
    # do something

या आप बस इस तरह के रूप में भी कर सकते हैं:

if 'key' in my_dict:   # it will evaluates to true if that key is present otherwise false.
    # do something

खैर .. आप परिचित होंगे कि सूची या डेटा में किसी तत्व के अस्तित्व को खोजना मतलब है सब कुछ (कम से कम अनियंत्रित सूची जैसे dict.keys) के माध्यम से जा रहा है। इसलिए अपवाद और त्रुटियों का उपयोग करने के बजाय सामान्य रूप से उत्पन्न होता है हम उस जटिलता से बच सकते हैं ...

d={1:'a',2:'b'}
try:
    needed=d[3]
    print(needed)
except:
    print("Key doesnt exist")

print dict.get('key1', 'blah')

Dict में मूल्यों के लिए बू मुद्रित नहीं करेगा, बल्कि इसके अस्तित्व की पुष्टि करने के लिए key1 के मान को प्रिंट करके लक्ष्य पूरा करता है।


एक dict में एक कुंजी के अस्तित्व के लिए परीक्षण करने का इरादा तरीका है।

d = dict()

for i in xrange(100):
    key = i % 10
    if key in d:
        d[key] += 1
    else:
        d[key] = 1

यदि आप डिफ़ॉल्ट चाहते थे, तो आप हमेशा dict.get() उपयोग कर सकते हैं:

d = dict()

for i in xrange(100):
    key = i % 10
    d[key] = d.get(key, 0) + 1

... और यदि आप हमेशा किसी भी कुंजी के लिए डिफ़ॉल्ट मान सुनिश्चित करना चाहते हैं तो आप collections मॉड्यूल से डिफ़ॉल्ट defaultdict उपयोग कर सकते हैं, जैसे:

from collections import defaultdict

d = defaultdict(lambda: 0)

for i in xrange(100):
    d[i % 10] += 1

... लेकिन सामान्य रूप से, कीवर्ड में ऐसा करने का सबसे अच्छा तरीका है।


बस एक एफवाईआई क्रिस को जोड़ रहा है। बी (सर्वश्रेष्ठ जवाब):

d = defaultdict(int)

साथ ही काम करता है; इसका कारण यह है कि कॉलिंग int() 0 देता है जो दृश्यों के पीछे defaultdict करता है (जब शब्दकोश का निर्माण होता है), इसलिए दस्तावेज़ में "फैक्टरी फ़ंक्शन" नाम होता है।


पायथन शब्दकोश में __contains__ नामक विधि है। यह विधि सही हो जाएगी यदि शब्दकोश में कुंजी और गलत है।

 >>> temp = {}

 >>> help(temp.__contains__)

Help on built-in function __contains__:

__contains__(key, /) method of builtins.dict instance
    True if D has a key k, else False.

क्यों नहीं है has_key () विधि का उपयोग करें।

a = {}
a.has_key('b') => #False

a['b'] = 8
a.has_key('b') => #True

कीवर्ड में उपयोग करके आप किसी शब्दकोश में कुंजी की उपस्थिति के लिए परीक्षण कर सकते हैं:

d = {'a': 1, 'b': 2}
'a' in d # <== evaluates to True
'c' in d # <== evaluates to False

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

पुराने कोड में, आपको has_key() , शब्दकोशों में कुंजियों के अस्तित्व की जांच के लिए एक बहिष्कृत विधि का कुछ उपयोग भी मिल सकता है (इसके बजाय key_name in dict_name उपयोग करें)।





dictionary