පයිතන්හි ඇති ශුන්‍ය වස්තුවට මා යොමු කරන්නේ කෙසේද?

පයිතන්හි, 'ශූන්‍ය' වස්තුව සිංගල්ටන් ය None.

"නොහික්මුණුකම" සඳහා දේවල් පරීක්ෂා කිරීමට හොඳම ක්‍රමය වන්නේ අනන්‍යතා ක්‍රියාකරු භාවිතා කිරීමයි is:

if foo is None:
    ...

None, පයිතන්ගේ ශූන්‍යය?

nullපයිතන් වල නැත ; ඒ වෙනුවට තියෙනවා None. දැනටමත් සඳහන් කර ඇති Noneපරිදි, යමක් වටිනාකමක් ලෙස ලබා දී ඇත්දැයි පරීක්ෂා කිරීමට වඩාත්ම නිවැරදි ක්‍රමය වන්නේ isවිචල්‍යයන් දෙකක් එකම වස්තුවකට යොමු වන බව පරීක්ෂා කරන අනන්‍යතා ක්‍රියාකරු භාවිතා කිරීමයි .

>>> foo is None
True
>>> foo = 'bar'
>>> foo is None
False

මූලික කරුණු

ඇත්තේ හා විය හැක්කේ එකක් පමණි None

Noneපංතියේ එකම අවස්ථාව වන අතර, පංතිය NoneTypeක්ෂණිකව තහවුරු කිරීමට ගන්නා ඕනෑම උත්සාහයක් එකම වස්තුවක් නැවත ලබා දෙනු ඇත None. පයිතන් වෙත නවකයන් බොහෝ විට වැරදි පණිවිඩ දකින අතර NoneTypeඑය කුමක්දැයි සඳහන් කරයි. මෙම පණිවුඩ හුදෙක් Noneනමකින් පමණක් සඳහන් කළ හැකි බව මගේ පුද්ගලික මතයයි , මන්ද අප ළඟදීම දකින පරිදි, Noneඅපැහැදිලි වීමට ඉඩක් නැත. එබැවින් මෙය කළ නොහැකි හෝ කළ නොහැකි TypeErrorයැයි සඳහන් කරන යම් පණිවිඩයක් ඔබ දුටුවහොත් NoneType, එය හුදෙක් Noneඑය කළ නොහැකි ආකාරයෙන් භාවිතා කරන පණිවිඩය බව දැන ගන්න .

එසේම, Noneසාදන ලද නියතයකි. ඔබ පයිතන් ආරම්භ කළ විගසම, මොඩියුලය, පන්තිය හෝ ක්‍රියාකාරීත්වය යන සෑම තැනකින්ම භාවිතා කළ හැකිය. NoneTypeඊට වෙනස්ව, Noneඑහි පංතිය විමසීමෙන් ඔබට පළමුව ඒ පිළිබඳ සඳහනක් ලබා ගත යුතුය .

>>> NoneType
NameError: name 'NoneType' is not defined
>>> type(None)
NoneType

ඔබට Noneපයිතන්ගේ අනන්‍යතා ක්‍රියාකාරිත්වය සමඟ ඇති සුවිශේෂත්වය පරීක්ෂා කළ හැකිය id(). එය වස්තුවකට පවරා ඇති අද්විතීය අංකය ලබා දෙයි, සෑම වස්තුවකටම එකක් ඇත. විචල්යයන් දෙකක හැඳුනුම්පත සමාන නම්, ඒවා ඇත්ත වශයෙන්ම එකම වස්තුවකට යොමු කරයි.

>>> NoneType = type(None)
>>> id(None)
10748000
>>> my_none = NoneType()
>>> id(my_none)
10748000
>>> another_none = NoneType()
>>> id(another_none)
10748000
>>> def function_that_does_nothing(): pass
>>> return_value = function_that_does_nothing()
>>> id(return_value)
10748000

None නැවත ලිවිය නොහැක

පයිතන්ගේ බොහෝ පැරණි අනුවාද වල (2.4 ට පෙර) නැවත පැවරීමට හැකි වූ Noneනමුත් තවත් නැත. පන්ති ලක්ෂණයක් ලෙස හෝ ශ්‍රිතයක සීමාවන් තුළ පවා නොවේ.

# In Python 2.7
>>> class SomeClass(object):
...     def my_fnc(self):
...             self.None = 'foo'
SyntaxError: cannot assign to None
>>> def my_fnc():
        None = 'foo'
