前言

在实际工作中，我们常常需要知道程序的实际运行时间（wall-clock time, real time）。本文就介绍了几种在Python中计时程序运行耗时的方法。

1. 一般方法

最为常见的方法，就是在代码的开头和结尾分别获取时间戳，然后两者之差便是程序运行时间。

1. import time
   
2. 
   
3. def do_something(nsec=0):
   
4.         if isinstance(nsec, (int, float)):
   
5.                 time.sleep(nsec)  # 模拟程序运行耗时
   
6. 
   
7. if __name__ == "__main__":
   
8.         start_time        = time.perf_counter()  # 记录开始时间戳
   
9.         do_something(3)
   
10.         do_something(1)
    
11.         do_something(0.5)
    
12.         end_time = time.perf_counter()  # 记录结束时间戳
    
13.         print(f"耗时 {end_time - start_time:.3f} s")

复制代码

这是最简单直接的方法，但问题是当需要计时的部分很多的时候，会导致大量的重复代码。

2. 基于上下文管理器

相比之下，使用Python的上下文管理器（context manager）是更加优雅，复用性更好的解决方案。Python的上下文管理器机制是用来更加方便地管理如文件、数据库连接、锁等资源的，确保在使用结束后恰当地关闭及释放资源，以避免造成泄露。
然而，上下文管理器的用途不仅限于资源的管理，其适合于所有的代码开始和结束的成对操作，就比如计时程序的运行时间。

1. import time
   
2. 
   
3. class Timer:
   
4.         """
   
5.         按照 xxh xxm xxs格式计时程序运行时间的计时上下文管理器
   
6.         """
   
7.         def __init__(self, code_part):
   
8.                 self._part = code_part
   
9.                
   
10.         def __enter__(self):
    
11.                 self._enter_time = time.perf_counter()
    
12.                
    
13.         def __exit__(self, *exc_args):  # 不做异常处理，因此将异常相关的参数打包
    
14.                 time_span = time.perf_counter() - self._enter_time
    
15.                 hours, seconds = divmod(time_span, 3600)
    
16.                 minutes, seconds = divmod(seconds, 60)
    
17.                 print(f"{self._part}耗时 {int(hours)}h {int(minutes)}m {seconds:.2f}s")
    
18. 
    
19. def do_something(nsec=0):
    
20.         if isinstance(nsec, (int, float)):
    
21.                 time.sleep(nsec)  # 模拟程序运行耗时
    
22. 
    
23. if __name__ == "__main__":
    
24.         with Timer("Main"):
    
25.                 with Timer("Part1"):
    
26.                         do_something(0.3)
    
27.                 with Timer("Part2"), open("demo_file.txt", "wt") as f:
    
28.                         f.write("Hello, World\n")
    
29.                         do_something(2)
    
30.                 do_something(1)

复制代码

3. 基于装饰器

使用Python的装饰器特性，可以十分方便地在函数水平添加计时器，计时单个函数的运行时间。

1. import time
   
2. from functools import wraps
   
3. 
   
4. def timer(func):
   
5.         @wraps(func)
   
6.         def inner(*args, **kwargs):
   
7.                 start_time = time.perf_counter()
   
8.                 retval = func(*args, **kwargs)
   
9.                 time_span = time.perf_counter() - start_time
   
10.                 hours, seconds = divmod(time_span, 3600)
    
11.                 minutes, seconds = divmod(seconds, 60)
    
12.                 print(f"{func.__name__}耗时 {int(hours)}h {int(minutes)}m {seconds:.2f}s")
    
13.                 return retval
    
14.         return inner
    
15. 
    
16. @timer
    
17. def do_something(nsec=0):
    
18.         if isinstance(nsec, (int, float)):
    
19.                 time.sleep(nsec)  # 模拟程序运行耗时
    
20. 
    
21. @timer
    
22. def main():
    
23.         do_something(1)
    
24.         time.sleep(0.5)
    
25. 
    
26. if __name__ == "__main__":
    
27.         main()       

复制代码

总结

到此这篇关于Python中计时程序运行时间的几种常用方法的文章就介绍到这了,更多相关Python计时程序运行时间方法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/python/339881lje.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！