web-dev-qa-db-fra.com

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

Dans la fonction __getattr__(), si une variable référée n’est pas trouvée, une erreur est générée. Comment puis-je vérifier si une variable ou une méthode existe dans 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
pythonmethods
54
Rajeev

Que diriez-vous de dir() fonction avant getattr()?

>>> "mymethod" in dir(dyn)
True
70
Michał Šrajer

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

Ne vérifiez pas si une méthode existe. Ne perdez pas une seule ligne de code en "vérifiant"

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

Vérifiez si la classe a 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

79
seriyPS

Vous pouvez essayer d'utiliser le module 'inspecter':

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

is_method(dyn, 'mymethod')
6
vint83

Peut-être comme ça, en supposant que toute méthode est appelable

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

Pourquoi ne pas chercher dans dyn.__dict__?

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

J'utilise ci-dessous la fonction utilitaire. Cela fonctionne sur les méthodes de classe lambda, ainsi que 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

Maintenant tu peux 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
0
Shital Shah