Python 3.5 против 3.6, что сделало карту медленнее по сравнению с пониманием

Я думаю, что честное сравнение предполагает использование одной и той же функции и одинаковых условий тестирования в Python 3.5 и 3.6, а также при сравнении map с пониманием списка в выбранной версии Python.

В своем первоначальном ответе я провел несколько тестов, которые показали, что map по-прежнему работает примерно в два раза быстрее в обеих версиях Python по сравнению с пониманием списка. Однако некоторые результаты не были окончательными, поэтому я провел еще несколько тестов.

Сначала позвольте мне привести некоторые из ваших пунктов, изложенных в вопросе:

"... [Я] заметил, что относительная производительность [map] (по сравнению с аналогичным распознаванием списков) резко изменилась между Python 3.5 и 3.6"

Вы также спросите:

"Мой вопрос: что произошло в этом случае, из-за чего понимание списка ускорилось, а решение карты замедлилось?"

Не очень ясно, имеете ли вы в виду, что карта медленнее, чем понимание списка в Python 3.6, или вы имеете в виду, что карта в Python 3.6 медленнее, чем в 3.5, и производительность понимания списка увеличилась (хотя и не обязательно до уровня избиения map).

Основываясь на более обширных тестах, которые я провел после своего первого ответа на этот вопрос, я думаю, что имею представление о том, что происходит.

Однако сначала создадим условия для «честных» сравнений. Для этого нам необходимо:

1. Сравните производительность map в разных версиях Python, используя одну и ту же функцию;

2. Сравните производительность map с пониманием списка в той же версии, используя ту же функцию;

3. Запустите тесты на одних и тех же данных;

4. Минимизируйте вклад от функций синхронизации.

Вот информация о версии моей системы:

Python 3.5.3 |Continuum Analytics, Inc.| (default, Mar  6 2017, 12:15:08) 
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
IPython 5.3.0 -- An enhanced Interactive Python.

и

Python 3.6.2 |Continuum Analytics, Inc.| (default, Jul 20 2017, 13:14:59) 
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
IPython 6.1.0 -- An enhanced Interactive Python. Type '?' for help.

Давайте сначала обратимся к проблеме «одинаковых данных». К сожалению, поскольку вы фактически используете seed(None), каждый набор данных lst отличается в каждой из двух версий Python. Это, вероятно, способствует разнице в производительности, наблюдаемой в двух версиях Python. Одним из исправлений было бы установить, например, random.seed(0) (или что-то в этом роде). Я решил создать список один раз и сохранить его с помощью numpy.save(), а затем загрузить его в каждой версии. Это особенно важно, потому что я решил немного изменить ваши тесты (количество «циклов» и «повторений») и увеличил длину вашего набора данных до 100 000 000:

import numpy as np
import random
lst = [random.randint(0, 10) for _ in range(100000000)]
np.save('lst', lst, allow_pickle=False)

Во-вторых, давайте использовать модуль timeit вместо волшебной команды IPython %timeit. Причина этого заключается в следующем тесте, выполненном в Python 3.5:

In [11]: f = (5).__lt__
In [12]: %timeit -n1 -r20 [f(i) for i in lst]
1 loop, best of 20: 9.01 s per loop

Сравните это с результатом timeit в той же версии Python:

>>> t = timeit.repeat('[f(i) for i in lst]', setup="f = (5).__lt__;
... import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, 
... number=1); print(min(t), max(t), np.mean(t), np.std(t))
7.442819457995938 7.703615028003696 7.5105415405 0.0550515642854

По неизвестным мне причинам магия IPython %timeit прибавляет время по сравнению с пакетом timeit. Поэтому в своем тестировании я буду использовать исключительно timeit.

ПРИМЕЧАНИЕ. В последующих обсуждениях я буду использовать только минимальное время (min(t)).

Тесты в Python 3.5.3:

Группа 1: тесты на понимание карты и списка

>>> import numpy as np
>>> import timeit

