博客链接：http://inarrater.com/2016/07/09/pythonadvance4/

我们继续来看那些Callable的Python类型。

5. Class method和Static method

这部分其实不能算Python的进阶内容了，可以说是基础内容。在初学Python的时候我就有过一些疑惑，@classmethod和@staticmethod修饰的函数看上去似乎没有什么区别，都是通过类来调用（当然对象也可以）。本小节内容稍微看一下两者的区别，首先是class method，因为比较简单，直接看代码例子和结果吧。

class A(object):
    @classmethod
    def foo(self):
        pass
        
    def bar(self):
        pass
        
a = A()
print A.foo
print a.foo

m1 = A.foo
m2 = a.foo
print 1, id(m1)
print 2, id(m2)

运行结果如下：

<bound method type.foo of <class '__main__.A'>>
<bound method type.foo of <class '__main__.A'>>
1 37346800
2 37266616

可以看到，我们把A.foo打印处理，是一个bound method对象，通过对象a来访问也是一样的，我们学着bound method的方式来分析看，m1和m2的id是不同，在理解了第4小节的内容之后这里就比较容易理解了。

思考： Class method是绑定了什么东西的bound method呢？

通过查看bound method对象的im_self属性就可以看到它所绑定的对象了，我们添加一些代码来分析。

print m1.im_self
print m2.im_self

m3 = a.bar
print m3.im_self

<class '__main__.A'>
<class '__main__.A'>
<__main__.A object at 0x02440030>

结论： Class Method是绑定了类对象的bound method。

需要额外注意的是，def foo(self):这里对于class method的定义是不好的，具有一定的误导性，这里的self不再是类的实例对象了，而是一个class对象，因此通常写成def foo(cls):或者def foo(klass)更清晰。

Static method是否也是bound method呢？我们直接来看分析代码。

class A(object):
    @staticmethod
    def foo(self):
        pass
        
a = A()
print A.foo
print a.foo

m1 = A.foo
m2 = a.foo
print 1, id(m1)
print 2, id(m2)

输出结果为：

<function foo at 0x023FA4B0>
<function foo at 0x023FA4B0>
1 37725360
2 37725360

结论： Static method就是在类的命名空间中的一个普通函数。

6. Functors和Operators

在C++中，重写了()操作符的类，它们实例化的对象就是一个functor，在Python中，重写了__call__方法的类的实例对象是一个functor。这里具体的内容就不再详述了，属于Python中比较基本的内容。
类似的，关于操作符（Operators），在Python中也是重载一些对应函数，比如+就是重载__add__函数。这里需要说的是一个性能问题，我们来看一个例子：

import timeit

def foo(a, b):
    return a + b
    
def bar(a, b):
    return a.__add__(b)


n = 5000000
print timeit.Timer('foo(1, 2)', 'from __main__ import foo').timeit(n)
print timeit.Timer('bar(1, 2)', 'from __main__ import bar').timeit(n)

print timeit.Timer('foo("1", "2")', 'from __main__ import foo').timeit(n)
print timeit.Timer('bar("1", "2")', 'from __main__ import bar').timeit(n)

输出结果如下：

0.689781276848
1.40617516723
0.806692302726
1.4724794197

原理上，+的操作符是调用__add__方法来进行处理，那为什么直接调用__add__方法反而会慢呢？我们使用dis模块来看一下Python代码翻译成Python虚拟机的指令的区别。

import dis
dis.dis(foo)
print '-' * 50
dis.dis(bar)

输出结果如下：

  4           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 BINARY_ADD          
              7 RETURN_VALUE        
--------------------------------------------------
  7           0 LOAD_FAST                0 (a)
              3 LOAD_ATTR                0 (__add__)
              6 LOAD_FAST                1 (b)
              9 CALL_FUNCTION            1
             12 RETURN_VALUE        

dis模块的dis方法可以打印出传入函数的虚拟机指令，可以看到foo函数使用+，并没有调用__add__方法，而是用了一个BINARY_ADD指令来直接进行加法。这就是它比直接调用__add__方法快的原因。

总结：对于Python的内建类型，操作符比直接调用对应的函数要好，Python可能会使用对应的二进制操作进行优化。

思考: 对于用户自定义的类型呢，效率哪个更高？

我们来看例子的代码：

import timeit

def foo(a, b):
    return a + b
    
def bar(a, b):
    return a.__add__(b)
    
class Number(object):
    def __init__(self, v):
        self._value = v

    def __add__(self, v):
        return self._value + v._value
        
n1 = Number(1)
n2 = Number(2)
print n1 + n2

n = 1000000
print timeit.Timer('foo(Number(1), Number(2))', 'from __main__ import foo, Number').timeit(n)
print timeit.Timer('bar(Number(1), Number(2))', 'from __main__ import bar, Number').timeit(n)

输出结果：

3
1.34897905469
1.26909055996

看上去，直接调用__add__方法反而更快一些，但是差别整体不大。这是因为+操作符会进行优化尝试，需要额外的时间消耗。不过呢，这点时间差别比较小，而且直接使用类似__add__的方法调用对于代码的可读性维护性会带来一定的困扰，因此大部分情况下，直接使用操作符会更好。

2016年7月8日晚于杭州网易大厦