යතුර සඳහා අගය යාවත්කාලීන කිරීමට පෙර ශබ්ද කෝෂයක යතුරක් තිබේදැයි පරීක්ෂා කිරීමට මට අවශ්‍ය විය. මම පහත කේතය ලිව්වා:

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

මෙම කාර්යය ඉටු කිරීමට හොඳම ක්‍රමය මෙය නොවන බව මම සිතමි. ශබ්ද කෝෂයේ යතුරක් පරීක්ෂා කිරීමට වඩා හොඳ ක්‍රමයක් තිබේද?

ina හි යතුරක පැවැත්ම පරීක්ෂා කිරීම සඳහා අපේක්ෂිත ක්‍රමය වේ 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එය කිරීමට හොඳම ක්‍රමය මූලික පදයයි.

ඔබට යතුරු ඇමතිය යුතු නැත:

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

රේඛීය සෙවුමකට වඩා ශබ්ද කෝෂයේ හැෂිං භාවිතා කරන බැවින් එය වඩා වේගවත් වනු ඇත.

In keyword භාවිතා කරමින් ශබ්ද කෝෂයක යතුරක් තිබේදැයි පරීක්ෂා කළ හැකිය :

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ඒ වෙනුවට භාවිතා කරන්න).

ඔබට මෙය කෙටි කළ හැකිය:

if 'key1' in dict:
    ...

කෙසේ වෙතත්, මෙය හොඳම රූපලාවණ්‍ය වැඩිදියුණු කිරීමකි. මෙය හොඳම ක්‍රමය නොවන බව ඔබ විශ්වාස කරන්නේ ඇයි?

පිළිගත් පිළිතුරේ යෝජිත ක්‍රම වේගයෙන් ක්‍රියාත්මක කිරීම පිළිබඳ අමතර තොරතුරු සඳහා (මීටර් 10 ලූප):

• 'key' in mydict ගත වූ කාලය තත්පර 1.07 යි
• mydict.get('key') ගත වූ කාලය තත්පර 1.84 යි
• mydefaultdict['key'] ගත වූ කාලය තත්පර 1.07 යි

එබැවින් භාවිතා කිරීම inහෝ defaultdictඊට එරෙහිව නිර්දේශ කරනු ලැබේ get.

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}

පයිතන්හි ශබ්දකෝෂයට get ('key', default) ක්‍රමයක් ඇත. යතුරක් නොමැති විට ඔබට පෙරනිමි අගයක් සැකසිය හැකිය.

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

EAFP භාවිතා කිරීම ගැන කුමක් කිව හැකිද (අවසරයට වඩා සමාව ඉල්ලීම පහසුය):

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

වෙනත් SO ලිපි බලන්න:

පයිතන් හෝ තිබේ නම් උත්සාහ කරන්න

පයිතන් හි සාමාජික පැවැත්ම පරීක්ෂා කිරීම

තෘතීය ක්‍රියාකරු භාවිතා කිරීම:

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

ඔබට ප්‍රති results ල ලබා ගත හැකි ක්‍රම:

• ඔබගේ_dict.has_key (යතුර) පයිතන් 3 හි ඉවත් කර ඇත්නම්
• your_dict හි යතුර නම්
• වාරණය හැර / උත්සාහ කරන්න

වඩා හොඳ දේ කරුණු 3 ක් මත රඳා පවතී:

1. ශබ්ද කෝෂයේ 'සාමාන්‍යයෙන් යතුර තිබේද' හෝ 'සාමාන්‍යයෙන් යතුර නැත'.
2. If ... else ... elseif ... else වැනි කොන්දේසි භාවිතා කිරීමට ඔබ අදහස් කරනවාද?
3. ශබ්ද කෝෂය කොතරම් විශාලද?

තව දුරටත් කියවන්න: http://paltman.com/try-except-performance-in-python-a-simple-test/

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

පයිතන් 2 පමණි: (සහ පයිතන් 2.7 inදැනටමත් සහය දක්වයි )

ඔබට has_key () ක්‍රමය භාවිතා කළ හැකිය:

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

ක්‍රිස්ට එෆ්.අයි.අයි. බී (හොඳම පිළිතුර):

d = defaultdict(int)

එසේම ක්රියා කරයි; හේතුව, int()ප්‍රතිලාභ ඇමතීම තිරය ​​පිටුපස ඇති 0දෙයයි defaultdict(ශබ්දකෝෂයක් තැනීමේදී), එබැවින් ප්‍රලේඛනයේ “කර්මාන්තශාලා ක්‍රියාකාරිත්වය” යන නම.

දී ඇති යතුරක් දැනටමත් ශබ්දකෝෂයක තිබේදැයි පරීක්ෂා කරන්න

එය කරන්නේ කෙසේද යන අදහස ලබා ගැනීම සඳහා අපි මුලින් ශබ්ද කෝෂයෙන් ඇමතිය හැකි ක්‍රම මොනවාදැයි පරීක්ෂා කරමු. මෙන්න ක්‍රම:

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()අපට නිවැරදි ක්‍රමය දැයි විමසා බලමු. අපට අපගේ ආ ict ාව තිබේ 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

යතුර තිබේද නැද්ද යන්න පිළිබඳ තොරතුරු ලබා ගැනීමට අපි එය භාවිතා කළ හැකිය . නමුත් අපි තනි එකක් සමඟ ආ ict ාවක් නිර්මාණය කරන්නේ නම් මෙය සලකා බලන්න 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().

පයිතන් ශබ්දකෝෂය යනුවෙන් හැඳින්වෙන ක්‍රමය __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.

බූලියන් ක්‍රියාකරුවන් භාවිතා කරමින් යතුරක් තිබේදැයි පරීක්ෂා කිරීමට තවත් එක් ක්‍රමයක් බෙදා ගැනීම.

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

යතුර තිබේ නම් මෙය දැනටමත් නිවැරදි ප්‍රති result ලය ලබා දෙයි, නමුත් එය නොමැති විට එය 'බූ' මුද්‍රණය කිරීමට අපට අවශ්‍යය. ඉතින්, අපි ප්රති result ලය සහor එය සමඟ'boo'

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

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')