Comment vérifier si une méthode existe en Python ?

Question

Dans la fonction __getattr__() Si une variable référencée n'est pas trouvée, il y a une erreur. Comment puis-je vérifier si une variable ou une méthode existe en tant que partie d'un objet ?

import string
import logging

class Dynamo:
 def __init__(self,x):
  print "In Init def"
  self.x=x
 def __repr__(self):
  print self.x
 def __str__(self):
  print self.x
 def __int__(self):
  print "In Init def"
 def __getattr__(self, key):
    print "In getattr"
    if key == 'color':
        return 'PapayaWhip'
    else:
        raise AttributeError

dyn = Dynamo('1')
print dyn.color
dyn.color = 'LemonChiffon'
print dyn.color
dyn.__int__()
dyn.mymethod() //How to check whether this exist or not

Answer 1

Vérifier si la classe possède une telle méthode ?

hasattr(Dynamo, key) and callable(getattr(Dynamo, key))

ou

hasattr(Dynamo, 'mymethod') and callable(getattr(Dynamo, 'mymethod'))

Vous pouvez utiliser self.__class__ au lieu de Dynamo

Answer 2

Il est plus facile de demander pardon que de demander la permission.

Ne pas vérifier si une méthode existe. Ne gaspillez pas une seule ligne de code pour "vérifier"

try:
    dyn.mymethod() # How to check whether this exists or not
    # Method exists and was used.  
except AttributeError:
    # Method does not exist; What now?

Answer 3

Pourquoi pas dir() fonction avant getattr() ?

>>> "mymethod" in dir(dyn)
True

Answer 4

J'utilise la fonction d'utilité ci-dessous. Elle fonctionne sur les méthodes lambda, les méthodes de classe et les méthodes d'instance.

Méthode utilitaire

def has_method(o, name):
    return callable(getattr(o, name, None))

Exemple d'utilisation

Définissons la classe de test

class MyTest:
  b = 'hello'
  f = lambda x: x

  @classmethod
  def fs():
    pass
  def fi(self):
    pass

Vous pouvez maintenant essayer,

>>> a = MyTest()                                                    
>>> has_method(a, 'b')                                         
False                                                          
>>> has_method(a, 'f')                                         
True                                                           
>>> has_method(a, 'fs')                                        
True                                                           
>>> has_method(a, 'fi')                                        
True                                                           
>>> has_method(a, 'not_exist')                                       
False

Answer 5

Vous pouvez essayer d'utiliser le module "inspect" :

import inspect
def is_method(obj, name):
    return hasattr(obj, name) and inspect.ismethod(getattr(obj, name))

is_method(dyn, 'mymethod')