可调用对象实现了__call__特殊方法，因此任何具有这种方法的对象都是可调用的。

你可以在它后面加上“(args)”，并期望它能工作。可调用对象通常是一个方法或类。方法被调用，类被实例化。

来自Python的源代码object.c:

/* Test whether an object can be called */

int
PyCallable_Check(PyObject *x)
{
    if (x == NULL)
        return 0;
    if (PyInstance_Check(x)) {
        PyObject *call = PyObject_GetAttrString(x, "__call__");
        if (call == NULL) {
            PyErr_Clear();
            return 0;
        }
        /* Could test recursively but don't, for fear of endless
           recursion if some joker sets self.__call__ = self */
        Py_DECREF(call);
        return 1;
    }
    else {
        return x->ob_type->tp_call != NULL;
    }
}

它说:

如果一个对象是某个类的实例，那么如果它具有__call__属性，则它是可调用的。 否则对象x可调用iff x->ob_type->tp_call != NULL

tp_call字段说明:

ternaryfunc tp_call可选 指向实现的函数的指针 调用对象。这应该是 如果对象不可调用，则为NULL。 签名与for相同 PyObject_Call()。这个字段是 由子类型继承。

你总是可以使用内置的callable函数来确定给定的对象是否可调用;或者更好的方法是稍后调用它并捕获TypeError。callable在Python 3.0和3.1中被移除，请使用callable = lambda o: hasattr(o， '__call__')或isinstance(o, collections.Callable)。

示例:一个简单的缓存实现:

class Cached:
    def __init__(self, function):
        self.function = function
        self.cache = {}

    def __call__(self, *args):
        try: return self.cache[args]
        except KeyError:
            ret = self.cache[args] = self.function(*args)
            return ret    

用法:

@Cached
def ack(x, y):
    return ack(x-1, ack(x, y-1)) if x*y else (x + y + 1) 

例子来自标准库，文件site.py，内置exit()和quit()函数的定义:

class Quitter(object):
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return 'Use %s() or %s to exit' % (self.name, eof)
    def __call__(self, code=None):
        # Shells like IDLE catch the SystemExit, but listen when their
        # stdin wrapper is closed.
        try:
            sys.stdin.close()
        except:
            pass
        raise SystemExit(code)
__builtin__.quit = Quitter('quit')
__builtin__.exit = Quitter('exit')

可调用对象是允许您使用圆括号()并最终传递一些参数的对象，就像函数一样。

每次定义函数时，python都会创建一个可调用对象。 例如，你可以用这些方式定义函数func(它们是一样的):

class a(object):
    def __call__(self, *args):
        print 'Hello'

func = a()

# or ... 
def func(*args):
    print 'Hello'

你可以使用这个方法而不是doit或run方法，我认为obj()比obj.doit()更清楚。

具有__call__()的类、函数、方法和对象都是可调用的。

你可以用callable()检查是否可调用，如果可调用返回True，如果不可调用返回False，如下所示:

class Class1:
    def __call__(self):
        print("__call__")

class Class2:
    pass

def func():
    pass

print(callable(Class1))   # Class1
print(callable(Class2))   # Class2

print(callable(Class1())) # Class1 object
print(callable(Class2())) # Class2 object

print(callable(func))     # func

然后，只有没有__call__()的Class2对象是不可调用的，返回False，如下所示:

True  # Class1
True  # Class2
True  # Class1 object
False # Class2 object
True  # func

此外，下面所有的都是不可调用的，返回False，如下所示:

print(callable("Hello"))  # "str" type
print(callable(100))      # "int" type
print(callable(100.23))   # "float" type
print(callable(100 + 2j)) # "complex" type
print(callable(True))     # "bool" type
print(callable(None))     # "NoneType"
print(callable([]))       # "list" type
print(callable(()))       # "tuple" type
print(callable({}))       # "dict" type
print(callable({""}))     # "set" type

输出:

False # "str" type
False # "int" type
False # "float" type
False # "complex" type
False # "bool" type
False # "NoneType"
False # "list" type
False # "tuple" type
False # "dict" type
False # "set" type

可调用对象是任何可以调用的对象。

内置可调用对象(objects.c中的PyCallable_Check)检查参数是否为:

类的实例，具有__call__方法或 具有非空tp_call (c struct)成员的类型，该成员指示可调用性(例如在函数、方法等中)。

名为__call__的方法是(根据文档)

当实例作为函数被“调用”时调用

例子

class Foo:
  def __call__(self):
    print 'called'

foo_instance = Foo()
foo_instance() #this is calling the __call__ method