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

Question

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

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

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

Comments

dict.keys()प्रलेखन के अनुसार कॉलिंग कुंजी की एक सूची बनाती है, दस्तावेज़ docs.python.org/2/library/stdtypes.html#dict.keys के अनुसार, लेकिन अगर इस पैटर्न को किसी गंभीर कार्यान्वयन में, अनुवाद करने के लिए, अनुकूलित नहीं किया गया तो मुझे आश्चर्य होगा। को if 'key1' in dict:।

— इवगेनी सर्गेव

इसलिए मुझे अंत में पता चला कि मेरी पायथन की कई स्क्रिप्ट इतनी धीमी क्यों थी :) :(? इसलिए कि मैं x in dict.keys()चाबियों की जांच के लिए उपयोग कर रहा हूं । और ऐसा इसलिए हुआ क्योंकि जावा में चाबियों पर पुनरावृति करने का सामान्य तरीका for (Type k : dict.keySet())यह आदत for k in dict.keys()है। की तुलना में अधिक स्वाभाविक लगता है for k in dict(जो कि प्रदर्शन के मामले में अभी भी ठीक होना चाहिए?), लेकिन फिर जांच की चाबियाँ if k in dict.keys()भी बन जाती हैं, जो एक समस्या है ...

— एवगेनी सर्गेव

@EvgeniSergeev के डिस्क्स if k in dict_:में कुंजियों की उपस्थिति के लिए परीक्षण_, ताकि आपको अभी भी ज़रूरत न हो dict_.keys()। (यह थोड़ा मुझे के रूप में यह एक के लिए अपने परीक्षण की तरह मेरे लिए पढ़ता है, मूल्य dict लेकिन ऐसा नहीं है।।)

— ToolmakerSteve

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

— इवगेनी सर्गेव

कोशिश "प्रमुख में"

— marcelosalloum

Answer 1

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

d = {"key1": 10, "key2": 23}

if "key1" in d:
    print("this will execute")

if "nonexistent key" in d:
    print("this will not")

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

d = dict()

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

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

from collections import defaultdict

d = defaultdict(int)

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

लेकिन सामान्य तौर पर, inकीवर्ड इसे करने का सबसे अच्छा तरीका है।

Comments

मैं आमतौर पर सिर्फ उपयोग करता getहूं अगर मैं वैसे भी आइटम को शब्दकोश से बाहर निकालने जा रहा हूं। शब्दकोश से आइटम का उपयोग करने in और खींचने में कोई समझदारी नहीं है ।

— जेसन बेकर

में पूरी तरह से सहमत हूँ। लेकिन अगर आपको केवल यह जानना है कि क्या कोई कुंजी मौजूद है, या आपको उस मामले के बीच अंतर करने की आवश्यकता है जहां कुंजी को परिभाषित किया गया है और ऐसा मामला जहां आप डिफ़ॉल्ट का उपयोग कर रहे हैं, तो inयह करने का सबसे अच्छा तरीका है।

— क्रिस बी।

इस उत्तर के लिए संदर्भ अजगर डॉक्स में है

— 5

0उदाहरण के लिए , कुंजी "गलत" के बराबर होने पर एक खराब परीक्षा है । यह मुश्किल तरीका सीखा: /

— सेबस्टियन

मैं सहमत नहीं हो सकता कि यह एक पूर्ण उत्तर है क्योंकि यह उल्लेख नहीं करता है कि 'प्रयास' - 'को छोड़कर' सबसे तेज होगा जब कुंजी की संख्या पर्याप्त नहीं होती है। नीचे इस उत्तर को देखें: stackoverflow.com/a/1602945/4376643

— क्रेग हिक्स

Answer 2

आपको कॉल करने की आवश्यकता नहीं है:

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

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

Comments

यह बहुत बढ़िया बात है। मैं इस धारणा के तहत था कि यह आंतरिक रूप से अभी भी चाबियों की सूची को पार कर लेगा, लेकिन मुझे लगता है कि यह एक सेट में सदस्यता की तरह परीक्षण का काम करता है।

— मोहन गुलाटी

@ मोहन गुलाटी: आप समझते हैं कि एक शब्द मानों के लिए मैप की गई कुंजी का हैशटेबल है, है ना? एक हैशिंग एल्गोरिथ्म एक पूर्णांक में कुंजी को धर्मान्तरित करता है और पूर्णांक हैश तालिका में एक स्थान खोजने के लिए उपयोग किया जाता है जो मेल खाता है। en.wikipedia.org/wiki/Hash_table

— hughdbrown

@Charles Addis, लगभग आधा मिलियन कुंजी के साथ काम करने के अनुभव से, आपको "key in dict.keys ()" के बजाय "प्रमुख" लिखने पर कम से कम 10x प्रदर्शन को बढ़ावा मिलता है। पीईपी और ज़ेन का यह भी कहना है कि आपके प्रोजेक्ट के खराब होने की स्थिति में आपको उन्हें अनदेखा करना चाहिए।

— ivan_bilan

ivan_bilan - मैं सिर्फ इस पर मेरे अपने benchtest भाग गया ... पांच लाख कुंजी पर, if key in d1ले लिया 0.17265701293945312सेकंड। कॉलिंग if key in d1.keys()लिया गया 0.23871088027954102- यह माइक्रो-ऑप्टिमाइज़ेशन की क्लासिक परिभाषा है। 0.07884883880615234सेकंड सेव करना प्रदर्शन को बढ़ावा देने वाला नहीं है।

— चार्ल्स अदीस

@ एली बस आपके लिए मैंने एक परीक्षा बनाई है जिसे आप स्वयं चला सकते हैं। परिणाम आपको चकित कर सकते हैं। ~ 50,000 कुंजी के साथ dicts के लिए, कॉलिंग नहीं keys()आपको .01 दूसरा कम्प्यूटेशनल लाभ देता है। ~ 500,000 कुंजियों के लिए, कॉलिंग नहीं keys()आपको .1 दूसरा लाभ देती है। ~ 5,000,000 कुंजी के लिए, ना बुलाने की keys().4 सेकंड तेजी से होता है, लेकिन 50,000,000 चाबी के लिए बुला keys()3 सेकंड तेजी से होता है!

— चार्ल्स अदीस

Answer 3

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

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, इसके बजाय)।

