如何测量 python 代码行之间花费的时间？

Question

但是在 python 中是如何完成的呢？要测量代码行之间的时间开始和结束时间？这样做的东西：

import some_time_library

starttime = some_time_library.some_module()
code_tobe_measured() 
endtime = some_time_library.some_module()

time_taken = endtime - starttime

Answer 1

如果你想测量 CPU 时间，可以使用

time.process_time()

for Python 3.3 and above:

import time
start = time.process_time()
# your code here    
print(time.process_time() - start)

第一个电话打开计时器，第二个电话告诉你已经过了多少秒。

还有一个函数

time.clock()

，但是自Python 3.3起已弃用，并将在Python 3.8中删除

有更好的分析工具，例如

timeit

和

profile

，但是 time.process_time() 将测量 CPU 时间，这就是您要问的。

如果您想测量挂钟时间，请使用

time.time()

。

Answer 2

您还可以使用

time

库：

import time

start = time.time()

# your code

# end

print(f'Time: {time.time() - start}')

Answer 3

借助小型便捷类，您可以像这样测量在缩进行中花费的时间：

with CodeTimer():
   line_to_measure()
   another_line()
   # etc...

缩进行执行完毕后会显示如下内容：

Code block took: x.xxx ms

更新： 您现在可以通过

pip install linetimer

然后

from linetimer import CodeTimer

上课。请参阅这个 GitHub 项目。

上课代码：

import timeit

class CodeTimer:
    def __init__(self, name=None):
        self.name = " '"  + name + "'" if name else ''

    def __enter__(self):
        self.start = timeit.default_timer()

    def __exit__(self, exc_type, exc_value, traceback):
        self.took = (timeit.default_timer() - self.start) * 1000.0
        print('Code block' + self.name + ' took: ' + str(self.took) + ' ms')

然后您可以命名要测量的代码块：

with CodeTimer('loop 1'):
   for i in range(100000):
      pass

with CodeTimer('loop 2'):
   for i in range(100000):
      pass

Code block 'loop 1' took: 4.991 ms
Code block 'loop 2' took: 3.666 ms

和nest他们：

with CodeTimer('Outer'):
   for i in range(100000):
      pass

   with CodeTimer('Inner'):
      for i in range(100000):
         pass

   for i in range(100000):
      pass

Code block 'Inner' took: 2.382 ms
Code block 'Outer' took: 10.466 ms

关于

timeit.default_timer()

，它使用基于操作系统和Python版本的最佳计时器，参见这个答案。

Answer 4

将代码放在函数中，然后使用装饰器进行计时是另一种选择。 (Source) 这种方法的优点是您定义一次计时器并使用它 a simple additional line for every function.

首先定义

timer

装饰器：

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print("Finished {} in {} secs".format(repr(func.__name__), round(run_time, 3)))
        return value

    return wrapper

然后，在定义函数时使用装饰器：

@timer
def doubled_and_add(num):
    res = sum([i*2 for i in range(num)])
    print("Result : {}".format(res))

让我们试试：

doubled_and_add(100000)
doubled_and_add(1000000)

输出：

Result : 9999900000
Finished 'doubled_and_add' in 0.0119 secs
Result : 999999000000
Finished 'doubled_and_add' in 0.0897 secs

注意：我不确定为什么要使用

time.perf_counter

而不是

time.time

。欢迎评论。

Answer 5

我一向喜欢用时分秒来查看时间（%H:%M:%S）格式：

from datetime import datetime
start = datetime.now()
# your code
end = datetime.now()
time_taken = end - start
print('Time: ',time_taken)

输出：

Time:  0:00:00.000019

Answer 6

我一直在寻找一种如何用最少的代码输出格式化时间的方法，所以这是我的解决方案。无论如何，很多人都使用 Pandas，所以在某些情况下，这可以节省额外的库导入。

import pandas as pd
start = pd.Timestamp.now()
# code
print(pd.Timestamp.now()-start)

输出：

0 days 00:05:32.541600

如果时间精度不是最重要的，我建议使用这个，否则使用

time

库：

%timeit pd.Timestamp.now()

每个循环输出 3.29 µs ± 214 ns

%timeit time.time()

每个循环输出 154 ns ± 13.3 ns

Answer 7

你也可以试试这个：

from time import perf_counter

t0 = perf_counter()

...

t1 = perf_counter()
time_taken = t1 - t0

Answer 8

使用模块

time

，我们可以在函数开始和函数结束时计算unix时间。以下是代码的样子：

from time import time as unix

此代码导入

time.time

