'==' හෝ 'is' භාවිතා කරමින් නූල් සංසන්දනය කිරීම සමහර විට වෙනස් ප්‍රති result ලයක් ලබා දෙන්නේ ඇයි?

1161

මට පයිතන් වැඩසටහනක් ඇත, එහිදී විචල්‍යයන් දෙකක් අගයට සකසා ඇත 'public'. කොන්දේසි සහිත ප්‍රකාශනයක මා සතුව සංසන්දනය var1 is var2අසාර්ථක වන නමුත් මම එය වෙනස් කළහොත් var1 == var2එය නැවත පැමිණේ True.

දැන් මම මගේ පයිතන් පරිවර්තකය විවෘත කර “සමාන” සංසන්දනය කළහොත් එය සාර්ථක වේ.

>>> s1 = 'public'
>>> s2 = 'public'
>>> s2 is s1
True

මට මෙහි නැති වී ඇත්තේ කුමක්ද?

— ජොටෝස්
source

8

බලන්න: stackoverflow.com/questions/1392433/…

— නික් දන්ඩෝලාකිස්

3

උදා: හරහා ඔබ කොන්සෝල ආදානය කියවන විටද මෙම ගැටළුව ඇතිවේ input = raw_input("Decide (y/n): "). මෙම අවස්ථාවෙහිදී "y" ආදානය සහ if input == 'y':"සත්‍ය" if input is 'y':නැවත ලබා දෙන අතර අසත්‍යය නැවත ලබා දෙනු ඇත.

— Semjon Mössinger

4

මෙම බ්ලොග් අඩවිය ඕනෑම පිළිතුරකට වඩා සම්පූර්ණ පැහැදිලි කිරීමක් සපයයි guilload.com/python-string-interning

— Chris_Rands

1

@ Chris

— rico

4

විය හැකි අනුපිටපත පයිතන් හි `==` සහ` යනු` අතර වෙනසක් තිබේද?

— තක්නොක්

1543

isඅනන්‍යතා පරීක්ෂාව ==යනු සමානාත්මතාවය පරීක්ෂා කිරීමයි. ඔබේ කේතයේ සිදුවන්නේ කුමක්ද යන්න පරිවර්තකයා විසින් අනුකරණය කරනු ඇත:

>>> a = 'pub'
>>> b = ''.join(['p', 'u', 'b'])
>>> a == b
True
>>> a is b
False

ඉතින්, ඔවුන් එක හා සමාන නොවීම පුදුමයක් නොවේ, හරිද?

වෙනත් වචන වලින් කිවහොත්: isයනුid(a) == id(b)

— නිහ ile අවතාරය
source

17

අහ් eq ට සමානද? එදිරිව සමානද? යෝජනා ක්‍රමයේදී, එය ලැබුණි.

— ජොටෝස්

48

හෝ ජාවා හි ==එදිරිව .equals(). හොඳම දෙය නම් පයිතන් ==ජාවා වලට සමාන නොවන බවයි ==.

— MatrixFrog

11

@ Крайст: ඇත්තේ එකම Noneඅගයක් පමණි . එබැවින් සෑම විටම එකම හැඳුනුම්පතක් ඇත.

— SilentGhost

19

මෙය OP හි "is -> True" උදාහරණය අමතන්නේ නැත.

— user2864740

6

String ඇලෙක්සැන්ඩර් සුපර්ට්‍රම්ප්, නූල් සීමාව නිසා .

— ක්‍රිස් රිකෝ

577

: මෙහි වෙනත් පිළිතුරු නිවැරදි isසඳහා භාවිතා කරනු ඇත අනන්යතාව අතර සංසන්දනය, ==සඳහා භාවිතා කරනු ඇත සමානාත්මතාවය රකිති. ඔබ සැලකිලිමත් වන්නේ සමානාත්මතාවය නිසා (නූල් දෙකෙහි එකම අක්ෂර අඩංගු විය යුතුය), මේ අවස්ථාවේ දී isක්‍රියාකරු සරලවම වැරදියි, ==ඒ වෙනුවට ඔබ භාවිතා කළ යුතුය .