>>> t = timeit.repeat('list(map(f, lst))', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.666553302988177 4.811194089008495 4.72791638025 0.041115884397

>>> t = timeit.repeat('[f(i) for i in lst]', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
7.442819457995938 7.703615028003696 7.5105415405 0.0550515642854

>>> t = timeit.repeat('[5 < i for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.94656751700677 5.07807950800634 5.00670203845 0.0340474956945

>>> t = timeit.repeat('list(map(abs, lst))', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.167273573024431 4.320013975986512 4.2408865186 0.0378852782878

>>> t = timeit.repeat('[abs(i) for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
5.664627838006709 5.837686392012984 5.71560354655 0.0456700607748

Обратите внимание, что второй тест (понимание списка с использованием f(i)) значительно медленнее, чем третий тест (понимание списка с использованием 5 < i), указывая на то, что f = (5).__lt__ не идентичен (или почти идентичен) 5 < i с точки зрения кода.

Группа 2: «индивидуальные» функциональные тесты

>>> t = timeit.repeat('f(1)', setup="f = (5).__lt__", repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.052280781004810706 0.05500587198184803 0.0531139718529 0.000877649561967

>>> t = timeit.repeat('5 < 1', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.030931947025237605 0.033691533986711875 0.0314959864045 0.000633274658428

>>> t = timeit.repeat('abs(1)', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.04685414198320359 0.05405496899038553 0.0483296330043 0.00162837880358

Обратите внимание, как снова первый тест (из f(1)) значительно медленнее второго теста (из 5 < 1), что еще раз подтверждает, что f = (5).__lt__ не идентичен (или почти идентичен) 5 < i с точки зрения кода.

Тесты в Python 3.6.2:

Группа 1: тесты на понимание карты и списка

>>> import numpy as np
>>> import timeit

>>> t = timeit.repeat('list(map(f, lst))', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.599696700985078 4.743880658003036 4.6631793691 0.0425774678203

>>> t = timeit.repeat('[f(i) for i in lst]', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
7.316072431014618 7.572676292009419 7.3837024617 0.0574811241553

>>> t = timeit.repeat('[5 < i for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.570452399988426 4.679144663008628 4.61264215875 0.0265541828693

>>> t = timeit.repeat('list(map(abs, lst))', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
2.742673939006636 2.8282236389932223 2.78504617405 0.0260357089928

>>> t = timeit.repeat('[abs(i) for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
6.2177103200228885 6.428813881997485 6.28722427145 0.0493010620999

Группа 2: «индивидуальные» функциональные тесты

>>> t = timeit.repeat('f(1)', setup="f = (5).__lt__", repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.051936342992121354 0.05764096099301241 0.0532974587506 0.00117079475737

>>> t = timeit.repeat('5 < 1', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.02675032999832183 0.032919151999522 0.0285137565021 0.00156522182488

>>> t = timeit.repeat('abs(1)', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.047831349016632885 0.0531779529992491 0.0482893927969 0.00112825297875

Обратите внимание, как снова первый тест (из f(1)) значительно медленнее, чем второй тест (из 5 < 1), что еще раз подтверждает, что f = (5).__lt__ не идентичен (или почти идентичен) 5 < i с точки зрения кода.

Обсуждение

Я не знаю, насколько надежны эти временные тесты, и также трудно выделить все факторы, влияющие на эти временные результаты. Однако из «Группы 2» тестов мы можем заметить, что единственным «индивидуальным» тестом, который значительно изменил свое время, является тест 5 < 1: он снизился до 0,0268 с в Python 3.6 с 0,0309 с в Python 3.5. Это делает тест понимания списка в Python 3.6, использующий 5 < i, работать быстрее, чем аналогичный тест в Python 3.5. Однако это не означает, что понимание списков стало быстрее в Python 3.6.

Давайте сравним относительную производительность map с пониманием списка для той же функции в той же версии Python. Затем мы получаем в Python 3.5: r(f) = 7.4428/4.6666 = 1.595, r(abs) = 5.665/4.167 = 1.359 и в Python 3.6: r(f) = 7.316/4.5997 = 1.591, r(abs) = 6.218/2.743 = 2.267. Основываясь на этих относительных показателях, мы видим, что в Python 3.6 производительность map по отношению к производительности понимания списка по крайней мере такая же, как в Python 3.5 для функции f = (5).__lt__, и это соотношение даже улучшилось для такой функции, как abs() в Python. 3.6.

В любом случае, я считаю, что нет никаких доказательств того, что понимание списка стало быстрее в Python 3.6 ни в относительном, ни в абсолютном смысле. Единственное улучшение производительности связано с тестом [5 < i for i in lst], но это потому, что сам 5 < i стал быстрее в Python 3.6, а не из-за того, что само понимание списка стало быстрее.

Я думаю, что честное сравнение будет включать использование одной и той же функции. В случае вашего примера, когда сравнение справедливо, map все равно выигрывает:

>>> import sys
>>> print(sys.version)
3.6.2 |Continuum Analytics, Inc.| (default, Jul 20 2017, 13:14:59) 
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]
>>> import random
>>> lst = [random.randint(0, 10) for _ in range(100000)]
>>> assert list(map((5).__lt__, lst)) == [5 < i for i in lst]
>>> f = (5).__lt__
>>> %timeit list(map(f, lst))
4.63 ms ± 110 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
>>> %timeit [f(i) for i in lst]
9.17 ms ± 177 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Хотя в Python 3.5 (по крайней мере, в моей системе) map работает быстрее, чем в Python 3.6, так же как и понимание списка:

>>> print(sys.version)
3.5.3 |Continuum Analytics, Inc.| (default, Mar  6 2017, 12:15:08) 
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]
>>> %timeit list(map(f, lst))
100 loops, best of 3: 4.36 ms per loop
>>> %timeit [f(i) for i in lst]
100 loops, best of 3: 8.12 ms per loop

Тем не менее, при использовании одной и той же функции map примерно в 2 раза быстрее, чем понимание списка как в Python 3.5, так и в 3.6.

РЕДАКТИРОВАТЬ (ответ на комментарии @user2357112):

Я считаю, что выполнение «добросовестных» сравнений важно для ответа на вопрос ОП: «Мой вопрос: что произошло в этом случае, что ускорило понимание списка и замедлило решение карты?» (последний абзац ). Однако в первом абзаце @MSeifert говорит: "... [Я] заметил, что относительная производительность (по сравнению с аналогичным пониманием списка) резко изменилась между Python 3.5 и 3.6"< /em> То есть сравнение идет между map и list comprehension. Тем не менее, тесты @MSeifert настроены следующим образом:

timig_map_35 = Timing(list(map(f, lst)))
timing_list_35 = Timing([g(i) for i in lst])

import random
lst = [random.randint(0, 10) for _ in range(1000000)] # 10x more elements
f = (5).__lt__
%timeit -n1 -r1000 list(map(f, lst)) # f = (5).__lt__
%timeit -n1 -r1000 [f(i) for i in lst] # f(i) = (5).__lt__(i)
%timeit -n1 -r1000 [5 < i for i in lst] # g(i) = 5 < i
%timeit -n1 -r1000 [1 for _ in lst] # h(i) = 1

43.5 ms ± 1.79 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
82.2 ms ± 2.39 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
43.6 ms ± 1.64 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
23.8 ms ± 1.27 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)

1 loop, best of 1000: 43.7 ms per loop
1 loop, best of 1000: 78.9 ms per loop
1 loop, best of 1000: 46 ms per loop
1 loop, best of 1000: 26.8 ms per loop

%timeit -n1 -r1000 list(map(abs, lst))
%timeit -n1 -r1000 [abs(i) for i in lst]
%timeit -n1000000 -r1000 f(1)

25.8 ms ± 1.42 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
67.1 ms ± 2.07 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
64.7 ns ± 2.22 ns per loop (mean ± std. dev. of 1000 runs, 1000000 loops each)

1 loop, best of 1000: 38.3 ms per loop
1 loop, best of 1000: 56.4 ms per loop
1000000 loops, best of 1000: 59.6 ns per loop