允许我们计算 unix 时间。

from time import sleep

这不是强制性的，但我也为其中一个演示导入

time.sleep

。

START_TIME = unix()

这是计算 unix 时间并将其放入变量中的方法。请记住，函数 unix 不是实际函数。我将

time.time

作为 unix 导入，所以如果您没有在第一次导入中放入

as unix

，您将需要使用

time.time()

.

在此之后，我们放置我们想要的任何函数或代码。在代码片段的末尾，我们放了

TOTAL_TIME = unix()-START_TIME

这行代码做了两件事：它在函数末尾计算 unix 时间，并使用之前的变量

START_TIME

，我们计算执行代码片段所花费的时间。

然后我们可以在任何我们想要的地方使用这个变量，包括

print()

函数。

print("The snippet took {} seconds to execute".format(TOTAL_TIME))

这里我写了一个快速演示代码，有两个实验作为演示。（完整评论）

from time import time as unix # Import the module to measure unix time
from time import sleep

# Here are a few examples:
# 1. Counting to 100 000
START_TIME = unix()
for i in range(0, 100001):
  print("Number: {}\r".format(i), end="")
TOTAL_TIME = unix() - START_TIME
print("\nFinal time (Expirement 1): {} s\n".format(TOTAL_TIME))

# 2. Precision of sleep
for i in range(10):
  START_TIME = unix()
  sleep(0.1)
  TOTAL_TIME = unix() - START_TIME
  print("Sleep(0.1): Index: {}, Time: {} s".format(i,TOTAL_TIME))

这是我的输出：

Number: 100000
Final time (Expirement 1): 16.666812419891357 s

Sleep(0.1): Index: 0, Time: 0.10014867782592773 s
Sleep(0.1): Index: 1, Time: 0.10016226768493652 s
Sleep(0.1): Index: 2, Time: 0.10202860832214355 s
Sleep(0.1): Index: 3, Time: 0.10015869140625 s
Sleep(0.1): Index: 4, Time: 0.10014724731445312 s
Sleep(0.1): Index: 5, Time: 0.10013675689697266 s
Sleep(0.1): Index: 6, Time: 0.10014677047729492 s
Sleep(0.1): Index: 7, Time: 0.1001439094543457 s
Sleep(0.1): Index: 8, Time: 0.10044598579406738 s
Sleep(0.1): Index: 9, Time: 0.10014700889587402 s
>

Answer 9

使用

timeit

模块来衡量你的表现：

def test():
    print("test")
    emptyFunction()
    for i in [x for x in range(10000)]:
        i**i


def emptyFunction():
    pass

if __name__ == "__main__":
    import timeit
    print(timeit.timeit("test()", number = 5, globals = globals()))
    #print(timeit.timeit("test()", setup = "from __main__ import test",
    #    number = 5))

第一个参数定义了我们想要执行的代码片段

test

在这种情况下&

number

定义了你想要重复多少次执行.

输出：

test
test
test
test
test
36.81822113099952

Answer 10

使用timeit：

import timeit
timeit.timeit("code_tobe_measured()")

例如

>>> import timeit
>>> timeit.timeit("import pandas")
2.923877900000008

Answer 11

让我再添加一点到 https://stackoverflow.com/a/63665115/7412781 解决方案。

删除对
```
functools
```
.
使用的进程时间
```
time.process_time()
```
而不是
```
time.perf_counter()
```
的绝对计数器，因为进程可以通过内核进行上下文切换。
也使用原始函数指针打印来获取正确的类名。

这是装饰器代码。

import time

def decorator_time_taken(fnc):
    def inner(*args):
        start = time.process_time()
        ret = fnc(*args)
        end = time.process_time()
        print("{} took {} seconds".format(fnc, round((end - start), 6)))
        return ret
    return inner

这是使用示例代码。它正在检查 193939 是否为质数。

class PrimeBrute:
    @decorator_time_taken
    def isPrime(self, a):
        for i in range(a-2):
           if a % (i+2) == 0: return False
        return True

inst = PrimeBrute()
print(inst.isPrime(193939))

这是输出。

<function PrimeBrute.isPrime at 0x7fc0c6919ae8> took 0.015789 seconds
True

Answer 12

导入日期时间

#计算前的这段代码

%%timeit ~代码~

如何测量 python 代码行之间花费的时间？

问题描述投票：0回答：12

12个回答

输出：

最新问题

如何测量 python 代码行之间花费的时间？

问题描述 投票：0回答：12

12个回答

输出：

最新问题

问题描述投票：0回答：12