හේතුව isඅනොන්ය වැඩ (බොහෝ) string literals සිටින බව ය සිර පෙරනිමියෙන්. විකිපීඩියාවෙන්:

අභ්‍යන්තර නූල් නූල් සැසඳීම් වේගවත් කරයි, සමහර විට යෙදුම්වල කාර්ය සාධන බාධකයක් වේ (සම්පාදකයින් සහ ගතික ක්‍රමලේඛන භාෂා ධාවන වේලාවන් වැනි) ඒවා යතුරු යතුරු සහිත හැෂ් වගු මත දැඩි ලෙස රඳා පවතී. සීමාවකින් තොරව, වෙනස් නූල් දෙකක් සමාන දැයි පරීක්ෂා කිරීම සඳහා නූල් දෙකේම සෑම අක්‍ෂරයක්ම පරීක්ෂා කිරීම ඇතුළත් වේ. හේතු කිහිපයක් නිසා මෙය මන්දගාමී වේ: එය සහජයෙන්ම නූල් වල දිග O (n) වේ; එයට සාමාන්‍යයෙන් කාලය ගතවන මතක කලාප කිහිපයකින් කියවීම් අවශ්‍ය වේ; කියවීම් මඟින් ප්‍රොසෙසර් හැඹිලිය පුරවයි, එයින් අදහස් කරන්නේ වෙනත් අවශ්‍යතා සඳහා අඩු හැඹිලියක් ඇති බවයි. අභ්‍යන්තර නූල් සමඟ, මුල් අභ්‍යන්තර මෙහෙයුමෙන් පසු සරල වස්තු අනන්‍යතා පරීක්ෂණයක් ප්‍රමාණවත් වේ; මෙය සාමාන්‍යයෙන් ක්‍රියාත්මක වන්නේ දර්ශක සමානාත්මතා පරීක්ෂණයක් ලෙස ය,

එබැවින්, ඔබේ වැඩසටහනේ එකම වටිනාකමක් ඇති වචන වචන දෙකක් (ඔබේ වැඩසටහන් ප්‍රභව කේතයට වචනාර්ථයෙන් ටයිප් කර ඇති, උද්ධෘත ලකුණු වලින් වටවී ඇති) ඇති විට, පයිතන් සම්පාදකයා ස්වයංක්‍රීයව නූල් වලට සම්බන්ධ වන අතර ඒ දෙකම එකම ස්ථානයක ගබඩා වේ. මතක ස්ථානය. (මෙය සැමවිටම සිදු නොවන බව සලකන්න. මෙය සිදු වන විට ඇති වන නීති තරමක් සංවර වී ඇත, එබැවින් කරුණාකර නිෂ්පාදන කේතයෙහි මෙම හැසිරීම මත රඳා නොසිටින්න!)

ඔබගේ අන්තර්ක්‍රියාකාරී සැසියේදී නූල් දෙකම එකම මතක ස්ථානයක ගබඩා කර ඇති බැවින් ඒවාට එකම අනන්‍යතාවයක් ඇත , එබැවින් isක්‍රියාකරු බලාපොරොත්තු වූ පරිදි ක්‍රියා කරයි. නමුත් ඔබ වෙනත් ක්‍රමයකින් නූලක් සාදන්නේ නම් (එම නූල හරියටම එකම අක්ෂර අඩංගු වුවද ), එවිට එම නූල සමාන විය හැකිය , නමුත් එය එකම නූලක් නොවේ - එනම් එයට වෙනස් අනන්‍යතාවයක් ඇත , මන්ද එය මතකයේ වෙනත් ස්ථානයක ගබඩා කර ඇත.

— ඩැනියෙල් ප්‍රයිඩන්
source

6

නූල් බැඳ ඇති විට යමෙකුට කැටි ගැසුණු නීති පිළිබඳ වැඩිදුර කියවිය හැක්කේ කොතැනින්ද?

— නොක්ටිස් ස්කයිටවර්

90