Comments

साझा करना चाहते थे कि (पायथन 2.7 का उपयोग करके) मैंने जो कुछ लिखा था, उस समय का रन टाइम, जो कि डक्ट्स पर बहुत अधिक आधारित था, 363.235070 में "key in dict.keys ()" का उपयोग कर रहा था और "कीज़" के लिए कॉल हटाकर पूरी तरह से 0.2601,000 हो गया। ) "

— घोड़े_फैस

@Ido_f कृपया अपने बेंचमार्क पोस्ट करें, क्योंकि मेरे बेंचमार्क लगभग 3.5 और 2.7 में कोई अंतर नहीं है

— चार्ल्स एडिस

@ मैं_ मुझे संदेह है कि यह आपके कार्यक्रम में कुछ और था, लेकिन वास्तव में कुछ और नहीं था key in dict.keys()। इस चेक को छोड़कर सभी कोड हटाने का प्रयास करें और देखें कि आपका परिणाम क्या है।

— चार्ल्स अदीस

Answer 4

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

if 'key1' in dict:
    ...

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

Comments

यह एक कॉस्मेटिक सुधार की तुलना में बहुत अधिक है। इस विधि का उपयोग करके एक कुंजी खोजने का समय हे (1) है, जबकि कॉलिंग कुंजी एक सूची उत्पन्न करेगी और ओ (एन) होगी।

— जेसन बेकर

O (1) बिल्कुल सही नहीं लगता है। क्या आप निश्चित हैं कि यह O (log n) जैसा कुछ नहीं है?

— स्पेक्टर्स

यह एकल तानाशाह की जटिलता है, जो औसत O (1) और सबसे खराब O (n) पर है। .list () हमेशा O (n) होगी। wiki.python.org/moin/TimeComplexity

— लियोनोरा

यह भी एक अतिरिक्त आवंटन से बचा जाता है। (तंग छोरों को थोड़ा तेज बनाने के लिए महत्वपूर्ण है)

— nurettin

Answer 5

स्वीकृत उत्तर की प्रस्तावित विधियों की गति निष्पादन (10 मी लूप) पर अतिरिक्त जानकारी के लिए:

• 'key' in mydict बीता हुआ समय 1.07 सेकंड
• mydict.get('key') बीता हुआ समय १.aps४ सेकंड
• mydefaultdict['key'] बीता हुआ समय 1.07 सेकंड

