වඩා හොඳ කුමක්දැයි මම කල්පනා කරමි:
d = {'a': 1, 'b': 2}
'a' in d
True
හෝ:
d = {'a': 1, 'b': 2}
d.has_key('a')
True
Answers:
in
අනිවාර්යයෙන්ම වඩා පයිතොනික් වේ.
ඇත්ත වශයෙන්ම has_key()
පයිතන් 3.x හි ඉවත් කරන ලදි .
keys()
පිටපතකට වඩා ශබ්දකෝෂයකට සමාන පෙනුමක් ඇති අතර x in d.keys()
ඕ (1) ද වේ. තවමත්, x in d
වඩා පයිතොනික් වේ.
x in d.keys()
තාවකාලික වස්තුවක් තැනීම හා විනාශ කිරීම, මතක විබෙදුම සමඟ සම්පුර්ණ x in d.keys()
කිරීම, ගණිතමය මෙහෙයුමක් (හැෂ් ගණනය කිරීම) සහ සොයා බැලීමක් සිදු කිරීම ය. d.keys()
මෙය තව දුරටත් 10 ගුණයක් පමණ වන බව සලකන්න . මම පරීක්ෂා කර නැති නමුත් මට තවමත් විශ්වාසයි එය ඕ (1) පමණක් බව.
in
අලංකාරයෙන් පමණක් නොව (ප්රතික්ෂේප නොකෙරේ ;-) පමණක් නොව, කාර්ය සාධනයෙන්ද, උදා:
$ python -mtimeit -s'd=dict.fromkeys(range(99))' '12 in d'
10000000 loops, best of 3: 0.0983 usec per loop
$ python -mtimeit -s'd=dict.fromkeys(range(99))' 'd.has_key(12)'
1000000 loops, best of 3: 0.21 usec per loop
පහත දැක්වෙන නිරීක්ෂණය සැමවිටම සත්ය නොවන නමුත් සාමාන්යයෙන් , පයිතන්හි වේගවත් විසඳුම වඩාත් අලංකාර සහ පයිතොනික් බව ඔබට පෙනෙනු ඇත ; -mtimeit
SO ප්රයෝජනවත් වන්නේ එබැවිනි - එය නැනෝ තත්පර සියයක් ඉතිරි කර ගැනීම පමණක් නොවේ ! -)
has_key
O (1) ද පෙනේ.
පිඹුරා අනුව ලේඛන :
has_key()
පක්ෂව ප්රතික්ෂේප කරනුkey in d
ලැබේ.
has_key()
දැන් ඉවත් කර ඇත්තේ පයිතන් 3
dict.has_key()
ඔබේ කේතය 2.3 ට පෙර ( key in dict
හඳුන්වා දුන් විට ) පයිතන් අනුවාදයන් මඟින් ධාවනය කළ යුතු නම් (සහ පමණක් නම්) භාවිතා කරන්න .
in
ඔබේ ක්රියාකාරිත්වය සැබවින්ම විනාශ කරන එක් උදාහරණයක් තිබේ .
ඔබ භාවිතා කරන්නේ නම් in
එය සාමාන්ය මත (1) උපකරණ පමණක් බව රුවනයකි __getitem__
හා has_key()
නමුත් __contains__
ඔබ සාමාන්ය හැරී ඇත (1) O (N) බවට සොයන්න (ලෙස සොයා in
ආපසු හරහා රේඛීය සෝදිසි වැටෙන __getitem__
).
නිවැරදි කිරීම ඉතා සුළුය:
def __contains__(self, x):
return self.has_key(x)
has_key()
වන Python 2 ශබ්ද කෝෂ විශේෂිත . in
/ __contains__
භාවිතා කිරීමට නිවැරදි API; සම්පුර්ණ ස්කෑන් කිරීම වැළැක්විය නොහැකි බහාලුම් සඳහා කෙසේ හෝhas_key()
ක්රමයක් නොමැත , සහ O (1) ප්රවේශයක් තිබේ නම් එය භාවිතයට විශේෂිත වූවක් වන අතර ගැටළුව සඳහා නිවැරදි දත්ත වර්ගය තෝරා ගැනීමට සංවර්ධකයාට වේ.
Dict.has_key () සඳහා වූ විසඳුම ඉවත් කර ඇත, 'in' භාවිතා කරන්න - උත්කෘෂ්ට පෙළ සංස්කාරක 3
මෙන්න මම 'වයස්' නම් ශබ්ද කෝෂයේ උදාහරණයක් ගෙන ඇත -
ages = {}
# Add a couple of names to the dictionary
ages['Sue'] = 23
ages['Peter'] = 19
ages['Andrew'] = 78
ages['Karren'] = 45
# use of 'in' in if condition instead of function_name.has_key(key-name).
if 'Sue' in ages:
print "Sue is in the dictionary. She is", ages['Sue'], "years old"
else:
print "Sue is not in the dictionary"
has_key
ශබ්ද කෝෂ ක්රමයක් වන නමුත් in
ඕනෑම එකතුවක් මත ක්රියා කරනු ඇති අතර, නැති වූ විට පවා __contains__
, in
සොයා ගැනීම සඳහා එකතුව නැවත සැකසීමට වෙනත් ක්රමයක් භාවිතා කරනු ඇත.
in
පිළිබඳ පරීක්ෂණ සිදු කිරීම තරමක් කාර්යක්ෂම වේ range
. පයිතන් 2 xrange
හි එහි කාර්යක්ෂමතාව ගැන මට එතරම් විශ්වාසයක් නැත . ;)
__contains__
කළ හැකිය .
range
සෑම අවස්ථාවකම නව අවස්ථාවක් නිර්මාණය කිරීමේ පොදු කාර්ය ඇතුළත් වේ . කලින් පැවති තනි අවස්ථාවක් භාවිතා කරමින් “කාල පරාසය තුළ පූර්ණ සංඛ්යා” පරීක්ෂණය මගේ වේලාවන්හි 40% ක් පමණ වේගවත් වේ.
ඇඩම් පාකින්ගේ අදහස් දැක්වීම් සමඟ ඇලෙක්ස් මාටෙලිගේ කාර්ය සාධන පරීක්ෂණ පුළුල් කිරීම ...
$ python3.5 -mtimeit -s'd=dict.fromkeys(range( 99))' 'd.has_key(12)'
Traceback (most recent call last):
File "/usr/local/Cellar/python3/3.5.2_3/Frameworks/Python.framework/Versions/3.5/lib/python3.5/timeit.py", line 301, in main
x = t.timeit(number)
File "/usr/local/Cellar/python3/3.5.2_3/Frameworks/Python.framework/Versions/3.5/lib/python3.5/timeit.py", line 178, in timeit
timing = self.inner(it, self.timer)
File "<timeit-src>", line 6, in inner
d.has_key(12)
AttributeError: 'dict' object has no attribute 'has_key'
$ python2.7 -mtimeit -s'd=dict.fromkeys(range( 99))' 'd.has_key(12)'
10000000 loops, best of 3: 0.0872 usec per loop
$ python2.7 -mtimeit -s'd=dict.fromkeys(range(1999))' 'd.has_key(12)'
10000000 loops, best of 3: 0.0858 usec per loop
$ python3.5 -mtimeit -s'd=dict.fromkeys(range( 99))' '12 in d'
10000000 loops, best of 3: 0.031 usec per loop
$ python3.5 -mtimeit -s'd=dict.fromkeys(range(1999))' '12 in d'
10000000 loops, best of 3: 0.033 usec per loop
$ python3.5 -mtimeit -s'd=dict.fromkeys(range( 99))' '12 in d.keys()'
10000000 loops, best of 3: 0.115 usec per loop
$ python3.5 -mtimeit -s'd=dict.fromkeys(range(1999))' '12 in d.keys()'
10000000 loops, best of 3: 0.117 usec per loop
ඔබට මේ වගේ දෙයක් තිබේ නම්:
t.has_key(ew)
පයිතන් 3.X සහ ඊට ඉහළින් ධාවනය කිරීම සඳහා එය පහළට වෙනස් කරන්න:
key = ew
if key not in t
t.has_key(ew)
ආපසු එයි . අගය ශබ්ද කෝෂයේ නොමැති නම් නැවත පැමිණේ . එපමණක්ද නොව, අන්වර්ථය ඉතා අතිරික්ත වේ. නිවැරදි අක්ෂර වින්යාසය . මීට වසර 8 කට පෙර පිළිගත් පිළිතුර මෙයයි. True
ew
key not in t
True
key = ew
if ew in t