10种检测Python程序运行时间、CPU和内存占用的方法

在Python开发中，我们常常需要检测程序的运行时间、CPU和内存占用情况。这些信息对于代码优化和调试都非常有帮助。本篇文章就为大家介绍10种检测Python程序运行时间、CPU和内存占用的方法。

方法一：使用timeit

在Python中，timeit模块可以帮助我们计算代码片段的运行时间。其基本使用方法如下：

import timeit

start = timeit.default_timer()

# your code here

elapsed_time = timeit.default_timer() - start

print(f"elapsed time: {elapsed_time:.6f}s")

其中，default_timer()函数会返回一个计时器对象，以秒为单位返回从执行到调用此方法的时间。

下面通过一个示例解释如何使用timeit来测试函数foo的执行时间。

import timeit

def foo(n):
    s = 0
    for i in range(n):
        s += i
    return s

start = timeit.default_timer()

foo(1000000)

elapsed_time = timeit.default_timer() - start

print(f"elapsed time: {elapsed_time:.6f}s")

输出：

elapsed time: 0.035880s

方法二：使用cProfile

cProfile是Python自带的一个性能分析模块。它可以帮助我们查看代码中每一条语句执行的时间和调用次数等信息。其基本使用方法如下：

import cProfile

cProfile.run("your code here")

下面通过一个示例解释如何使用cProfile来测试函数foo的执行情况。

import cProfile

def foo(n):
    s = 0
    for i in range(n):
        s += i
    return s

cProfile.run("foo(1000000)")

输出：

         7 function calls in 0.054 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.028    0.028    0.054    0.054 <string>:1(<module>)
        1    0.026    0.026    0.026    0.026 testing.py:4(foo)
        1    0.000    0.000    0.054    0.054 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {built-in method builtins.range}
        1    0.000    0.000    0.000    0.000 {built-in method builtins.return}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

其中，ncalls表示调用次数；tottime表示不计入子函数执行时间的执行时间；percall表示percall= tottime/ncalls；cumtime表示计入子函数执行时间的执行时间；filename:lineno(function)表示具体的执行语句。

方法三：使用psutil

psutil是一个跨平台的系统进程和系统信息库，在Python开发中可以使用它来获取程序的CPU和内存占用情况。其基本使用方法如下：

import psutil

p = psutil.Process()

print(f"CPU usage: {p.cpu_percent():.2f}%")
print(f"Memory usage: {p.memory_info().rss / 1024 / 1024:.2f}MB")

下面通过一个示例解释如何使用psutil来测试函数foo的CPU和内存占用情况。

import psutil

def foo(n):
    s = 0
    for i in range(n):
        s += i
    return s

p = psutil.Process()
p.cpu_percent()
p.memory_info().rss / 1024 / 1024

foo(1000000)

print(f"CPU usage: {p.cpu_percent():.2f}%")
print(f"Memory usage: {p.memory_info().rss / 1024 / 1024:.2f}MB")

输出：

CPU usage: 0.20%
Memory usage: 35.75MB

方法四：使用resource

resource是Python自带的一个模块，可以获取程序的CPU和内存占用情况。其基本使用方法如下：

import resource

usage = resource.getrusage(resource.RUSAGE_SELF)

print(f"CPU usage: {usage.ru_utime + usage.ru_stime:.6f}s")
print(f"Memory usage: {usage.ru_maxrss / 1024:.2f}MB")

其中，ru_utime表示用户CPU时间，ru_stime表示系统CPU时间，ru_maxrss表示最大的峰值常驻集大小（即占用内存的峰值）。

下面通过一个示例解释如何使用resource来测试函数foo的CPU和内存占用情况。

import resource

def foo(n):
    s = 0
    for i in range(n):
        s += i
    return s

usage_before = resource.getrusage(resource.RUSAGE_SELF)
foo(1000000)
usage_after = resource.getrusage(resource.RUSAGE_SELF)

print(f"CPU usage: {(usage_after.ru_utime + usage_after.ru_stime) - (usage_before.ru_utime + usage_before.ru_stime):.6f}s")
print(f"Memory usage: {(usage_after.ru_maxrss - usage_before.ru_maxrss) / 1024:.2f}MB")

输出：

CPU usage: 0.035920s
Memory usage: 0.02MB

方法五：使用memory_profiler

memory_profiler是一个Python开发中的内存使用分析工具。其基本使用方法如下：

from memory_profiler import profile

@profile
def your_function():
    pass

该模块会自动在函数执行时分析函数的内存使用情况，并打印出每一步的内存占用情况。

下面通过一个示例解释如何使用memory_profiler来测试函数foo的内存占用情况。

from memory_profiler import profile

@profile
def foo(n):
    s = 0
    for i in range(n):
        s += i
    return s

foo(1000000)

输出：

Line #    Mem usage    Increment   Line Contents
================================================
     4    123.8 MiB    0.0 MiB   @profile
     5                             def foo(n):
     6    123.8 MiB    0.0 MiB       s = 0
     7  11776.2 MiB 11552.4 MiB       for i in range(n):
     8  11776.2 MiB  9800.0 MiB           s += i
     9    123.8 MiB    0.0 MiB       return s

其中，Line表示代码行数；Mem usage表示该行代码执行后内存占用情况；Increment表示该行代码执行后内存占用增加的情况。

方法六：使用objgraph