සවිස්තරාත්මක පැහැදිලි කිරීමක් සඳහා +1. ඇත්ත වශයෙන්ම සිදුවූයේ කුමක්ද යන්න පැහැදිලි නොකර අනෙක් පිළිතුරට මෙතරම් ඉහළ නැංවීම් ලැබුණේ කෙසේදැයි විශ්වාස නැත.

— That1Guy

4

ප්‍රශ්නය කියවන විට මා සිතුවේ මෙයයි. පිළිගත් පිළිතුර කෙටි නමුත් කාරණය අඩංගු වේ, නමුත් මෙම පිළිතුර වඩා හොඳ දේවල් පැහැදිලි කරයි . හොඳයි!

— Sнаđошƒаӽ

3

@NoctisSkytower එයම ගූගල් කර මෙම guilload.com/python-string-interning

— xtreak

5

@ naught101: නෑ, පාලනය අතර තෝරා ගැනීමට ය ==සහ isඔබට අවශ්ය චෙක්පත මොන වගේ මත පදනම් වූ. නූල් සමාන වීම ගැන ඔබ සැලකිලිමත් වන්නේ නම් (එනම් එකම අන්තර්ගතයන් තිබීම) ඔබ සැමවිටම භාවිතා කළ යුතුය ==. කිසියම් පයිතන් නම් දෙකක් එකම වස්තු උදාහරණයකට යොමු වන්නේ දැයි ඔබ සැලකිලිමත් වන්නේ නම්, ඔබ භාවිතා කළ යුතුය is. ඔබ isඒවායේ අන්තර්ගතයන් ගැන සැලකිලිමත් නොවී විවිධ අගයන් හසුරුවන කේතයක් ලියන්නේ නම් ඔබට අවශ්‍ය විය හැකිය , එසේත් නැතිනම් එහි ඇත්තේ එකක් පමණක් බව ඔබ දන්නේ නම් සහ එම දේ මවා පෙන්වන වෙනත් වස්තූන් නොසලකා හැරීමට ඔබට අවශ්‍යය. ඔබට විශ්වාස නැත්නම්, සෑම විටම තෝරා ගන්න ==.

— ඩැනියෙල් ප්‍රයිඩන්

108

මෙම isඅතර මූල පදය වස්තුව අනන්යතාව සඳහා පරීක්ෂණයකි ==අගය හා සසඳන වේ.

ඔබ භාවිතා කරන්නේ නම් is, ප්‍රති result ලය සත්‍ය වනුයේ වස්තුව එකම වස්තුවක් නම් පමණි. කෙසේ වෙතත්, ==වස්තුවේ අගයන් සමාන වන ඕනෑම වේලාවක සත්‍ය වනු ඇත.

— තෝමස් ඕවන්ස්
source

57

සටහන් කළ යුතු අවසාන කරුණ නම්, ඔබට sys.internඑකම නූලට යොමු කිරීමක් ලැබෙන බව සහතික කිරීම සඳහා ඔබට ශ්‍රිතය භාවිතා කළ හැකිය :

>>> from sys import intern
>>> a = intern('a')
>>> a2 = intern('a')
>>> a is a2
True

ඉහත පෙන්වා දී ඇති පරිදි, isනූල්වල සමානාත්මතාවය තීරණය කිරීම සඳහා ඔබ භාවිතා නොකළ යුතුය . නමුත් ඔබට භාවිතා කිරීමට යම් ආකාරයක අමුතු අවශ්‍යතාවයක් තිබේදැයි දැන ගැනීමට මෙය ප්‍රයෝජනවත් විය හැකිය is.

බව සටහන internකාර්යය Python 2 මත builtin විය කිරීම සඳහා භාවිතා නමුත් ගෙන යන ලදී sysPython 3 මොඩියුලය.

— ජේසන් බේකර්
source

43

isඅනන්‍යතා පරීක්ෂාව ==යනු සමානාත්මතාවය පරීක්ෂා කිරීමයි. මෙයින් අදහස් කරන්නේ එය isකරුණු දෙකක් එක හා සමාන දැයි පරීක්ෂා කිරීමේ ක්‍රමයකි දේද, නැතිනම් .

