¿Cómo comprobar si existe un método en Python?

En la función __getattr__(), si no se encuentra una variable referida, da un error. ¿Cómo puedo verificar si una variable o método existe como parte de un objeto?

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

¿Qué tal dir()funcionar antes getattr()?

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

Es más fácil pedir perdón que pedir permiso.

No compruebe si existe un método. No pierda ni una sola línea de código en "comprobar"

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

¿Compruebe si la clase tiene ese método?

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

o

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

Puedes usar en self.__class__lugar deDynamo

Puede intentar usar el módulo 'inspeccionar':

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

is_method(dyn, 'mymethod')

Utilizo la siguiente función de utilidad. Funciona con lambda, métodos de clase y métodos de instancia.

Método de utilidad

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

Ejemplo de uso

Definamos la clase de prueba

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

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

Ahora puedes intentarlo

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

¿Qué tal buscarlo en dyn.__dict__?

try:
    method = dyn.__dict__['mymethod']
except KeyError:
    print "mymethod not in dyn"

Tal vez así, asumiendo que todos los métodos son invocables

app = App(root) # some object call app 
att = dir(app) #get attr of the object att  #['doc', 'init', 'module', 'button', 'hi_there', 'say_hi']

for i in att: 
    if callable(getattr(app, i)): 
        print 'callable:', i 
    else: 
        print 'not callable:', i

Si su método está fuera de una clase y no desea ejecutarlo y generar una excepción si no existe:

'mymethod' in globals()

Creo que deberías mirar el inspectpaquete. Te permite 'envolver' algunas de las cosas. Cuando usa el dirmétodo, también enumera los métodos integrados, los métodos heredados y todos los demás atributos que hacen posibles las colisiones, por ejemplo:

class One(object):

    def f_one(self):
        return 'class one'

class Two(One):

    def f_two(self):
        return 'class two'

if __name__ == '__main__':
    print dir(Two)

La matriz de la que obtiene dir(Two)contiene f_oney f_twoy muchas cosas integradas. Con inspectusted puede hacer esto:

class One(object):

    def f_one(self):
        return 'class one'

class Two(One):

    def f_two(self):
        return 'class two'

if __name__ == '__main__':
    import inspect

    def testForFunc(func_name):
        ## Only list attributes that are methods
        for name, _ in inspect.getmembers(Two, inspect.ismethod):
            if name == func_name:
                return True
        return False

    print testForFunc('f_two')

Estos ejemplos aún enumeran ambos métodos en las dos clases, pero si desea limitar la inspección para que solo funcione en una clase específica, requiere un poco más de trabajo, pero es absolutamente posible.