具有__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

在Python中，可调用对象是一个类型具有__call__方法的对象:

>>> class Foo:
...  pass
... 
>>> class Bar(object):
...  pass
... 
>>> type(Foo).__call__(Foo)
<__main__.Foo instance at 0x711440>
>>> type(Bar).__call__(Bar)
<__main__.Bar object at 0x712110>
>>> def foo(bar):
...  return bar
... 
>>> type(foo).__call__(foo, 42)
42

就这么简单:)

这当然可以重载:

>>> class Foo(object):
...  def __call__(self):
...   return 42
... 
>>> f = Foo()
>>> f()
42

Callable是一个具有__call__方法的对象。这意味着你可以伪造可调用的函数，或者做一些简单的事情，比如Partial Function Application，你可以取一个函数，添加一些增强它的东西，或者填充一些参数，返回一些可以依次调用的东西(在函数编程圈中称为curiling)。

某些排版错误会使解释器试图调用一些您不打算调用的东西，例如字符串。这可能会在解释器试图执行不可调用的应用程序时产生错误。你可以在python解释器中看到这种情况，方法是执行下面的脚本。

[nigel@k9 ~]$ python
Python 2.5 (r25:51908, Nov  6 2007, 15:55:44) 
[GCC 4.1.2 20070925 (Red Hat 4.1.2-27)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 'aaa'()    # <== Here we attempt to call a string.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object is not callable
>>> 

Callable是带有方法的“内置函数或方法”的类型或类 调用

>>> type(callable)
<class 'builtin_function_or_method'>
>>>

例子: Print是一个可调用对象。使用内置函数调用 当你调用print函数时，Python创建一个print类型的对象，并调用它的方法调用，如果有参数，则传递参数。

>>> type(print)
<class 'builtin_function_or_method'>
>>> print.__call__(10)
10
>>> print(10)
10
>>>

__call__使任何对象都可以作为函数调用。

这个例子将输出8:

class Adder(object):
  def __init__(self, val):
    self.val = val

  def __call__(self, val):
    return self.val + val

func = Adder(5)
print func(3)

很简单，“可调用对象”是可以像方法一样调用的对象。内置函数“callable()”将告诉您某些东西是否看起来是可调用的，就像检查call属性一样。函数和类一样都是可调用的，类实例也是可调用的。看这里和这里。