SyntaxError: cannot assign to None

# In Python 3.5
>>> class SomeClass:
...     def my_fnc(self):
...             self.None = 'foo'
SyntaxError: invalid syntax
>>> def my_fnc():
        None = 'foo'
SyntaxError: cannot assign to keyword

එබැවින් සියලු Noneයොමු කිරීම් එක හා සමාන යැයි උපකල්පනය කිරීම ආරක්ෂිත ය . කිසිදු "චාරිත්රයක්" නොමැත None.

ක්රියාකරු Noneභාවිතා කිරීම සඳහා පරීක්ෂා කිරීමis

කේතය ලියන විට ඔබ වෙනුවෙන් ටෙස්ට් දීමට සිතිය හැකි Noneness මේ වගේ:

if value==None:
    pass

නැත්නම් මේ වගේ අසත්‍යය පරීක්ෂා කරන්න

if not value:
    pass

ඔබ ඇඟවුම් තේරුම් ගත යුතු අතර එය පැහැදිලිව දැක්වීම බොහෝ විට හොඳ අදහසකි.

1 වන අවස්ථාව: අගයක් තිබේදැයි පරීක්ෂා කිරීම None

ඇයි කරන්නේ

value is None

ඊට වඩා

value==None

?

පළමුවැන්න සමාන වේ:

id(value)==id(None)

ප්‍රකාශනය value==Noneඇත්ත වශයෙන්ම මේ ආකාරයට අදාළ වේ

value.__eq__(None)

වටිනාකම සැබවින්ම නම් Noneඔබ බලාපොරොත්තු වූ දේ ඔබට ලැබෙනු ඇත.

>>> nothing = function_that_does_nothing()
>>> nothing.__eq__(None)
True

බොහෝ සුලභ අවස්ථාවන්හිදී __eq__()ප්‍රති come ලය සමාන වනු ඇත, නමුත් ක්‍රමවේදය මඟින් කිසියම් නිරවද්‍යතාව සහතික කළ හැකි දොරක් විවෘත කරයි, මන්ද එය විශේෂ හැසිරීමක් ලබා දීම සඳහා පන්තියකදී අභිබවා යා හැකි බැවිනි.

මෙම පන්තිය සලකා බලන්න.

>>> class Empty(object):
...     def __eq__(self, other):
...         return not other

එබැවින් ඔබ එය උත්සාහ කර Noneඑය ක්‍රියාත්මක වේ

>>> empty = Empty()
>>> empty==None
True

නමුත් පසුව එය හිස් නූල මත ද ක්රියා කරයි

>>> empty==''
True

තවම

>>> ''==None
False
>>> empty is None
False

2 වන අවස්ථාව: Noneබූලියන් ලෙස භාවිතා කිරීම

පහත පරීක්ෂණ දෙක

if value:
    # Do something

if not value:
    # Do something

ඇත්ත වශයෙන්ම ලෙස ඇගයීමට ලක් කෙරේ

if bool(value):
    # Do something

if not bool(value):
    # Do something

Noneයනු "ෆෝල්සි" ය, එයින් අදහස් වන්නේ බූලියනයකට දැමුවහොත් එය නැවත පැමිණෙන Falseඅතර notක්‍රියාකරු යෙදූ විට එය නැවත පැමිණේ True. කෙසේ වෙතත් එය සුවිශේෂී දේපලක් නොවන බව සලකන්න None. Falseතමාට අමතරව , දේපල හිස් ලැයිස්තු, ටුපල්, කට්ටල, නියෝග, නූල්, මෙන්ම 0, සහ __bool__()නැවත පැමිණීමට මැජික් ක්‍රමය ක්‍රියාත්මක කරන පන්තිවල ඇති සියලුම වස්තූන් විසින් බෙදා ගනු ලැබේ False.

>>> bool(None)
False
>>> not None
True

>>> bool([])
False
>>> not []
True

>>> class MyFalsey(object):
...     def __bool__(self):
...         return False
>>> f = MyFalsey()
>>> bool(f)
False
>>> not f
True

එබැවින් පහත දැක්වෙන ආකාරයෙන් විචල්යයන් සඳහා පරීක්ෂා කිරීමේදී, ඔබ ඇතුළත් කරන්නේ හෝ පරීක්ෂණයෙන් බැහැර කරන්නේ කුමක් ද යන්න පිළිබඳව අමතර දැනුමක් ලබා ගන්න:

