Comment vérifier si une variable existe?

Je veux vérifier si une variable existe. Maintenant, je fais quelque chose comme ça:

try:
   myVar
except NameError:
   # Do something.

Existe-t-il d'autres moyens sans exception?

Pour vérifier l'existence d'une variable locale:

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

Pour vérifier l'existence d'une variable globale:

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

Pour vérifier si un objet a un attribut:

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

L' utilisation de variables qui n'ont pas encore été définies ou définies (implicitement ou explicitement) est presque toujours une mauvaise chose dans n'importe quelle langue, car elle indique souvent que la logique du programme n'a pas été bien réfléchie et est susceptible de résulter dans un comportement imprévisible.

Si vous devez le faire en Python, l'astuce suivante, similaire à la vôtre, garantira qu'une variable a une certaine valeur avant utilisation:

try:
    myVar
except NameError:
    myVar = None

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

Cependant, je ne suis toujours pas convaincu que c'est une bonne idée - à mon avis, vous devriez essayer de refactoriser votre code afin que cette situation ne se produise pas.

Un moyen simple est de l'initialiser en disant d'abord myVar = None

Plus tard:

if myVar is not None:
    # Do something

L'utilisation de try / except est la meilleure façon de tester l'existence d'une variable. Mais il y a presque certainement une meilleure façon de faire quoi que ce soit que de définir / tester des variables globales.

Par exemple, si vous souhaitez initialiser une variable de niveau module la première fois que vous appelez une fonction, vous feriez mieux de coder quelque chose comme ceci:

my_variable = None

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

pour les objets / modules, vous pouvez également

'var' in dir(obj)

Par exemple,

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

Je suppose que le test va être utilisé dans une fonction, similaire à la réponse de user97370 . Je n'aime pas cette réponse car elle pollue l'espace de noms global. Une façon de résoudre ce problème consiste à utiliser une classe à la place:

class InitMyVariable(object):
  my_variable = None

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

Je n'aime pas cela, car cela complique le code et ouvre des questions telles que, cela devrait-il confirmer le modèle de programmation Singleton? Heureusement, Python a permis aux fonctions d'avoir des attributs pendant un certain temps, ce qui nous donne cette solution simple:

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

catchest appelé excepten Python. à part ça, c'est bien pour des cas aussi simples. Il y a le AttributeErrorqui peut être utilisé pour vérifier si un objet a un attribut.

Un moyen qui fonctionne souvent bien pour gérer ce type de situation consiste à ne pas vérifier explicitement si la variable existe, mais à aller de l'avant et à envelopper la première utilisation de la variable éventuellement non existante dans un try / except NameError:

# 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
  ...

J'ai créé une fonction personnalisée.

def exists(var):
     var_exists = var in locals() or var in globals()
     return var_exists

Ensuite, appelez la fonction comme suit en remplaçant variable_namepar la variable que vous souhaitez vérifier:

exists("variable_name")

Reviendra TrueouFalse