假设您要测量代码段的执行时间。你是做什么？直到现在，我就像大多数人一样会做以下事情：

登录后复制 
# 导入时间
start_time = time.time()
"""某些代码"""
end_time = time.time()
print(f“执行时间为：{end_time-start_time}”)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.

现在说我们要比较两个不同函数的执行时间，然后：

登录后复制 
# 导入时间
def function_1(*参数)：
 ＃做一点事
 ＃返回值
def function_2(*参数)：
 ＃做一点事
 ＃返回值
 
＃衡量function_1花费的时间
start_of_f1 = time.time()
值1 = function_1(*参数)
end_of_f1 = time.time()
print(f” function_1花费的时间是：{start_of_f1-end_of_f1}”)＃function_2所花费的测量时间
start_of_f2 = time.time()
值2 = function_1(*参数)
end_of_f2 = time.time()print(f” function_1花费的时间是：{start_of_f2-end_of_f2}”)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

这是大多数人衡量执行时间并比较两个功能的方式。

但是，如果必须测量非常小的代码段所花费的时间，则此方法无法产生准确的结果。甚至在比较功能时，操作系统中发生的所有其他进程和任务都与time.time()实例混为一谈。因此比较功能时不准确。

为了解决这个问题，Python有一个timeit模块，该模块用于测量大小代码段的执行时间。在本文的此处，我们首先使用一些示例来了解python 中的timeit库。

首先，让我们看看文档中提供的概述。

在Python中的timeit

该模块提供了一种计时少量Python代码的简单方法。它既具有命令行界面又具有可调用界面。它避免了许多用于测量执行时间的常见陷阱。

这个模块有一个函数timeit.timeit(stmt = pass，setup = pass，timer = ，number = 1000000)这个函数有四个参数：

  1. stmt：要测量其执行时间的代码段。
  2. setup：执行stmt之前要运行的代码。通常，它用于导入一些模块或声明一些必要的变量。通过示例将更加清楚。
  3. timer：这是默认的timeit.Timer对象。它有一个合理的默认值，因此我们不必做太多事情。
  4. number：指定将执行stmt的次数。

它会回到执行拍摄(秒)的时间语句，指定的数十倍。

让我们看一些例子以更好地理解它。

登录后复制 
导入时间

＃此代码在stmt之前仅执行一次。
setup_code =“来自数学导入sqrt”

＃此代码将按照参数'number'的指定执行
stmt_code =“ sum(sqrt(x)for范围(1,10000)中的x)”
迭代次数= 10000
时间= timeit.timeit(stmt = stmt_code，设置= setup_code，数量=迭代次数)

打印(时间)

＃17.9秒
＃此输出适用于代码片段的10000个版本，而不是一个单独的版本。

print(f“单次迭代的时间为{time / iterations”“)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

我们所做的只是将代码作为字符串传递，并指定迭代次数给timeit.timeit函数。

现在，让我们看看一种使用该惊人库来比较两个函数的方法。

在此示例中，让我们比较两个排序函数，一个是简单的冒泡排序，另一个是Python内置的sorted()函数。在这里，我们还将看到另一个名为repeat()的timeit函数。

登录后复制 
def bubble_sort(arr)：
    对于范围内的我(len(arr))：
        对于范围(0，len(arr)-i-1)中的j：
            如果arr [j]> arr [j + 1]：
                arr [j]，arr [j + 1] = arr [j +1]，arr [j]
    返回arr


def make_random_array()：
    来自随机进口randint

    返回[randint(-100，100)表示范围(20)中的i]


test_array = make_random_array()
'''
由于我们要确保在同一数组上测试函数，因此我们声明一个数组
在这里，稍后将在compare_functions()中调用它。
'''

def compare_functions()：
    导入时间

    setup_code1 =“”“
来自__main__ import bubble_sort
从__main__导入test_array
“”
    setup_code2 =“”“
从__main__导入test_array
“”
    stmt_code1 =“ bubble_sort(test_array)”
    stmt_code2 =“ sorted(test_array)”

    times1 = timeit.repeat(stmt = stmt_code1，setup = setup_code1，number = 10000，repeat = 5)
    times2 = timeit.repeat(stmt = stmt_code2，setup = setup_code2，number = 10000，repeat = 5)
    print(f“气泡排序所花费的时间为{min(times1)}”)
    print(f“内置排序所花费的时间为{min(times2)}”)

如果__name__ ==“ __main__”：
    compare_functions()
“”
气泡排序花费的时间是0.2646727000001192
内置排序所花费的时间是0.0031973000000107277
“”
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.

在这里，输出是列表times1和times2中的最小值。

在设置代码中，

登录后复制 
来自__main__导入气泡排序
from __main__ import arr 这将导入程序中已定义的bubble_sort函数，并导入我们在程序中先前声明的数组“ test_array”。
这将确保两个功能都在同一数组“ test_array”上进行测试。
  • 1.
  • 2.
  • 3.

timeit.repeat()需要一个附加参数，重复(默认值= 5)。这将返回多次重复的代码段的执行时间列表。

正如预期的那样，冒泡排序所花费的时间比内置的sorted()函数要多得多。

现在总结，让我们看看如何使用该库中的命令行界面。

从命令行作为程序调用时，使用以下形式：

登录后复制 
python -m timeit [-n N] [-r N] [-u U] [-s S] [声明...]
  • 1.

这里，

  1. -n N，执行“语句”的次数。
  2. -r N，重复多少次
  3. -ss，设置语句
  4. -uu，计时器输出单位(nano，micro，mil，sec)

一些示例如下：

登录后复制 
$ python -m timeit -s'text =“样本字符串”; char =“ g”''文本中的字符'
5000000次循环，最好是5次：每个循环0.0877微秒
$ python -m timeit -s'text =“样本字符串”; char =“ g”''text.find(char)'
1000000次循环，最好5次：每个循环0.342微秒
  • 1.
  • 2.
  • 3.
  • 4.

这结束了timeit模块的介绍。我试图涵盖所有需要知道的知识，从现在开始开始使用此模块。

这是该模块的官方文档。请看看它以了解有关此模块的更多信息。我也鼓励您在这里查看此模块的源代码。