为什么在我的情况下 For 循环比 Map、Reduce 和 List 理解更快答案

【问题标题】：Why is in my case For loop faster vs Map, Reduce and List comprehension为什么在我的情况下 For 循环比 Map、Reduce 和 List 理解更快
【发布时间】：2017-09-26 10:16:39
【问题描述】：

我写了一个简单的脚本来测试速度，这就是我发现的。实际上 for 循环在我的情况下是最快的。这真的让我吃惊，看看下面（计算平方和）。那是因为它在内存中保存了列表还是有意的？谁能解释一下。

from functools import reduce
import datetime


def time_it(func, numbers, *args):
    start_t = datetime.datetime.now()
    for i in range(numbers):
        func(args[0])
    print (datetime.datetime.now()-start_t)

def square_sum1(numbers):
    return reduce(lambda sum, next: sum+next**2, numbers, 0)


def square_sum2(numbers):
    a = 0
    for i in numbers:
        i = i**2
        a += i
    return a

def square_sum3(numbers):
    sqrt = lambda x: x**2
    return sum(map(sqrt, numbers))

def square_sum4(numbers):
    return(sum([i**2 for i in numbers]))


time_it(square_sum1, 100000, [1, 2, 5, 3, 1, 2, 5, 3])
time_it(square_sum2, 100000, [1, 2, 5, 3, 1, 2, 5, 3])
time_it(square_sum3, 100000, [1, 2, 5, 3, 1, 2, 5, 3])
time_it(square_sum4, 100000, [1, 2, 5, 3, 1, 2, 5, 3])

0:00:00.302000 #Reduce
0:00:00.144000 #For loop
0:00:00.318000 #Map
0:00:00.290000 #List comprehension`

更新 - 当我尝试更长的循环时会有结果。

time_it(square_sum1, 100, range(1000))
time_it(square_sum2, 100, range(1000))
time_it(square_sum3, 100, range(1000))
time_it(square_sum4, 100, range(1000))

0:00:00.068992
0:00:00.062955
0:00:00.069022
0:00:00.057446

【问题讨论】：

顺便说一句，这是衡量执行速度的一种不同寻常的方法。使用time.time 更为常见。但是使用timeit 模块会更好。您应该尝试使用生成器表达式而不是列表推导 sum：sum(i**2 for i in numbers);也可以试试sum(i*i for i in numbers)。
好问题；我喜欢你真的把所有相关信息都放进去了；以如此简洁的方式！

标签： python performance for-loop mapreduce list-comprehension

【解决方案1】：

Python function calls have overheads 这使得它们相对较慢，因此使用简单表达式的代码总是比将表达式包装在函数中的代码快；它是普通的def 函数还是lambda 都没有关系。出于这个原因，最好避免 map 或 reduce 如果您要向它们传递 Python 函数，如果您可以使用 for 循环中的普通表达式或理解或生成器表达式来完成等效工作。

有几个小的优化可以加快您的某些功能。不要做不必要的任务。例如，

def square_sum2a(numbers):
    a = 0
    for i in numbers:
        a += i ** 2
    return a

另外，i * i 比 i ** 2 快很多，因为乘法比幂运算快。

正如我在 cmets 中提到的，传递 sum 生成器比传递列表推导更有效，尤其是在循环很大的情况下；对于长度为 8 的小列表，它可能不会有什么不同，但对于大列表，它会非常明显。

sum(i*i for i in numbers)

顺便说一句，您不应该使用 sum 或 next 作为变量名，因为这会掩盖具有相同名称的内置函数。在这里它不会有任何伤害，但它仍然不是一个好主意，而且它使您的代码在具有比 SO 语法突出显示更全面的语法突出显示的编辑器中看起来很奇怪。

这是使用timeit 模块的新版本代码。它重复 3 次，每次循环 10,000 次，并对结果进行排序。正如timeit docs 中所解释的，在一系列重复中要查看的重要数字是最小的一个。

在典型情况下，最小值给出了速度的下限你的机器可以运行给定的代码sn-p；在更高的价值结果向量通常不是由 Python 的可变性引起的速度，但其他进程会干扰您的计时精度。所以结果的min() 可能是你应该是唯一的数字有兴趣。

from timeit import Timer
from functools import reduce

def square_sum1(numbers):
    return reduce(lambda total, u: total + u**2, numbers, 0)

def square_sum1a(numbers):
    return reduce(lambda total, u: total + u*u, numbers, 0)

def square_sum2(numbers):
    a = 0
    for i in numbers:
        i = i**2
        a += i
    return a

def square_sum2a(numbers):
    a = 0
    for i in numbers:
        a += i * i
    return a

def square_sum3(numbers):
    sqr = lambda x: x**2
    return sum(map(sqr, numbers))

def square_sum3a(numbers):
    sqr = lambda x: x*x
    return sum(map(sqr, numbers))

def square_sum4(numbers):
    return(sum([i**2 for i in numbers]))

def square_sum4a(numbers):
    return(sum(i*i for i in numbers))

funcs = (
    square_sum1,
    square_sum1a,
    square_sum2,
    square_sum2a,
    square_sum3,
    square_sum3a,
    square_sum4,
    square_sum4a,
)

data = [1, 2, 5, 3, 1, 2, 5, 3]

def time_test(loops, reps):
    ''' Print timing stats for all the functions '''
    timings = []
    for func in funcs:
        fname = func.__name__
        setup = 'from __main__ import data, ' + fname
        cmd = fname + '(data)'
        t = Timer(cmd, setup)
        result = t.repeat(reps, loops)
        result.sort()
        timings.append((result, fname))

    timings.sort()
    for result, fname in timings:
        print('{0:14} {1}'.format(fname, result))

loops, reps = 10000, 3
time_test(loops, reps)

输出

square_sum2a   [0.03815755599862314, 0.03817843700016965, 0.038571521999983815]
square_sum4a   [0.06384095800240175, 0.06462285799716483, 0.06579178199899616]
square_sum3a   [0.07395686000018031, 0.07405958899835241, 0.07463337299850537]
square_sum1a   [0.07867341000019223, 0.0788448769999377, 0.07908406700153137]
square_sum2    [0.08781023399933474, 0.08803317899946705, 0.08846573399932822]
square_sum4    [0.10260082300010254, 0.10360279499946046, 0.10415067900248687]
square_sum3    [0.12363515399920288, 0.12434166299863136, 0.1273790529994585]
square_sum1    [0.1276186039976892, 0.13786184099808452, 0.16315817699796753]

结果是在一台在 Linux 上运行 Python 3.6.0 的旧单核 32 位 2GHz 机器上获得的。

【讨论】：

是的，你写的很有道理，sum(i*i for i in numbers) 也加快了很多（大约 300%）
@alphiii 从我的更新版本中可以看出，timeit 使速度差异更加明显。一个主要原因是timeit 在进行计时测试时禁用垃圾收集，因此时间不会被垃圾收集所花费的时间所掩盖。

【解决方案2】：

这几乎独立于底层编程语言，因为在抽象中并不是免费的。

含义：调用方法总是有一定的成本。需要建立一个堆栈；控制流需要“跳跃”。当您想到较低级别时，例如 CPU：可能需要加载该方法的代码，等等。

换句话说：当您的主要需求是核心数字运算时，您必须在易用性与相应抽象的成本之间取得平衡。

Beyond：如果您专注于速度，那么您应该超越python，或者至少超越“普通”python。相反，您可以转向 numpy 等模块。

【讨论】：