python - 嵌套函数是否比 Python 中的全局函数更快?

标签 python performance-testing nested-function

我更喜欢在 Python 中尽可能使用嵌套函数而不是方法或全局函数。所以我决定测试它们的性能,因为它接缝了当你在另一个函数中定义一个函数时,在每次调用外部函数时都会有内部函数定义的开销。

充其量我希望全局函数稍微快一点,但令人惊讶的是嵌套函数更快。有谁知道为什么?

这是我的代码:

from time import clock

def a(n):
    return n + 1

def b1(loopcount):
    return sum([a(n) for n in range(loopcount)])

def b2(loopcount):
    def a(n):
        return n + 1
    return sum([a(n) for n in range(loopcount)])

powers = [5, 6, 7]
b1times = []
b2times = []
print "   ", "".join(["{:^10d}".format(n) for n in powers])    
for i in range(5):
    for power in powers:
        t = clock()
        b1(10**power)
        b1times.append(clock() - t)
    for power in powers:
        t = clock()
        b2(10**power)
        b2times.append(clock() - t)
    print "b1:", "".join(["{:^10.5f}".format(n) for n in b1times])
    print "b2:", "".join(["{:^10.5f}".format(n) for n in b2times])
    print ""
    b1times = []
    b2times = [] 

这是我电脑上的结果:

        5         6         7
b1:  0.08200   0.82773   8.47946
b2:  0.06914   0.79637   8.18571

b1:  0.07332   0.82139   8.68262
b2:  0.06547   0.82088   8.19606

b1:  0.07963   0.82625   9.65037
b2:  0.06617   0.82027   8.21412

b1:  0.07630   0.82112   8.49082
b2:  0.06541   0.80686   8.20532

b1:  0.12328   0.87034   8.42964
b2:  0.07059   0.79717   8.24620

更新:使用@Janne Karila 的评论

现在我更多地调用 b1 和 b2,b1 变得更快。因此,正如@Kos 和@Pavel Anossov 在他们的回答中所说,有几个因素会影响此处的速度,您无法做出笼统的陈述。
谢谢大家!

from time import *

def a1(n):
    return n + 1

def b1(n):
    return a1(n)

def b2(n):
    def a2():
        return n + 1
    return a2()

powers = [4, 5, 6]
b1times = []
b2times = []
print "   ", "".join(["{:^10d}".format(n) for n in powers])    
for i in range(5):
    for power in powers:
        t = clock()
        sum([b1(n) for n in range(10**power)])
        b1times.append(clock() - t)
    for power in powers:
        t = clock()
        sum([b2(n) for n in range(10**power)])
        b2times.append(clock() - t)
    print "b1:", "".join(["{:^10.5f}".format(n) for n in b1times])
    print "b2:", "".join(["{:^10.5f}".format(n) for n in b2times])
    print ""
    b1times = []
    b2times = [] 

最佳答案

这里有几个部分有作用:

1)定义函数的时候(创建函数对象),
2)按名称查找函数对象的时间,
3) 实际调用函数的时间。

您的全局函数示例使用 1) 更快(无需在每次调用 b1 时重新定义 a)。然而,它在 2) 中更慢,因为全局变量查找比本地查找慢。

那我们为什么不能两者兼得呢?

我已经 extended your benchmark使用使用全局函数的解决方案,但避免使用局部变量进行全局查找。它似乎是我机器上三个中最快的:

        5         6         7
b1:  0.04147   0.44421   4.46508
b2:  0.03399   0.43321   4.41121
b3:  0.03258   0.41821   4.25542

b1:  0.03240   0.42998   4.39774
b2:  0.03320   0.43465   4.42229
b3:  0.03155   0.42109   4.23669

b1:  0.03273   0.43321   4.37266
b2:  0.03326   0.43551   4.42208
b3:  0.03137   0.42356   4.25341

b1:  0.03253   0.43104   4.40466
b2:  0.03401   0.43719   4.42996
b3:  0.03155   0.41681   4.24132

b1:  0.03244   0.42965   4.37192
b2:  0.03310   0.43629   4.42727
b3:  0.03117   0.41701   4.23932

关于python - 嵌套函数是否比 Python 中的全局函数更快?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/14122195/

相关文章:

python - 使用Python评估html表中的图像

sql - 性能测试sql查询

testing - JMeter 无法使用 JMS 订阅者读取消息,给我 404 状态代码作为响应

Javascript 调用嵌套函数

javascript - Jasmine 测试没有看到嵌套函数

javascript - 在功能性 React 组件中定义处理程序的正确方法?

python - 从 asyncio.Protocol.data_received 调用协程

python - 将文本组合成 block

python - 如何使用 boto 在亚马逊上获取 key /文件的校验和?

用不同语言编写的API框架的性能基准