Почему этот код нарезки быстрее, чем более процедурный код?

Ответ 1

Много интересной дискуссии в другом месте этой темы. В принципе, мы начали сравнивать две версии этой функции, которые я буду описывать со следующими немыми именами:

• Версия zip -py:

  def pairs(xs):
      for p in zip(xs[:-1], xs[1:]): 
          yield p
  

• Версия "loopy":

  def pairs(xs):
      last = object()
      dummy = last
      for x in xs:
          if last is not dummy:
              yield last,x
          last = x
  

Так почему же петлевая версия оказывается медленнее? В принципе, я думаю, что это сводится к нескольким вещам:

• Строчная версия явно выполняет дополнительную работу: она сравнивает идентификаторы двух объектов (if last is not dummy: ...) на каждой инициализирующей пару итерации внутреннего цикла.

  • @mambocab edit показывает, что не делать этого сравнения делает петлевую версию
    немного быстрее, но не полностью закрывает пробел.
    
    

• В zippy-версии больше всего содержится в компилированном C-коде, который имеет петлевая версия в коде Python:

  • Объединение двух объектов в tuple. Завершающая версия имеет yield last,x, тогда как в zippy-версии кортеж p поступает прямо от zip, поэтому он просто делает yield p.

  • Связывание имен переменных с объектом: циклическая версия делает это дважды в каждом цикле, назначая x в цикле for и last=x. Версия zippy делает это только один раз, в цикле for.

• Интересно, что существует один способ, с помощью которого zippy-версия действительно выполняет больше: она использует два listiterator s, iter(xs[:-1]) и iter(xs[1:]), которые передаются в zip. В циклической версии используется один listiterator (for x in xs).

  • Создание объекта listiterator (вывод iter([])), вероятно, очень оптимизирован, поскольку программисты Python используют его так часто.
  • Итерация над списками списков xs[:-1] и xs[1:] - очень легкая операция, которая практически не увеличивает накладные расходы по сравнению с итерированием по всему списку. По сути, это просто означает перемещение начальной или конечной точки итератора, но не изменение того, что происходит на каждой итерации.

Ответ 2

Это я результат для iZip, который на самом деле ближе к вашей реализации. Похоже на то, чего вы ожидаете. Версия zip создает весь список в памяти внутри функции, поэтому она самая быстрая. Версия цикла просто проиграет список, так что он немного медленнее. iZip является самым близким по отношению к коду, но я предполагаю, что есть некоторые бэкэнд-процессы управления памятью, которые увеличивают время выполнения.

In [11]: %timeit pairsLoop([1,2,3,4,5])
1000000 loops, best of 3: 651 ns per loop

In [12]: %timeit pairsZip([1,2,3,4,5])
1000000 loops, best of 3: 637 ns per loop

In [13]: %timeit pairsIzip([1,2,3,4,5])
1000000 loops, best of 3: 655 ns per loop

Ниже приведена версия кода ниже:

from itertools import izip


def pairsIzip(xs):
    for p in izip(xs[:-1], xs[1:]): 
        yield p

def pairsZip(xs):
    for p in zip(xs[:-1], xs[1:]): 
        yield p

def pairsLoop(xs):
    last = object()
    dummy = last
    for x in xs:
        if last is not dummy:
            yield last,x
        last = x

Ответ 3

Я подозреваю, что основная причина, по которой вторая версия медленнее, заключается в том, что она выполняет операцию сравнения для каждой пары, которая yield s:

# pair-generating loop
for x in xs:
    if last is not dummy:
       yield last,x
    last = x

Первая версия не делает ничего, кроме плюсов. Переименованные переменные цикла эквивалентны этому:

# pair-generating loop
for last,x in zip(xs[:-1], xs[1:]):
    yield last,x 

Это не особенно красиво или Pythonic, но вы можете написать процедурный вариант без сравнения во внутреннем цикле. Как быстро это выполняется?

def pairs(xs):
    for ii in range(1,len(xs)):
        yield xs[ii-1], xs[ii]