इसलिए के खिलाफ उपयोग inया defaultdictसिफारिश की जाती है get।

Comments

पूरी तरह से सहमत हैं कि get1.84 s <1.07 * 2 ;-P

— पॉल

Answer 6

मैं 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}

Comments

क्या करता है setdefaultओ पी के सवाल के साथ क्या करना है?

— हुग्डब्रोर्न

@hughdbrown "मैं परीक्षण करना चाहता था कि कुंजी के लिए मान को अपडेट करने से पहले कोई कुंजी किसी शब्दकोश में मौजूद है या नहीं।" कभी-कभी पोस्ट में ऐसा कोड शामिल होता है जो किसी चीज़ के प्रति प्रतिक्रियाओं की हड़बड़ाहट पैदा करता है जो कि मूल लक्ष्य नहीं है। पहले वाक्य में बताए गए लक्ष्य को पूरा करने के लिए, सेटडेफ़ॉल्ट सबसे प्रभावी तरीका है, भले ही यह पोस्ट किए गए नमूना कोड के लिए ड्रॉप-इन प्रतिस्थापन नहीं है।

— डेविड बर्जर

यह श्रेष्ठ उत्तर है क्योंकि यह तकनीकी रूप से सही उत्तर देने के बजाय ओपी के लक्ष्य को संतुष्ट करता है। देखें: nedbatchelder.com/blog/201207/…

— Niels Bom

