博客链接：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日晚于杭州网易大厦
