Làm thế nào để kiểm tra xem một phương thức có tồn tại trong Python hay không?

Trong hàm __getattr__(), nếu không tìm thấy biến được tham chiếu thì nó sẽ báo lỗi. Làm cách nào để kiểm tra xem một biến hoặc phương thức có tồn tại như một phần của một đối tượng hay không?

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

Làm thế nào về dir()chức năng trước đây getattr()?

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

Yêu cầu sự tha thứ sẽ dễ dàng hơn là xin phép.

Đừng kiểm tra xem có phương pháp nào không. Đừng lãng phí một dòng mã cho việc "kiểm tra"

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

Kiểm tra xem lớp có phương thức như vậy không?

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

hoặc là

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

Bạn có thể sử dụng self.__class__thay vìDynamo

Bạn có thể thử sử dụng mô-đun 'kiểm tra':

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

is_method(dyn, 'mymethod')

Tôi sử dụng chức năng tiện ích dưới đây. Nó hoạt động trên lambda, các phương thức lớp cũng như các phương thức thể hiện.

Phương pháp Tiện ích

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

Ví dụ sử dụng

Hãy xác định lớp thử nghiệm

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

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

Bây giờ bạn có thể thử,

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

Làm thế nào về việc tìm kiếm nó trong dyn.__dict__?

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

Có thể như thế này, giả sử tất cả các phương thức đều có thể gọi được

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

Nếu phương thức của bạn nằm ngoài một lớp và bạn không muốn chạy nó và đưa ra một ngoại lệ nếu nó không tồn tại:

'mymethod' in globals()

Tôi nghĩ bạn nên nhìn vào inspectgói. Nó cho phép bạn 'bọc' một số thứ. Khi bạn sử dụng dirphương thức, nó cũng liệt kê các phương thức được tích hợp sẵn, các phương thức kế thừa và tất cả các thuộc tính khác làm cho xung đột có thể xảy ra, ví dụ:

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)

Mảng bạn nhận được dir(Two)chứa cả f_onevà f_twovà rất nhiều thứ được tích hợp sẵn. Với inspectbạn có thể làm điều này:

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

Ví dụ này vẫn liệt kê cả hai phương thức trong hai lớp nhưng nếu bạn muốn giới hạn việc kiểm tra chỉ hoạt động trong một lớp cụ thể thì cần phải làm việc nhiều hơn một chút, nhưng hoàn toàn có thể.