जानकारीपूर्ण उत्तर के लिए +1, जिसने मुझे कुछ सिखाया। हालांकि, क्या यह सबसे अच्छा समाधान है यह इस बात पर निर्भर करता है कि कोडर के मन में क्या है; उदाहरण के लिए "कुंजी के मूल्य को अपडेट करने से पहले"। हो सकता है कि वह एक अपवाद को फेंकने जा रहा हो अगर यह मौजूद नहीं है (== नई कुंजी जोड़ने की अनुमति नहीं है)। हो सकता है कि इसका एक शब्दकोष है, और वह मौजूदा संख्या में 1 जोड़ने जा रहा है, जिस स्थिति में `d [key] = d.get (कुंजी, 0) + 1’ सबसे साफ समाधान है (जैसा कि क्रिस दिखाता है, आपके उत्तर के बाद लिखा गया था)। (मैं केवल इस बात का उल्लेख करने से परेशान हूं, यदि भविष्य के पाठक यहां आते हैं, तो विभिन्न कार्यों को ध्यान में रखते हुए।)

— टूलमेकरसर्व

@ टूलमेकर सच। यहां समस्या यह है कि ओपी का सवाल पर्याप्त स्पष्ट नहीं था।

— नील्स बॉम

Answer 7

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

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

Answer 8

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

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

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

अगर अजगर में या तो कोशिश बनाम का उपयोग करना

पायथन में सदस्य अस्तित्व के लिए जाँच करना

Comments

कोशिश करो / छोड़कर अधिक महंगा हो सकता है अगर यह संभावना है कि कुंजी अक्सर मौजूद नहीं है। आपके द्वारा संदर्भित पद से: "[I] f आप उम्मीद करते हैं कि समय परिणाम के 99% में वास्तव में कुछ चलने योग्य होगा, मैं कोशिश करूंगा / दृष्टिकोण को छोड़कर। यदि वास्तव में अपवाद असाधारण हैं तो यह तेजी से होगा। यदि परिणाम कुछ भी नहीं है। 50% से अधिक समय, तब यदि संभव हो तो बेहतर है का उपयोग करते हुए। [...] [ए] n अगर बयान हमेशा आपको लागत देता है, तो यह लगभग एक कोशिश / ब्लॉक को छोड़कर स्थापित करने के लिए स्वतंत्र है। लेकिन जब एक अपवाद वास्तव में होता है, लागत बहुत अधिक है। " stackoverflow.com/a/1835844/1094092

— Billrichards

Answer 9

टर्नरी ऑपरेटर का उपयोग करना:

message = "blah" if 'key1' in dict else "booh"
print(message)

Answer 10

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

• अगर आपका_डक्ट.हास_की (कुंजी) पायथन 3 में हटा दी गई है
• अगर आपके_डिक्ट में कुंजी है
• प्रयास करें / ब्लॉक को छोड़कर

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

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

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

'In' या 'if' के बजाय try / block का उपयोग करें:

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."

Comments

अजगर के लिए अच्छा लेकिन वास्तविक होने की आवश्यकता है। 3. मैंने वेब पेज की स्क्रिप्ट को रूपांतरित किया 2to3, और देखा कि बिना कोशिश के सिंटैक्स हमेशा ट्राइ सिंटैक्स के साथ तेजी से होता है, यहां तक ​​कि उस स्थिति में भी जहां कुंजी तानाशाही में है।

— जीन पॉल

Answer 11

अजगर केवल 2: (और अजगर 2.7 inपहले से ही समर्थन करता है )

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

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

Comments

.has_key()पदावनत कर दिया गया है ; आपको inअन्य उत्तरों में दिखाए अनुसार उपयोग करना चाहिए ।

— ब्रैड कोच

BTW, मैं एक OLD प्रश्न के सभी मौजूदा उत्तरों को पढ़ने से पहले, इसका उत्तर देने की सलाह देता हूं । इस जवाब ने कुछ नहीं जोड़ा, क्योंकि यह सुझाव माइकल के जवाब में पहले से मौजूद था, '09 'से। (मुझे चर्चा में उपयोगी कुछ जोड़ने के प्रयास को हतोत्साहित करने का कोई मतलब नहीं है। प्रयास करते रहें।)

— टूलमेकर

Answer 12

क्रिस से बस एक FYI करें। बी (सबसे अच्छा जवाब):

d = defaultdict(int)

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

Comments

यदि आप गिनती का शब्दकोश बना रहे हैं, तो आपको काउंटर (पायथन 2.7 मानकर) का उपयोग करना चाहिए । और मैं प्रयोग किया जाता है defaultdict(lambda: 0)के बजाय defaultdict(int)क्योंकि मुझे लगता है कि यह स्पष्ट क्या हो रहा है है, पाठक को यह जानने की जरूरत नहीं है कि आप बिना तर्क के 0कॉल int()करते हैं। YMMV।

— क्रिस बी।

Answer 13

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

यह विचार करने के लिए कि हम पहले कैसे निरीक्षण करते हैं कि हम किन तरीकों को शब्दकोश में कह सकते हैं। ये तरीके हैं:

d={'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

---

Python Dictionary clear()       Removes all Items
Python Dictionary copy()        Returns Shallow Copy of a Dictionary
Python Dictionary fromkeys()    Creates dictionary from given sequence
Python Dictionary get()         Returns Value of The Key
Python Dictionary items()       Returns view of dictionary (key, value) pair
Python Dictionary keys()        Returns View Object of All Keys
Python Dictionary pop()         Removes and returns element having given key
Python Dictionary popitem()     Returns & Removes Element From Dictionary
Python Dictionary setdefault()  Inserts Key With a Value if Key is not Present
Python Dictionary update()      Updates the Dictionary 
Python Dictionary values()      Returns view of all values in dictionary

---

यह जाँचने की क्रूर विधि कि कुंजी पहले से मौजूद है, get()विधि हो सकती है :

d.get("key")

अन्य दो दिलचस्प तरीके items()और keys()आवाज़ बहुत काम की लगती है। तो आइए देखें कि क्या get()हमारे लिए सही तरीका है। हम अपने तानाशाही d:

d= {'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

मुद्रण से पता चलता है कि हमारे पास नहीं है None:

print(d.get('key')) #None
print(d.get('clear')) #0
print(d.get('copy')) #1

यदि कुंजी मौजूद है या नहीं तो जानकारी प्राप्त करने के लिए हम इसका उपयोग कर सकते हैं। लेकिन इस पर विचार करें यदि हम एक एकल के साथ एक तानाशाही बनाते हैं key:None:

d= {'key':None}
print(d.get('key')) #None
print(d.get('key2')) #None

get()यदि कुछ मान हो सकते हैं तो उस पद्धति का नेतृत्व करना विश्वसनीय नहीं है None। इस कहानी का सुखद अंत होना चाहिए। यदि हम inतुलनित्र का उपयोग करते हैं :

print('key' in d) #True
print('key2' in d) #False

हमें सही परिणाम मिलते हैं। हम पायथन बाइट कोड की जांच कर सकते हैं:

import dis
dis.dis("'key' in d")
#   1           0 LOAD_CONST               0 ('key')
#               2 LOAD_NAME                0 (d)
#               4 COMPARE_OP               6 (in)
#               6 RETURN_VALUE

dis.dis("d.get('key2')")
#   1           0 LOAD_NAME                0 (d)
#               2 LOAD_METHOD              1 (get)
#               4 LOAD_CONST               0 ('key2')
#               6 CALL_METHOD              1
#               8 RETURN_VALUE

इससे पता चलता है कि inऑपरेटर की तुलना न केवल अधिक विश्वसनीय है, बल्कि उससे भी तेज है get()।

Comments

.get()defaultमूल्य के लिए एक दूसरा तर्क हो सकता है, कि जहां समस्या को संभालने के लिए इस्तेमाल किया जा सकता है key:None। उदाहरण: d.get("key", False)

— एलेक्स

.get()सबसे तेज़ तरीका है। एक अन्य विकल्प एक try/ exceptब्लॉक में निर्दिष्ट करना है

— HCLivess

Answer 14

पायथन डिक्शनरी में विधि कहा जाता है __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.

Comments

__contains__सीधे फोन करना बहुत बुरा अभ्यास है । इसे करने का सही तरीका, inऑपरेटर का उपयोग करना है, जो containment checkकि __contains__फ़ंक्शन को आमंत्रित करता है।

— user1767754

@ user1767754 मैं उपयोग कर रहा हूँ foo = x['foo'] if x.__contains__('foo') else 'bar'। किसी भी विचार कैसे inऑपरेटर इस अभिव्यक्ति के हिस्से के रूप में उपयोग कर सकते हैं ?

— डोन्रोनडॉन

foo = x['foo'] if 'foo' in x else 'bar'

— रे वू

Answer 15

बूलियन ऑपरेटरों का उपयोग करके एक कुंजी मौजूद है, तो जाँच का एक और तरीका साझा करना।

d = {'a': 1, 'b':2}
keys = 'abcd'

for k in keys:
    x = (k in d and 'blah') or 'boo'
    print(x) 

यह लौटाता है

>>> blah
>>> blah
>>> boo
>>> boo

व्याख्या

सबसे पहले आपको पता होना चाहिए कि अजगर में, 0, None, या शून्य लंबाई के साथ वस्तुओं का मूल्यांकनFalse । बाकी सब कुछ मूल्यांकन करता है True। बूलियन ऑपरेशन का मूल्यांकन बाएं से दाएं किया जाता है और ऑपरेटर को सही या गलत नहीं लौटाता है।

आइए एक उदाहरण देखें:

>>> 'Some string' or 1/0 
'Some string'
>>>

चूंकि 'Some string'मूल्यांकन करता हैTrue , बाकी का orमूल्यांकन नहीं किया गया है और शून्य त्रुटि से कोई विभाजन नहीं हुआ है।

लेकिन अगर हम स्विच करते हैं तो ऑर्डर 1/0का मूल्यांकन पहले किया जाता है और एक अपवाद उठाया जाता है:

>>> 1/0 or 'Some string'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 

यदि कोई कुंजी मौजूद है, तो हम पैटर्न की जाँच के लिए इसका उपयोग कर सकते हैं।

(k in d and 'blah')

के रूप में ही करता है

if k in d:
    'blah'
else:
    False

यदि कुंजी मौजूद है तो यह पहले से ही सही परिणाम देता है, लेकिन हम चाहते हैं कि जब यह न हो तो 'बू' प्रिंट करें। तो, हम परिणाम लेते हैं और orइसके साथ'boo'

>>> False or 'boo'
'boo'
>>> 'blah' or 'boo'
'blah'
>>> 

Answer 16

आप उपयोग कर सकते हैं forअगर यह मौजूद हैं या उपयोग नहीं कर शब्दकोश पर पुनरावृति करने पाश और आप शब्दकोश में लगाना चाहते हैं कुंजी का नाम मिलता है, कि जांच के बाद ifहालत:

dic = {'first' : 12, 'second' : 123}
for each in dic:
    if each == 'second': 
        print('the key exists and the corresponding value can be updated in the dictionary')

Comments

कोड की जाँच करें क्योंकि इसके लिए आउटपुट है it is existऔरnot exist

— system123456

अगर यह रैखिक खोज करने के लिए है, तो एक शब्दकोश का उपयोग क्यों करें?

— जीन फ़्राँस्वा Fabre