Wie überprüfe ich, ob eine Methode in Python vorhanden ist?

__getattr__()Wenn in der Funktion eine referenzierte Variable nicht gefunden wird, wird ein Fehler ausgegeben. Wie kann ich überprüfen, ob eine Variable oder Methode als Teil eines Objekts vorhanden ist?

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

Wie wäre es dir()vorher mit Funktion getattr()?

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

Es ist einfacher, um Vergebung zu bitten, als um Erlaubnis.

Überprüfen Sie nicht, ob eine Methode vorhanden ist. Verschwenden Sie keine einzige Codezeile beim "Überprüfen"

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

Überprüfen Sie, ob die Klasse eine solche Methode hat?

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

oder

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

Sie können self.__class__anstelle von verwendenDynamo

Sie können versuchen, das Inspektionsmodul zu verwenden:

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

is_method(dyn, 'mymethod')

Ich benutze unten Dienstprogrammfunktion. Es funktioniert mit Lambda, Klassenmethoden sowie Instanzmethoden.

Dienstprogrammmethode

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

Beispiel Verwendung

Definieren wir die Testklasse

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

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

Jetzt können Sie versuchen,

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

Wie wäre es damit nachzuschlagen dyn.__dict__?

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

Vielleicht so, vorausgesetzt, alle Methoden sind aufrufbar

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

Wenn sich Ihre Methode außerhalb einer Klasse befindet und Sie sie nicht ausführen und eine Ausnahme auslösen möchten, wenn sie nicht vorhanden ist:

'mymethod' in globals()

Ich denke, Sie sollten sich das inspectPaket ansehen . Es ermöglicht Ihnen, einige der Dinge zu "verpacken". Wenn Sie die dirMethode verwenden, werden auch integrierte Methoden, geerbte Methoden und alle anderen Attribute aufgelistet, die Kollisionen ermöglichen, z.

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)

Das Array Sie erhalten dir(Two)enthält sowohl f_oneund f_twound eine Menge in Sachen gebaut. Mit inspectkönnen Sie dies tun:

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

In diesen Beispielen werden weiterhin beide Methoden in den beiden Klassen aufgelistet. Wenn Sie jedoch die Inspektion auf die Funktion nur in einer bestimmten Klasse beschränken möchten, ist etwas mehr Arbeit erforderlich, dies ist jedoch absolut möglich.