def some_function(value=None):
    if not value:
        value = init_value()

ඉහත සඳහන් කළ පරිදි, ඔබ init_value()අගය නිශ්චිතවම සකසා ඇති විට ඇමතීමට අදහස් කළේද None, නැතහොත් ඔබ නියම කළේ අගයක් 0හෝ හිස් නූලක් හෝ හිස් ලැයිස්තුවක් ද ආරම්භක ක්‍රියාවලිය අවුලුවන ලෙසද? මම කීවාක් මෙන් සිහියෙන් සිටින්න. බොහෝ විට සිදු වන පරිදි, පයිතන් පැහැදිළි කිරීම ව්‍යංගයට වඩා හොඳය .

None ප්රායෝගිකව

None සං signal ා අගයක් ලෙස භාවිතා කරයි

Noneපයිතන් හි විශේෂ තත්වයක් ඇත. බොහෝ ඇල්ගොරිතම එය සුවිශේෂී අගයක් ලෙස සලකන බැවින් එය ප්‍රියතම මූලික අගය වේ. එවැනි තත්වයන් තුළ එය යම් ධජයක් සඳහා විශේෂ හැසිරවීමක් අවශ්‍ය බව සං signal ා කිරීම සඳහා ධජයක් ලෙස භාවිතා කළ හැකිය (පෙරනිමි අගයක් සැකසීම වැනි).

ඔබට Noneශ්‍රිතයක මූල පද තර්ක වෙත පැවරිය හැකි අතර ඒ සඳහා පැහැදිලිව පරීක්ෂා කරන්න.

def my_function(value, param=None):
    if param is None:
        # Do something outrageous!

වස්තුවක ගුණාංගයක් ලබා ගැනීමට උත්සාහ කරන විට ඔබට එය පෙරනිමිය ලෙස ආපසු ලබා දිය හැකි අතර විශේෂ දෙයක් කිරීමට පෙර ඒ සඳහා පැහැදිලිව පරීක්ෂා කරන්න.

value = getattr(some_obj, 'some_attribute', None)
if value is None:
    # do something spectacular!

පෙරනිමියෙන් නොපවතින යතුරකට ප්‍රවේශ වීමට උත්සාහ කරන විට ශබ්ද කෝෂයේ get()ක්‍රමය නැවත පැමිණේ None:

>>> some_dict = {}
>>> value = some_dict.get('foo')
>>> value is None
True

ඔබ දායකත්ව අංකනය භාවිතා කර එයට ප්‍රවේශ වීමට උත්සාහ කරන්නේ KeyErrorනම් එය මතු වනු ඇත

>>> value = some_dict['foo']
KeyError: 'foo'

එලෙසම ඔබ නොපවතින අයිතමයක් පොප් කිරීමට උත්සාහ කරන්නේ නම්

>>> value = some_dict.pop('foo')
KeyError: 'foo'

සාමාන්‍යයෙන් සකසා ඇති පෙරනිමි අගයකින් ඔබට එය යටපත් කළ හැකිය None

value = some_dict.pop('foo', None)
if value is None:
    # Booom!

None ධජයක් සහ වලංගු අගයක් ලෙස භාවිතා කරයි

ඉහත විස්තර කර ඇති භාවිතයන් Noneවලංගු අගයක් ලෙස නොසැලකෙන විට, නමුත් විශේෂ දෙයක් කිරීමට සං signal ාවක් වැනි ය. කෙසේ වෙතත් එය Noneපැමිණියේ කොහෙන්දැයි දැන ගැනීමට වැදගත් වන අවස්ථා තිබේ, මන්ද එය සං signal ාවක් ලෙස භාවිතා කළද එය දත්තවල කොටසක් විය හැකි බැවිනි.

