Python 字典 : there a speed difference between matching a numeric key over a word in python?

Question

在包含 50 个项目的 Python 字典中，匹配整数键(2 位数字)查找字符串值与匹配字符串键(5 - 10+ 个字母)查找整数值之间是否存在已知的明显速度差异大量循环(100,000+)？

作为一个小奖励；如果可以的话，在 MYSQL 中执行此类事件与在 Python 中执行此类事件有什么好处吗？

Answer 1

微基准测试语言features 是一个有用的练习，但你必须将它与一粒盐。很难做到以准确且有意义的方式进行基准测试，并且通常人们关心的是整体表现，而不是个人特征性能。

我发现使用“测试工具”可以更轻松地运行以可比较的方式选择不同的替代方案。

对于字典查找，以下是使用 benchmark 的示例来自 PyPI 的模块。100随机运行，设置 N=50 个项目的 dict每个 - int 键和 str 值或相反，然后尝试 try/ except和 get 访问范例。代码如下:

import benchmark
from random import choice, randint
import string

def str_key(length=8, alphabet=string.ascii_letters):
    return ''.join(choice(alphabet) for _ in xrange(length))

def int_key(min=10, max=99):
    return randint(min, max)

class Benchmark_DictLookup(benchmark.Benchmark):

    each = 100 # allows for differing number of runs

    def setUp(self):
        # Only using setUp in order to subclass later
        # Can also specify tearDown, eachSetUp, and eachTearDown
        self.size = 1000000
        self.n = 50
        self.intdict = { int_key():str_key() for _ in xrange(self.n) }
        self.strdict = { str_key():int_key() for _ in xrange(self.n) }
        self.intkeys = [ int_key() for _ in xrange(self.size) ]
        self.strkeys = [ str_key() for _ in xrange(self.size) ]

    def test_int_lookup(self):
        d = self.intdict
        for key in self.intkeys:
            try:
                d[key]
            except KeyError:
                pass

    def test_int_lookup_get(self):
        d = self.intdict
        for key in self.intkeys:
            d.get(key, None)

    def test_str_lookup(self):
        d = self.strdict
        for key in self.strkeys:
            try:
                d[key]
            except KeyError:
                pass

    def test_str_lookup_get(self):
        d = self.strdict
        for key in self.strkeys:
            d.get(key, None)


class Benchmark_Hashing(benchmark.Benchmark):

    each = 100 # allows for differing number of runs

    def setUp(self):
        # Only using setUp in order to subclass later
        # Can also specify tearDown, eachSetUp, and eachTearDown
        self.size = 100000
        self.intkeys = [ int_key() for _ in xrange(self.size) ]
        self.strkeys = [ str_key() for _ in xrange(self.size) ]


    def test_int_hash(self):
        for key in self.intkeys:
            id(key)

    def test_str_hash(self):
        for key in self.strkeys:
            id(key)


if __name__ == '__main__':
    benchmark.main(format="markdown", numberFormat="%.4g")

结果:

$ python dictspeed.py

Benchmark Report
================

Benchmark DictLookup
--------------------

          name | rank | runs |   mean |      sd | timesBaseline
---------------|------|------|--------|---------|--------------
int lookup get |    1 |  100 | 0.1756 | 0.01619 |           1.0
str lookup get |    2 |  100 | 0.1859 | 0.01477 | 1.05832996073
    int lookup |    3 |  100 | 0.5236 | 0.03935 | 2.98143047487
    str lookup |    4 |  100 | 0.8168 | 0.04961 | 4.65108861267

Benchmark Hashing
-----------------

    name | rank | runs |     mean |        sd | timesBaseline
---------|------|------|----------|-----------|--------------
int hash |    1 |  100 | 0.008738 |  0.000489 |           1.0
str hash |    2 |  100 | 0.008925 | 0.0002952 | 1.02137781609

Each of the above 600 runs were run in random, non-consecutive order by
`benchmark` v0.1.5 (http://jspi.es/benchmark) with Python 2.7.5
Darwin-13.4.0-x86_64 on 2014-10-28 19:23:01.

结论:字典中的字符串查找并不比整数查找昂贵多少。 但是所谓的Pythonic“请求宽恕而不是许可”范例比简单地使用get方法调用花费的时间长长。此外，散列一个字符串(至少大小为 8)并不比散列一个整数昂贵多少。

但是如果您在不同的实现上运行，例如 PyPy，事情会变得更加有趣:

$ pypy dictspeed.py

Benchmark Report
================

Benchmark DictLookup
--------------------

          name | rank | runs |    mean |        sd | timesBaseline
---------------|------|------|---------|-----------|--------------
int lookup get |    1 |  100 | 0.01538 | 0.0004682 |           1.0
str lookup get |    2 |  100 | 0.01993 |  0.001117 |   1.295460397
    str lookup |    3 |  100 |  0.0203 |  0.001566 | 1.31997704025
    int lookup |    4 |  100 | 0.02316 |  0.001056 | 1.50543635375

Benchmark Hashing
-----------------

    name | rank | runs |      mean |        sd | timesBaseline
---------|------|------|-----------|-----------|--------------
str hash |    1 |  100 | 0.0005657 | 0.0001609 |           1.0
int hash |    2 |  100 |  0.006066 | 0.0005283 |  10.724346492

Each of the above 600 runs were run in random, non-consecutive order by
`benchmark` v0.1.5 (http://jspi.es/benchmark) with Python 2.7.8
Darwin-13.4.0-x86_64 on 2014-10-28 19:23:57.

在最好的情况下，PyPy 的速度大约快 11 倍，但比率有很大不同。 PyPy 不会像 CPython 那样承受巨大的异常处理成本。而且，对整数进行哈希处理的速度比对字符串进行哈希处理的速度慢 10 倍。想要得到意想不到的结果怎么样？

我本来想尝试 Python 3，但是 benchmark 在那里安装得不好。我还尝试将字符串长度增加到 50。它并没有显着改变结果、比率或结论。

总体而言，散列和查找速度非常快，除非您必须执行数百万或数十亿次，或者有非常长的 key ，或者其他一些不寻常的情况，否则开发人员通常不需要担心它们的微观性能。