ඔබට සරල personවස්තුවක් ඇති බව පවසන්න . එය 'ජැක්' ලෙස නම් කර අවුරුදු 23 ක් නම්, එය තවත් අවුරුදු 23 ක් පැරණි ජැක්ට සමාන ය, නමුත් එය එකම පුද්ගලයා නොවේ.

class Person(object):
   def __init__(self, name, age):
       self.name = name
       self.age = age

   def __eq__(self, other):
       return self.name == other.name and self.age == other.age

jack1 = Person('Jack', 23)
jack2 = Person('Jack', 23)

jack1 == jack2 #True
jack1 is jack2 #False

ඔවුන් එකම වයසේ පසුවන නමුත් ඔවුන් පුද්ගලයාගේ එකම අවස්ථාව නොවේ. නූලක් තවත් එකකට සමාන විය හැකි නමුත් එය එකම වස්තුවක් නොවේ.

— ටැන්කර්ස්මාෂ්
source

ඔබ කට්ටලය වෙනස් jack1.age = 99කළහොත් එය වෙනස් නොවේ jack2.age. ඒ ඒවා එකිනෙකට වෙනස් අවස්ථා දෙකක් නිසා ය jack1 is not jack2. කෙසේ වෙතත්, jack1 == jack2ඔවුන්ගේ නම සහ වයස සමාන නම් ඔවුනට එකිනෙකාට සමාන විය හැකිය . එය නූල් සඳහා වඩාත් සංකීර්ණ වේ, මන්ද පයිතන්හි නූල් වෙනස් නොවන අතර පයිතන් බොහෝ විට එකම අවස්ථාව නැවත භාවිතා කරයි. මම මෙම පැහැදිලි කිරීමට කැමතියි එය සරල අවස්ථා (සාමාන්‍ය වස්තුවක්) වෙනුවට විශේෂ අවස්ථා (නූල්) භාවිතා කරන නිසා.

— Flimm

37

මෙය පැති සටහනකි, නමුත් මුග්ධ පයිතන් වලදී, ඔබ බොහෝ විට මෙවැනි දේ දකිනු ඇත:

if x is None: 
    # some clauses

මෙය ආරක්ෂිතයි, මන්ද ශුන්‍ය වස්තුවෙහි එක් අවස්ථාවක් (එනම් කිසිවක් නැත) සහතික වී ඇති බැවිනි .

— ග්‍රෙග් ලින්ඩ්
source

1

සත්‍ය සහ අසත්‍යය සඳහා ද එය එසේම ද? ගැලපෙන්නේ එක් අවස්ථාවක් පමණක් ද?

— හැන්ඩි මෑන්

1

AndHandyManDan ඔව්, ඒවා පයිතන් 2 සහ 3 යන දෙකෙහිම තනි

— තලයන් වේ

amkamillitw නමුත් පයිතන් 2 හි ඔබට වැරදි සහ සත්‍ය නැවත පැවරිය හැකිය.

— මාර්ටිජන් පීටර්ස්

28

ඔබ කරන්නේ කුමක්දැයි ඔබට විශ්වාස නැත්නම්, '==' භාවිතා කරන්න. ඔබට ඒ ගැන තව ටිකක් දැනුමක් තිබේ නම්, ඔබට 'නැත' වැනි දන්නා වස්තූන් සඳහා 'is' භාවිතා කළ හැකිය.

එසේ නොමැතිනම් දේවල් ක්‍රියාත්මක නොවන්නේ ඇයි සහ මෙය සිදුවන්නේ ඇයිදැයි ඔබ කල්පනා කරනු ඇත.

>>> a = 1
>>> b = 1
>>> b is a
True
>>> a = 6000
>>> b = 6000
>>> b is a
False

විවිධ පයිතන් අනුවාදයන් / ක්‍රියාත්මක කිරීම් අතර සමහර දේවල් එක හා සමානව පවතිනු ඇතැයි මට විශ්වාස නැත.

— මැටියාස් නිල්සන්
source

1

තීන්ත නැවත පැවරීම මෙම තත්වය අවුලුවන ආකාරය පෙන්වන සිත්ගන්නා උදාහරණයකි. මෙය අසාර්ථක වූයේ ඇයි? එය සීමාවාසික පුහුණුව නිසාද නැත්නම් වෙනත් දෙයක් නිසාද?