වස්තුවක් getattr(some_obj, 'attribute_name', None)නැවත ලබා ගැනීම සඳහා ඔබ විමසූ විට, ඔබ Noneප්‍රවේශ වීමට උත්සාහ කළ ගුණාංගය සකසා Noneඇත්ද නැතිනම් එය සම්පූර්ණයෙන්ම වස්තුවෙන් ඉවත් වී ඇත්දැයි ඔබට නොකියයි . ශබ්දකෝෂයකින් යතුරකට ප්‍රවේශවීමේදී ඇති වූ තත්වයම some_dict.get('some_key'), some_dict['some_key']නැතිවී ඇත්දැයි හෝ එය සකසා ඇත්දැයි ඔබ නොදනී None. ඔබට එම තොරතුරු අවශ්‍ය නම්, මෙය හැසිරවිය හැකි සාමාන්‍ය ක්‍රමය වන්නේ try/exceptඉදිකිරීමක් තුළ සිට ගුණාංගය හෝ යතුර වෙත ප්‍රවේශ වීමට උත්සාහ කිරීමයි :

try:
    # Equivalent to getattr() without specifying a default
    # value = getattr(some_obj, 'some_attribute')
    value = some_obj.some_attribute
    # Now you handle `None` the data here
    if value is None:
        # Do something here because the attribute was set to None
except AttributeError:
    # We're now handling the exceptional situation from here.
    # We could assign None as a default value if required.
    value = None
    # In addition, since we now know that some_obj doesn't have the
    # attribute 'some_attribute' we could do something about that.
    log_something(some_obj)

ඒ හා සමානව:

try:
    value = some_dict['some_key']
    if value is None:
        # Do something here because 'some_key' is set to None
except KeyError:
    # Set a default
    value = None
    # And do something because 'some_key' was missing
    # from the dict.
    log_something(some_dict)

ඉහත උදාහරණ දෙකෙන් දැක්වෙන්නේ වස්තු හා ශබ්ද කෝෂ හැසිරවිය යුතු ආකාරයයි. කාර්යයන් ගැන කුමක් කිව හැකිද? එකම දෙය, නමුත් අපි ඒ සඳහා ද්විත්ව තරු ලකුණු මූල පදය භාවිතා කරමු:

def my_function(**kwargs):
    try:
        value = kwargs['some_key']
        if value is None:
            # Do something because 'some_key' is explicitly
            # set to None
    except KeyError:
        # We assign the default
        value = None
        # And since it's not coming from the caller.
        log_something('did not receive "some_key"')

None වලංගු අගයක් ලෙස පමණක් භාවිතා කරයි

කොඩි සහ දත්ත try/exceptඅතර වෙනස හඳුනා ගැනීම සඳහා ඔබේ කේතය ඉහත රටාව සමඟ පැටලී ඇති බව ඔබ දුටුවහොත් , තවත් පරීක්ෂණ අගයක් භාවිතා කරන්න. වලංගු අගයන් සමූහයට පිටින් වැටෙන අගයක් දත්ත ව්‍යුහයක දත්තවල කොටසක් ලෙස ඇතුළත් කර ඇති අතර විශේෂ කොන්දේසි පාලනය කිරීමට සහ පරීක්ෂා කිරීමට භාවිතා කරයි (උදා: සීමාවන්, තත්වය, ආදිය). එවැනි අගයක් සෙන්ඩිනල් ලෙස හැඳින්වෙන අතර එය සං .ාවක් ලෙස භාවිතා කරන ආකාරය භාවිතා කළ හැකිය. පයිතන් හි සෙන්ඩිනල් එකක් නිර්මාණය කිරීම සුළුපටු ය.NoneNoneNone

undefined = object()

මෙම undefinedසුවිශේෂී වන අතර වැඩසටහන සඳහා පොලී විය හැකි බව ඕනෑම දෙයක් බොහෝ කරන්නේ නැත ඉහත වස්තුව, එය මෙසේ සඳහා විශිෂ්ට වෙනුවට තියෙන්නේ Noneකොඩි ලෙස. සමහර අවවාද අදාළ වේ, කේතයෙන් පසුව ඒ ගැන වැඩි විස්තර.

ක්රියාකාරිත්වය සමඟ

def my_function(value, param1=undefined, param2=undefined):
    if param1 is undefined:
        # We know nothing was passed to it, not even None
        log_something('param1 was missing')
        param1 = None


    if param2 is undefined:
        # We got nothing here either
        log_something('param2 was missing')
        param2 = None

ආ ict ාව සමඟ

value = some_dict.get('some_key', undefined)
if value is None:
    log_something("'some_key' was set to None")

if value is undefined:
    # We know that the dict didn't have 'some_key'
    log_something("'some_key' was not set at all")
    value = None

වස්තුවක් සමඟ

value = getattr(obj, 'some_attribute', undefined)
if value is None:
    log_something("'obj.some_attribute' was set to None")
