Python进阶(四)
博客链接: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日晚于杭州网易大厦