— පෝල්

පරිවර්තකය ක්‍රියාත්මක කිරීම නිසා ව්‍යාජ ලෙස ආපසු පැමිණීමට හේතුව පෙනේ: stackoverflow.com/questions/132988/…

— පෝල්

1

කියවන්න: stackoverflow.com/questions/306313/… සහ stackoverflow.com/questions/11476190/why-0-6-is-6-false

— Archit Jain

@ArchitJain ඔව්, එම සබැඳි එය ඉතා හොඳින් පැහැදිලි කරයි. ඔබ ඒවා කියවන විට, ඔබට 'සක්‍රීයව' භාවිතා කළ හැකි සංඛ්‍යා මොනවාදැයි ඔබ දැන ගනු ඇත. එය එසේ කිරීම තවමත් හොඳ අදහසක් නොවන්නේ මන්දැයි ඔවුන් පැහැදිලි කරනු ඇතැයි මම ප්‍රාර්ථනා කරමි :) ඔබ මෙය දැන සිටීම අනෙක් සියල්ලන්ම එසේ කරයි යැයි සිතීම හොඳ අදහසක් නොවේ (හෝ අභ්‍යන්තර අංක පරාසය කිසි විටෙකත් වෙනස් නොවේ)

— මැටියාස් නිල්සන්

20

පයිතන් සමඟ ඇති මගේ සීමිත අත්දැකීම් වලින්, isඑකම වටිනාකමක් ඇති විවිධ වස්තු දෙකකට වඩා එකම වස්තුවක් දැයි බැලීමට වස්තු දෙකක් සංසන්දනය කිරීමට භාවිතා කරයි. ==අගයන් සමාන දැයි තීරණය කිරීමට භාවිතා කරයි.

මෙන්න හොඳ උදාහරණයක්:

>>> s1 = u'public'
>>> s2 = 'public'
>>> s1 is s2
False
>>> s1 == s2
True

s1යුනිකෝඩ් නූලක් වන අතර s2එය සාමාන්‍ය නූලකි. ඒවා එකම වර්ගයක් නොව එකම අගයයි.

— ජැක් එම්.
source

18

'එය' සංසන්දනය අසත්‍යය ලෙස තක්සේරු කරන විට, වෙනස් වස්තු දෙකක් භාවිතා කිරීම යන කාරණය සමඟ එය සම්බන්ධ යැයි මම සිතමි. එය සත්‍යය ලෙස තක්සේරු කරන්නේ නම්, එයින් අදහස් වන්නේ අභ්‍යන්තරව එය එකම නිශ්චිත වස්තුවක් භාවිතා කරන අතර නව එකක් නිර්මාණය නොකිරීමයි, සමහර විට ඔබ ඒවා තත්පර 2 ක් හෝ ඊට අඩු කාලයකින් නිර්මාණය කළ නිසාත් එය අතර ප්‍රශස්තකරණය සහ විශාල කාල පරතරයක් නොමැති නිසාත් විය හැකිය. එකම වස්තුව භාවිතා කරයි.

මේ නිසා ඔබ භාවිතා කළ යුත්තේ සමානාත්මතා ක්‍රියාකරු ==මිස isනූල් වස්තුවක වටිනාකම සංසන්දනය කිරීම සඳහා නොවේ.

>>> s = 'one'
>>> s2 = 'two'
>>> s is s2
False
>>> s2 = s2.replace('two', 'one')
>>> s2
'one'
>>> s2 is s
False
>>>

මෙම උදාහරණයේ දී, මම s2 සෑදුවෙමි, එය මීට පෙර 'එකකට' සමාන වූ වෙනස් නූල් වස්තුවකි, නමුත් එය සමාන වස්තුවක් නොවේ s, මන්ද මා මුලින් 'එකකට' පවරා නොතිබූ බැවින් පරිවර්තකයා එකම වස්තුව භාවිතා නොකළේය. මා සතුව තිබුනේ නම් ඔවුන් එකම වස්තුවක් බවට පත් වනු ඇත.