if value is undefined:
    # We know that there's no obj.some_attribute
    log_something("no 'some_attribute' set on obj")
    value = None

මා කලින් සඳහන් කළ පරිදි, අභිරුචි සෙන්ඩිනල්වරු සමහර අවවාද සමඟ පැමිණෙති. පළමුව, ඒවා වැනි මූල පද නොවේ None, එබැවින් පයිතන් ඒවා ආරක්ෂා නොකරයි. ඔබට undefinedඉහත ඕනෑම වේලාවක, එය නිර්වචනය කර ඇති මොඩියුලයේ ඕනෑම තැනක නැවත ලිවිය හැකිය , එබැවින් ඔබ ඒවා නිරාවරණය කර භාවිතා කරන ආකාරය ගැන සැලකිලිමත් වන්න. ඊළඟට, ආපසු ලබා දුන් අවස්ථාව object()තනි පුද්ගලයෙක් නොවේ. ඔබ එම ඇමතුම 10 වතාවක් කළහොත් ඔබට විවිධ වස්තු 10 ක් ලැබේ. අවසාන වශයෙන්, සෙන්ඩිනල් භාවිතා කිරීම අතිශයින්ම විකාරයකි. සෙන්ඩිනල් එකක් එය භාවිතා කරන පුස්තකාලයට විශේෂිත වන අතර එහි විෂය පථය සාමාන්‍යයෙන් පුස්තකාලයේ අභ්‍යන්තරයට පමණක් සීමා විය යුතුය. එය "කාන්දු" නොවිය යුතුය. බාහිර කේතය ඒ පිළිබඳව දැනුවත් විය යුත්තේ ඒවායේ අරමුණ පුස්තකාලයේ API දීර් extend කිරීම හෝ අතිරේක කිරීම නම් පමණි.

එය වෙනත් භාෂාවල මෙන් ශුන්‍ය යැයි නොකියයි, නමුත් None. මෙම වස්තුවේ සෑම විටම ඇත්තේ එක් අවස්ථාවක් පමණි, එබැවින් ඔබට අවශ්‍ය නම් x is Noneඒ වෙනුවට (අනන්‍යතා සංසන්දනය) සමානකම් තිබේදැයි පරීක්ෂා කළ හැකිය x == None.

Python දී, අගය නොමැති නියෝජනය කිරීමට, ඔබ භාවිතා කළ හැකිය කිසිවක් අගය ( types.NoneType.None වස්තූන් සඳහා) සහ "" (හෝ ලෙන් () == 0 ) නූල් සඳහා. එබැවින්:

if yourObject is None:  # if yourObject == None:
    ...

if yourString == "":  # if yourString.len() == 0:
    ...

"==" සහ "යනු" අතර වෙනස සම්බන්ධයෙන්, "==" භාවිතා කරමින් වස්තු අනන්‍යතාවය පරීක්ෂා කිරීම ප්‍රමාණවත් විය යුතුය. කෙසේ වෙතත්, "is" මෙහෙයුම වස්තු අනන්‍යතා මෙහෙයුම ලෙස අර්ථ දක්වා ඇති හෙයින්, එය බොහෝ විට "==" වෙනුවට එය භාවිතා කිරීම වඩාත් නිවැරදිය. වේග වෙනසක් පවා තිබේදැයි විශ්වාස නැත.

කෙසේ වෙතත්, ඔබට බලන්න පුළුවන්:

• පයිතන් බිල්ට්-ඉන් කොන්ස්ටන්ට්ස් ඩොක් පිටුව.
• පයිතන් සත්‍ය අගය පරීක්ෂා කිරීමේ ලේඛනය.

Null යනු විශේෂ වස්තු වර්ගයකි:

>>>type(None)
<class 'NoneType'>

වස්තුවක් 'කිසිවක් ටයිප්' පන්තියේ තිබේදැයි ඔබට පරීක්ෂා කළ හැකිය:

>>>variable = None
>>>variable is None
True

වැඩි විස්තර පයිතන් ඩොක්ස් වෙතින් ලබා ගත හැකිය

සත්‍ය අගය පරීක්ෂා කිරීමකට අනුව , 'කිසිවක්' කෙලින්ම අසත්‍යය ලෙස පරීක්ෂා කරයි, එබැවින් සරලම ප්‍රකාශනය ප්‍රමාණවත් වේ:

if not foo: