为什么显式调用魔术方法要比“ sugared”语法慢？

Question

当我遇到一组奇怪的计时结果时，我正在搞乱一个小型的自定义数据对象，该对象必须是可散列的，可比的和快速的。该对象的某些比较（和哈希方法）只是委托给一个属性，所以我使用的是：

def __hash__(self):
    return self.foo.__hash__()

但是，经过测试，我发现它hash(self.foo)的速度明显更快。出于好奇，我测试__eq__，__ne__和其他神奇的比较，才发现
所有的 人跑得更快，如果我用含糖的形式（==，!=，<等）。为什么是这样？我以为加糖形式必须在幕后进行相同的函数调用，但也许不是这样吗？

时间结果

设置：控制所有比较的instance属性周围的薄包装器。

Python 3.3.4 (v3.3.4:7ff62415e426, Feb 10 2014, 18:13:51) [MSC v.1600 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> 
>>> sugar_setup = '''\
... import datetime
... class Thin(object):
...     def __init__(self, f):
...             self._foo = f
...     def __hash__(self):
...             return hash(self._foo)
...     def __eq__(self, other):
...             return self._foo == other._foo
...     def __ne__(self, other):
...             return self._foo != other._foo
...     def __lt__(self, other):
...             return self._foo < other._foo
...     def __gt__(self, other):
...             return self._foo > other._foo
... '''
>>> explicit_setup = '''\
... import datetime
... class Thin(object):
...     def __init__(self, f):
...             self._foo = f
...     def __hash__(self):
...             return self._foo.__hash__()
...     def __eq__(self, other):
...             return self._foo.__eq__(other._foo)
...     def __ne__(self, other):
...             return self._foo.__ne__(other._foo)
...     def __lt__(self, other):
...             return self._foo.__lt__(other._foo)
...     def __gt__(self, other):
...             return self._foo.__gt__(other._foo)
... '''

测验

我的自定义对象包装了datetime，所以这就是我使用的内容，但不应有任何区别。是的，我正在测试中创建日期时间，因此那里显然存在一些相关的开销，但是从一项测试到另一项测试的开销是恒定的，因此不应有所作为。为了简洁起见，我省略了__ne__和__gt__测试，但是结果基本上与此处显示的相同。

>>> test_hash = '''\
... for i in range(1, 1000):
...     hash(Thin(datetime.datetime.fromordinal(i)))
... '''
>>> test_eq = '''\
... for i in range(1, 1000):
...     a = Thin(datetime.datetime.fromordinal(i))
...     b = Thin(datetime.datetime.fromordinal(i+1))
...     a == a # True
...     a == b # False
... '''
>>> test_lt = '''\
... for i in range(1, 1000):
...     a = Thin(datetime.datetime.fromordinal(i))
...     b = Thin(datetime.datetime.fromordinal(i+1))
...     a < b # True
...     b < a # False
... '''

结果

>>> min(timeit.repeat(test_hash, explicit_setup, number=1000, repeat=20))
1.0805227295846862
>>> min(timeit.repeat(test_hash, sugar_setup, number=1000, repeat=20))
1.0135617737162192
>>> min(timeit.repeat(test_eq, explicit_setup, number=1000, repeat=20))
2.349765956168767
>>> min(timeit.repeat(test_eq, sugar_setup, number=1000, repeat=20))
2.1486044757355103
>>> min(timeit.repeat(test_lt, explicit_setup, number=500, repeat=20))
1.156479287717275
>>> min(timeit.repeat(test_lt, sugar_setup, number=500, repeat=20))
1.0673696685109917

• 杂凑：
  • 明确的： 1.0805227295846862
  • 加糖的： 1.0135617737162192
• 等于：
  • 明确的： 2.349765956168767
  • 加糖的： 2.1486044757355103
• 少于：
  • 明确的： 1.156479287717275
  • 加糖的： 1.0673696685109917

Answer 1

两个原因：

• API查找仅查看 类型 。他们不看self.foo.__hash__，他们寻找type(self.foo).__hash__。少看一本字典。

• C插槽查找比纯Python属性查找（将使用__getattribute__）快。而是完全在C中绕过来查找方法对象（包括描述符绑定）__getattribute__。

因此，您必须在type(self._foo).__hash__本地缓存查找，即使这样，调用也不会像从C代码中那样快。如果速度非常宝贵，请坚持使用标准库功能。

另一个原因，以避免直接调用魔术方法是比较运营商做 更多的 不仅仅是通话一个魔术方法; 这些方法也反映了版本；对于x < y，如果x.__lt__未定义或x.__lt__(y)返回NotImplemented单例，y.__gt__(x)则也请参考。