— meder omuraliev
source

3

.replace()මෙම සන්දර්භය තුළ නිදසුනක් ලෙස භාවිතා කිරීම හොඳම නොවේ, නමුත් එහි අර්ථ නිරූපණය ව්‍යාකූල විය හැකි බැවිනි. s2 = s2.replace()ඇත හැම විටම එය නිර්මාණය නව , නූල් වස්තුව නව සංගීත වස්තුව අනුයුක්ත s2, එවිට ඒ වැල වස්තුව ඉවත් s2කිරීමට අදහස් කිරීම සඳහා යොදා ගනී. එබැවින් ඔබ එසේ කළද s = s.replace('one', 'one')ඔබට තවමත් නව සංගීත වස්තුවක් ලැබෙනු ඇත.

— ඩැනියෙල් ප්‍රයිඩන්

13

මෙය "සීමාවාසික" නූල් ලෙස හැඳින්වෙන බව මම විශ්වාස කරමි. පයිතන් මෙය කරයි, ජාවා ද එසේ කරයි, එසේම ප්‍රශස්ත මාතයන් සම්පාදනය කිරීමේදී C සහ C ++ ද කරන්න.

ඔබ සමාන නූල් දෙකක් භාවිතා කරන්නේ නම්, නූල් වස්තු දෙකක් නිර්මාණය කිරීමෙන් මතකය නාස්ති කරනවා වෙනුවට, එකම අන්තර්ගතයන් සහිත සියලු නූල් එකම මතකයට යොමු වේ.

මෙහි ප්‍රති results ලය වන්නේ පයිතන් “යනු” ක්‍රියාකරු සත්‍යය ආපසු ලබා දීමයි, මන්ද එකම අන්තර්ගතයන් සහිත නූල් දෙකක් එකම නූල් වස්තුවකට යොමු වන බැවිනි. මෙය ජාවා සහ සී වලද සිදුවනු ඇත.

මෙය ප්‍රයෝජනවත් වන්නේ මතක ඉතිරිකිරීම් සඳහා පමණි. නූල් සමානාත්මතාවය පරීක්ෂා කිරීම සඳහා ඔබට එය මත විශ්වාසය තැබිය නොහැක, මන්ද විවිධ පරිවර්තකයන් සහ සම්පාදකයින් සහ JIT එන්ජින් සෑම විටම එය කළ නොහැක.

— සැන් ලින්ක්ස්
source

12

ඉහත පිළිතුර කිසිදු භාෂා සඳහනක් උපුටා නොදක්වන හෙයින් ප්‍රශ්නය පරණ වුවත් මම ප්‍රශ්නයට පිළිතුරු දෙමි

ඇත්ත වශයෙන්ම ක්‍රියාකරු අනන්‍යතාවය පරීක්ෂා කරන අතර == ක්‍රියාකරු සමානාත්මතාවය සඳහා පරීක්ෂා කරයි,

භාෂා යොමුවෙන්:

වස්තු හැසිරීමේ සෑම අංශයකටම පාහේ වර්ග බලපායි. වස්තු අනන්‍යතාවයේ වැදගත්කම පවා යම් අර්ථයකින් බලපායි: වෙනස් කළ නොහැකි වර්ග සඳහා, නව අගයන් ගණනය කරන මෙහෙයුම් ඇත්ත වශයෙන්ම පවත්නා ඕනෑම වස්තුවකට එකම වර්ගයේ සහ වටිනාකමක් සහිත යොමු කිරීමක් ලබා දිය හැකි අතර විකෘති වස්තු සඳහා මෙය අවසර නැත . උදා, a = 1 පසු; b = 1, a සහ b ක්‍රියාත්මක කිරීම මත පදනම්ව එකම අගය සහිත අගය සමඟ එකම වස්තුවක් යොමු කිරීමට හෝ නොකිරීමට ඉඩ ඇත, නමුත් c = [] ට පසුව; d = [], c සහ d වෙනස්, අද්විතීය, අලුතින් සාදන ලද හිස් ලැයිස්තු දෙකක් වෙත යොමු කිරීම සහතික කෙරේ. (C = d = [] එකම වස්තුව c සහ d යන දෙකටම පවරන බව සලකන්න.)

