__call__

在Python中，函数其实是一个对象：

>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)

由于 f 可以被调用，所以，f 被称为可调用对象。

所有的函数都是可调用对象。

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法call()。

我们把 Person 类变成一个可调用对象：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print 'My name is %s...' % self.name
        print 'My friend is %s...' % friend

现在可以对 Person 实例直接调用：

>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...

单看 p(‘Tim’) 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。

任务
改进一下前面定义的斐波那契数列：

class Fib(object):
    ???

请加一个__call__方法，让调用更简单：

>>> f = Fib()
>>> print f(10)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

可以把实例对象用类似函数的形式表示，进一步模糊了函数和对象之间的概念

class Fib(object):
    def __init__(self):
        pass
    def __call__(self,num):
        a,b = 0,1;
        self.l=[]

        for i in range (num):
            self.l.append(a)
            a,b= b,a+b
        return self.l
    def __str__(self):
        return str(self.l)
    __rept__=__str__

f = Fib()
print f(10)

转自https://www.cnblogs.com/superxuezhazha/p/5793536.html

函数的使用能够极大的极少代码重复率，提高代码的灵活性。

C++中具有函数这种行为的方式有很多。就函数调用方式而言

func(param1, param2);

这儿使用func作为函数调用名，param1和param2为函数参数。在C++中就func的类型，可能为：

• 普通函数
• 类成员函数
• 类静态函数
• 仿函数

callable可调用对象

对于这种可以被当做函数直接来调用的对象，我们称为可调用的对象，可调用的对象的实现就是在他们内部要实现特殊的__call__()方法。

可调用对象的意义：

• 简化对象下方法的调用，比如说我们有一个对象a，下面有一个func()方法，我们要调用func()方法的时候要使用a.func()来调用。但是如果我们要是把func()方法的内部实现写到我们__call__方法里面的话，那么a这个对象就变成一个可调用的对象，那么我们再次调用的时候就不需要使用a.方法了，而直接a()就可以调用对象下面的方法了。那么这个是一种简化。下面我们来看一下在哪些情况下把一个对象实现成可调用对象：构造函数不算，例如Aborter这个类，他下面只有一个方法，它就直接把它实现成一个可调用对象。另外一种情况就是，对象下面的某个方法使用很多的时候，别的方法都不常用，只有某个方法他使用的很多，那么这种情况下，也可以把某个方法实现成__call__的方式
• 模糊了对象和函数的区别，这种情景不是很好理解，如果说一个对象是可调用对象的话，我们可以直接使用a()的形式调用，这种调用形式几乎和我们函数的调用形式是一样的func()，但是这个意义就在于它可以统一调用的接口，我们来看下面的示例

可调用方法的使用场景

class A():
    def go(self):
        return object()

class B():
    def run(self):
        return object()

def func():
    return object()

def main(callable):
    callable()
    # 我想在main中调用传入的参数，得到一个对象object
    # b.run()
    # a.go()
    # func()
    # ...
    pass

main(A())
main(B())
main(func())

上面的代码可以发现当我们调用main方法的时候，还需要确定传入的对象（例如A(),B()）里面的方法名是什么，这样写很不好，所以我们就可以改写成下面的代码

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

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

def main(callable):
    callable()
    # 我想在main中调用传入的参数，得到一个对象object
    # b.run()
    # a.go()
    # func()
    # ...

main(A())
main(B())

这样就不用区别到底是A类型还是B类型的对象了。