විචල්‍යයක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

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

try:
   myVar
except NameError:
   # Do something.

ව්යතිරේක නොමැතිව වෙනත් ක්රම තිබේද?

දේශීය විචල්‍යයක පැවැත්ම පරීක්ෂා කිරීම සඳහා:

if 'myVar' in locals():
  # myVar exists.

ගෝලීය විචල්‍යයක පැවැත්ම පරීක්ෂා කිරීම සඳහා:

if 'myVar' in globals():
  # myVar exists.

වස්තුවකට ලක්ෂණයක් තිබේදැයි පරීක්ෂා කිරීමට:

if hasattr(obj, 'attr_name'):
  # obj.attr_name exists.

මෙම භාවිතය අර්ථ හෝ කට්ටලයක් (නිසැකයෙන්ම ඒම හෝ) කර කර නැති විචල්යයන් සැමවිටම පාහේ නරක දෙයක් ඕනෑම එය බොහෝ විට මෙම වැඩසටහන තර්කනය නිසි සිතා කර නොමැති බව පෙන්නුම්, හා එහි ප්රතිඵලයක් විය හැකි නිසා, භාෂාව අනපේක්ෂිත හැසිරීම් වල.

ඔබට එය පයිතන් හි කිරීමට අවශ්‍ය නම් , පහත දැක්වෙන උපක්‍රමය ඔබට සමාන වන අතර භාවිතයට පෙර විචල්‍යයකට යම් අගයක් ඇති බව සහතික කරයි:

try:
    myVar
except NameError:
    myVar = None

# Now you're free to use myVar without Python complaining.

කෙසේ වෙතත්, එය හොඳ අදහසක් බව මට තවමත් ඒත්තු ගොස් නැත - මගේ මතය අනුව, මෙම තත්වය ඇති නොවන පරිදි ඔබේ කේතය නැවත සකස් කිරීමට උත්සාහ කළ යුතුය.

සරල ක්‍රමයක් නම් මුලින් කියමින් එය ආරම්භ කිරීමයි myVar = None

පසුව:

if myVar is not None:
    # Do something

විචල්‍යයක පැවැත්ම පරීක්ෂා කිරීම සඳහා හොඳම ක්‍රමය උත්සාහය / හැර භාවිතා කිරීමයි. නමුත් ගෝලීය විචල්‍යයන් සැකසීමට / පරීක්ෂා කිරීමට වඩා ඔබ කරන ඕනෑම දෙයක් කිරීමට වඩා හොඳ ක්‍රමයක් තිබේ.

උදාහරණයක් ලෙස, ඔබට පළමු වරට මොඩියුල මට්ටමේ විචල්‍යයක් ආරම්භ කිරීමට අවශ්‍ය නම්, ඔබ යම් ශ්‍රිතයක් අමතන විට, ඔබට මෙවැනි කේතයක් ලබා ගැනීම වඩා හොඳය:

my_variable = None

def InitMyVariable():
  global my_variable
  if my_variable is None:
    my_variable = ...

වස්තු / මොඩියුල සඳහා, ඔබට ද හැකිය

'var' in dir(obj)

උදාහරණයක් වශයෙන්,

>>> class Something(object):
...     pass
...
>>> c = Something()
>>> c.a = 1
>>> 'a' in dir(c)
True
>>> 'b' in dir(c)
False

පරිශීලක 97370 ගේ පිළිතුරට සමාන ශ්‍රිතයක් තුළ පරීක්ෂණය භාවිතා කිරීමට ඇතැයි මම සිතමි . මම එම පිළිතුරට කැමති නැත, මන්ද එය ගෝලීය නාම අවකාශය දූෂණය කරයි. එය නිවැරදි කිරීමට එක් ක්‍රමයක් නම් ඒ වෙනුවට පන්තියක් භාවිතා කිරීමයි:

class InitMyVariable(object):
  my_variable = None

def __call__(self):
  if self.my_variable is None:
   self.my_variable = ...

මම මෙය කැමති නැත, මන්ද එය කේතය සංකීර්ණ කර ප්‍රශ්න වැනි ප්‍රශ්න විවෘත කරන බැවින් මෙය සිංගල්ටන් ක්‍රමලේඛ රටාවට තහවුරු කළ යුතුද? වාසනාවකට මෙන්, පයිතන් විසින් යම් කාලයක් සඳහා කාර්යයන් සඳහා ඉඩ ලබා දී ඇති අතර එමඟින් අපට මෙම සරල විසඳුම ලබා දෙයි:

def InitMyVariable():
  if InitMyVariable.my_variable is None:
    InitMyVariable.my_variable = ...
InitMyVariable.my_variable = None

catchexceptපයිතන් හි හැඳින්වේ . ඒ හැර එවැනි සරල අවස්ථා සඳහා එය හොඳයි. මෙම තියෙනවා AttributeErrorවස්තුවක් විශ්ලේෂණයක් ඇති නම්, පරීක්ෂා කිරීමට යොදා ගත හැකි බව.

මෙවැනි තත්වයක් හසුරුවා ගැනීම සඳහා බොහෝ විට හොඳින් ක්‍රියා කරන ක්‍රමයක් නම් විචල්‍යය පවතින්නේ දැයි පැහැදිලිව පරීක්ෂා නොකොට ඉදිරියට ගොස් නාම දෝෂය හැර / නොපවතින විචල්‍යයේ පළමු භාවිතය උත්සාහයෙන් / එතීම:

# Search for entry.
for x in y:
  if x == 3:
    found = x

# Work with found entry.
try:
  print('Found: {0}'.format(found))
except NameError:
  print('Not found')
else:
  # Handle rest of Found case here
  ...

මම අභිරුචි ශ්‍රිතයක් නිර්මාණය කළෙමි.

def exists(var):
     return var in globals()

variable_nameඔබට පරීක්ෂා කිරීමට අවශ්‍ය විචල්‍යය වෙනුවට පහත දැක්වෙන ශ්‍රිතය අමතන්න :

exists("variable_name")

නැවත පැමිණේ TrueහෝFalse

කෙටි ප්‍රභේදය:

my_var = some_value if 'my_var' not in globals() else my_var: