python - 将迭代器传递给 any 以提高执行速度，为什么？

Question

这里总结了问题。是的，我知道这些答案中的一些 ;)，我可以对其他人挥挥手，但我真的很想在这里了解细节。

1. 这是个好主意吗？ (这个不在下面)
2. 我想知道这张 map 是否真的提高了速度？为什么？
3. 为什么世界上会传递迭代器给any让我的代码更快？
4. 为什么我的 Counter 对象可以工作，而我的 print_true 函数却惨遭失败？
5. 有没有等价于itertools.imap的这只会一遍又一遍地调用一个函数，并且可以选择一定次数？
6. 我的胡萝卜呢？!？

---

我刚看了PyCon 2011: How Dropbox Did It and How Python Helped (诚​​然，我跳过了大部分部分)，但真正有趣的部分终于在 22:23 左右开始。

演讲者提倡在 C 中创建内部循环，并且“运行一次”的东西不需要太多优化(有道理)……然后他继续说……释义:

Pass a composition of iterators to any for massive speed improvements.

这是代码(希望它是相同的):

import itertools, hashlib, time   
_md5 = hashlib.md5()  
def run():
    for i in itertools.repeat("foo", 10000000):
        _md5.update(i)
a = time.time();  run(); time.time() - a  
Out[118]: 9.44077205657959

_md5 = hashlib.md5() 
def run():
    any(itertools.imap(_md5.update, itertools.repeat("foo", 10000000)))    
a = time.time();  run(); time.time() - a
Out[121]: 6.547091007232666

嗯，看来要获得更大的速度提升，我只能买一台更快的电脑! (从他的幻灯片来看。)

然后，他做了一堆挥手 Action ，但实际上并未详细说明原因。

我已经从 pythonic way to do something N times without an index variable? 的答案中了解了迭代器感谢 Alex Martelli。

然后我想，我想知道 map 是否真的增加了速度提升？我最后的想法是 WTF？？？传递给 any ？真的？？？这肯定是不对的，因为文档定义了 any作为:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

为什么将迭代器传递给 any 会使我的代码更快？

然后我使用以下(在许多其他测试中)对其进行了测试，但这就是我的原因:

def print_true(x):
    print 'True'
    return 'Awesome'

def test_for_loop_over_iter_map_over_iter_repeat():
    for result in itertools.imap(print_true, itertools.repeat("foo", 5)):
        pass

def run_any_over_iter_map_over_iter_repeat():
    any(itertools.imap(print_true, itertools.repeat("foo", 5)))

And the runs:

    In [67]: test_for_loop_over_iter_map_over_iter_repeat()
    True
    True
    True
    True
    True

    In [74]: run_any_over_iter_map_over_iter_repeat()
    True

耻辱。我宣布这个人充满了它。 异端!但是，我静下心来继续测试。 如果这是真的，Dropbox 到底怎么可能工作!？!？

经过进一步测试，它确实起作用了……我最初只使用了一个简单的计数器对象，在这两种情况下它一直计数到 10000000。

所以问题是为什么我的 Counter 对象可以工作而我的 print_true 函数却惨遭失败？

class Counter(object):
    count = 0
    def count_one(self, none):
        self.count += 1

def run_any_counter():
    counter = Counter()
    any(itertools.imap(counter.count_one, itertools.repeat("foo", 10000000)))
    print counter.count

def run_for_counter():
    counter = Counter()
    for result in itertools.imap(counter.count_one, itertools.repeat("foo", 10000000)):
        pass
    print counter.count

输出:

%time run_for_counter()
10000000
CPU times: user 5.54 s, sys: 0.03 s, total: 5.57 s
Wall time: 5.68 s

%time run_any_counter()
10000000
CPU times: user 5.28 s, sys: 0.02 s, total: 5.30 s
Wall time: 5.40 s

甚至在删除不需要的参数并为我的 Counter 对象编写最合理的代码之后，一个更大的 WTF 仍然比 any-map 版本慢。我的胡萝卜在哪里？!？:

class CounterNoArg(object):
    count = 0
    def count_one(self):
        self.count += 1

def straight_count():
    counter = CounterNoArg()
    for _ in itertools.repeat(None, 10000000):
        counter.count_one()
    print counter.count

输出:

In [111]: %time straight_count()
10000000
CPU times: user 5.44 s, sys: 0.02 s, total: 5.46 s
Wall time: 5.60 s

我问是因为我认为 Pythonistas 或 Pythoneers 需要胡萝卜所以我们不会开始将东西传递给 any或 all为了提高性能，还是已经存在？可能相当于 itertools.imap这只会一遍又一遍地调用一个函数，并且可以选择一定次数。

我管理过的最好的是(使用列表理解给出有趣的结果):

def super_run():
    counter = CounterNoArg()
    for _ in (call() for call in itertools.repeat(counter.count_one, 10000000)):
        pass
    print counter.count

def super_counter_run():
    counter = CounterNoArg()
    [call() for call in itertools.repeat(counter.count_one, 10000000)]
    print counter.count

def run_any_counter():
    counter = Counter()
    any(itertools.imap(counter.count_one, itertools.repeat("foo", 10000000)))
    print counter.count

%time super_run()
10000000
CPU times: user 5.23 s, sys: 0.03 s, total: 5.26 s
Wall time: 5.43 s

%time super_counter_run()
10000000
CPU times: user 4.75 s, sys: 0.18 s, total: 4.94 s
Wall time: 5.80 s

%time run_any_counter()
10000000
CPU times: user 5.15 s, sys: 0.06 s, total: 5.21 s
Wall time: 5.30 s

def run_any_like_presentation():
    any(itertools.imap(_md5.update, itertools.repeat("foo", 10000000)))

def super_run_like_presentation():
    [do_work for do_work in itertools.imap(_md5.update, itertools.repeat("foo", 10000000))]

def super_run_like_presentation_2():
    [_md5.update(foo) for foo in itertools.repeat("foo", 10000000)]


%time run_any_like_presentation()
CPU times: user 5.28 s, sys: 0.02 s, total: 5.29 s
Wall time: 5.47 s

%time super_run_like_presentation()
CPU times: user 6.14 s, sys: 0.18 s, total: 6.33 s
Wall time: 7.56 s

%time super_run_like_presentation_2()
CPU times: user 8.44 s, sys: 0.22 s, total: 8.66 s
Wall time: 9.59 s

呃...

注意:我鼓励您自己运行测试。

Answer 1

在您的第一个示例中，第一个版本的run 必须在每次循环时查找_md5.update，而第二个版本则不需要。我认为您会发现这是造成性能差异的主要原因。其余部分可能与必须设置局部变量 i 有关，尽管这并不容易演示。

import itertools, hashlib, timeit
_md5 = hashlib.md5()

def run1():
    for i in itertools.repeat("foo", 10000000):
        _md5.update(i)

def run2():
    u = _md5.update
    for i in itertools.repeat("foo", 10000000):
        u(i)

def run3():
    any(itertools.imap(_md5.update, itertools.repeat("foo", 10000000)))

>>> timeit.timeit('run1()', 'from __main__ import run1', number=1)
6.081272840499878
>>> timeit.timeit('run2()', 'from __main__ import run2', number=1)
4.660238981246948
>>> timeit.timeit('run3()', 'from __main__ import run3', number=1)
4.062871932983398

itertools documentation有一个更好的方法来使用迭代器(并丢弃它的所有值):请参阅 consume 函数。使用 any 来完成这项工作取决于 _md5.update 总是返回 None 的事实，因此这种方法通常不起作用. 此外，配方速度稍微快一些: [查看评论]

import collections

def consume(it):
    "Consume iterator completely (discarding its values)."
    collections.deque(it, maxlen=0)

def run4():
    consume(itertools.imap(_md5.update, itertools.repeat("foo", 10000000)))

>>> timeit.timeit('run4()', 'from __main__ import run4', number=1)
3.969902992248535

编辑添加:似乎 consume 配方并不像它应该的那样广为人知:如果你查看 CPython 实现的细节，你会发现当 collections.deque 被 maxlen=0 调用，然后调用函数 consume_iterator in _collectionsmodule.c ，看起来像这样:

static PyObject*
consume_iterator(PyObject *it)
{
    PyObject *item;
    while ((item = PyIter_Next(it)) != NULL) {
        Py_DECREF(item);
    }
    Py_DECREF(it);
    if (PyErr_Occurred())
        return NULL;
    Py_RETURN_NONE;
}