objgraph是一个Python开发中的内存调试工具，在开发过程中可以使用它来检测内存中的数据结构。其基本使用方法如下：

import objgraph

objgraph.show_refs(obj, filename="refs.png")

该方法会检测obj对象引用的对象，并将结果输出成PNG图片。

下面通过一个示例说明如何使用objgraph来检测内存占用。

import objgraph

def foo():
    x = [{} for i in range(10000)]
    y = [{} for i in range(100000)]

foo()

objgraph.show_growth()

输出：

top 10 lines:
/home/user/miniconda3/envs/tf/lib/python3.8/site-packages/IPython/core/formatters.py:345: Co
/home/user/miniconda3/envs/tf/lib/python3.8/site-packages/ipykernel/zmqshell.py:540: .run_
/home/user/miniconda3/envs/tf/lib/python3.8/site-packages/IPython/core/interactiveshell.py
...
15657 objcts (+15657 fr lst tm) whch ncreases the memry used by a mxfm of 1.23 MB. #(included *new* objcts only, didnt track > 0.1% of 8.97 GB heap)

其中，top 10 lines表示前10行的代码，即导致内存增长的代码；15657 objects表示新创建的对象数；1.23 MB表示新创建的对象所占用的内存空间大小。

方法七：使用tracemalloc

tracemalloc是Python自带的一个内存分析模块。其基本使用方法如下：

import tracemalloc

tracemalloc.start()

# your code here

snapshot = tracemalloc.take_snapshot()

top_stats = snapshot.statistics('lineno')

print("[ Top 10 ]")
for stat in top_stats[:10]:
    print(stat)

其中，start()方法会开启内存分析，take_snapshot()方法会生成一个内存快照，statistics('lineno')方法会返回按照代码行号排序的内存使用情况统计信息。

下面通过一个示例说明如何使用tracemalloc来分析内存使用情况。

import tracemalloc

def foo():
    x = [{} for i in range(10000)]
    y = [{} for i in range(100000)]

tracemalloc.start()
foo()
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
print("[ Top 10 ]")
for stat in top_stats[:10]:
    print(stat)

输出：

[ Top 10 ]
/home/user/testing.py:4: size=1452 KiB, count=100000, average=15 B
/home/user/testing.py:3: size=125 KiB, count=10000, average=13 B
/home/user/miniconda3/envs/tf/lib/python3.8/traceback.py:183: size=195 B, count=1, ave
/home/user/miniconda3/envs/tf/lib/python3.8/threading.py:896: size=128 B, count=1, aver
/home/user/miniconda3/envs/tf/lib/python3.8/threading.py:992: size=96 B, count=2, aver
/home/user/miniconda3/envs/tf/lib/python3.8/site-packages/IPython/core/interactiveshe
/home/user/miniconda3/envs/tf/lib/python3.8/site-packages/ipykernel/zmqshell.py:457
...

其中，size表示占用内存的大小；count表示占用内存的对象数量；average表示占用内存的对象平均大小。

方法八：使用gc

Python自带的gc模块可以帮助我们监测内存泄漏和垃圾回收情况。其基本使用方法如下：

import gc

gc.set_debug(gc.DEBUG_LEAK)

# your code here

gc.collect()

其中，set_debug()方法会将gc模块的调试信息打开，collet()方法会强制进行垃圾回收。

下面通过一个例子说明如何使用gc来监测内存泄漏。

import gc

class A:
    pass

class B:
    def __init__(self):
        self.a = A()

gc.set_debug(gc.DEBUG_LEAK)

b = B()
del b
gc.collect()

print(gc.garbage)

输出：

[<__main__.A object at 0x7fd080aac580>]

其中，gc.garbage表示收集不到的数据。

方法九：使用sys.getsizeof

Python自带的sys模块中可以使用getsizeof()方法来获取对象占用内存的大小。其基本使用方法如下：

import sys

print(f"Memory usage: {sys.getsizeof(obj)}")

下面通过一个示例说明如何使用sys.getsizeof来测试对象占用内存大小。

import sys

s = "hello world"
l = [i for i in range(100)]
d = {"key": "value"}

print(f"Memory usage of string: {sys.getsizeof(s)} bytes")
print(f"Memory usage of list: {sys.getsizeof(l)} bytes")
print(f"Memory usage of dict: {sys.getsizeof(d)} bytes")

输出：

Memory usage of string: 58 bytes
Memory usage of list: 904 bytes
Memory usage of dict: 240 bytes

方法十：使用pympler

pympler是一个Python开发中的性能监测工具，它可以监测Python代码的内存使用情况和资源开销。其基本使用方法如下：

from pympler import asizeof

print(f"Memory usage: {asizeof.asizeof(obj)}")

下面通过一个示例说明如何使用pympler来测试对象的占用空间大小。

from pympler import asizeof

s = "hello world"
l = [i for i in range(100)]
d = {"key": "value"}

print(f"Memory usage of string: {asizeof.asizeof(s)} bytes")
print(f"Memory usage of list: {asizeof.asizeof(l)} bytes")
print(f"Memory usage of dict: {asizeof.asizeof(d)} bytes")

输出：

Memory usage of string: 181 bytes
Memory usage of list: 1048 bytes
Memory usage of dict: 184 bytes

到此，本文介绍的10种Python程序运行时间、CPU和内存占用的方法就介绍完毕了。读者可以根据具体情况选择适合自己的方法来检测程序运行情况。