එබැවින් ඉහත ප්‍රකාශයෙන් අපට නිගමනය කළ හැක්කේ වෙනස් කළ නොහැකි ආකාරයේ නූල් “is” සමඟ පරීක්ෂා කිරීමේදී අසමත් විය හැකි අතර “is” සමඟ පරීක්ෂා කළ විට එය සාර්ථකදැයි පරීක්ෂා කළ හැකිය.

වෙනස් කළ නොහැකි වර්ග වන int, tuple සඳහාද මෙය අදාළ වේ

— RAM
source

8

මෙම ==ක්රියාකරු ටෙස්ට් අගය සමාන වචන. මෙම isක්රියාකරු වස්තුව අනන්යතාව පරීක්ෂා කර, Python දෙක ඇත්තටම (එනම්, මතකය එම ලිපිනයේ සජීවී) එම වස්තුව යන්න පරීක්ෂා.

>>> a = 'banana'
>>> b = 'banana'
>>> a is b 
True

මෙම උදාහරණයේ දී, Python එකම එක string වස්තුව නිර්මාණය, දෙකම aහා bඑයින් අදහස් වේ. හේතුව, පයිතන් අභ්‍යන්තරව හැඹිලි සහ සමහර නූල් ප්‍රශස්තිකරණය ලෙස නැවත භාවිතා කිරීම, ඇත්ත වශයෙන්ම මතකයේ ඇත්තේ 'කෙසෙල්' නූලක් පමණි, එය a සහ b විසින් බෙදාගෙන ඇත; සාමාන්‍ය හැසිරීම අවුලුවාලීමට, ඔබ දිගු නූල් භාවිතා කළ යුතුය:

>>> a = 'a longer banana'
>>> b = 'a longer banana'
>>> a == b, a is b
(True, False)

ඔබ ලැයිස්තු දෙකක් සාදන විට, ඔබට වස්තු දෙකක් ලැබේ:

>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> a is b
False

මෙම අවස්ථාවේ දී අපි ලැයිස්තු දෙක සමාන යැයි කියමු, මන්ද ඒවා එකම මූලද්‍රව්‍යයන් ඇති නමුත් ඒවා සමාන නොවේ, මන්ද ඒවා එකම වස්තුවක් නොවන බැවිනි. වස්තූන් දෙකක් සමාන නම්, ඒවා ද සමාන වේ, නමුත් ඒවා සමාන නම්, ඒවා අනිවාර්යයෙන්ම සමාන නොවේ.

යම් aවස්තුවක් ගැන සඳහන් කර ඔබ පවරන්නේ b = aනම්, විචල්‍යයන් දෙකම එකම වස්තුවකට යොමු වේ:

>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True

— X. වැන්ග්
source

7

isමතක ස්ථානය සංසන්දනය කරයි. එය වස්තු මට්ටමේ සංසන්දනය සඳහා යොදා ගනී.

==වැඩසටහනේ විචල්‍යයන් සංසන්දනය කරයි. එය අගය මට්ටමින් පරීක්ෂා කිරීම සඳහා භාවිතා කරයි.

is ලිපින මට්ටමේ සමානතාව සඳහා පරික්ෂා කරයි

== අගය මට්ටමේ සමානතාව සඳහා පරික්ෂා කරයි

— ජොනාෂු
source

3

isඅනන්‍යතා පරීක්ෂාව ==යනු සමානාත්මතාවය පරීක්ෂා කිරීමයි ( පයිතන් ප්‍රලේඛනය බලන්න ).

බොහෝ අවස්ථාවලදී, එසේ a is bනම් a == b. නමුත් ව්යතිරේක පවතී, උදාහරණයක් ලෙස:

>>> nan = float('nan')
>>> nan is nan
True
>>> nan == nan
False

එබැවින්, ඔබට භාවිතා කළ හැක්කේ isඅනන්‍යතා පරීක්ෂණ සඳහා පමණි , කිසි විටෙකත් සමානාත්මතා පරීක්ෂණ නොවේ.

— රයන්
source