以下是一个答案，使用：

对代码片段进行计时的简洁上下文管理器time.perf_counter（）计算时间增量。与time.time（）相反，它是不可调整的（sysadmin和守护程序都不能更改其值），因此应该首选它（参见文档）python3.10+（因为键入，但可以很容易地适应以前的版本）

import time
from contextlib import contextmanager
from typing import Iterator

@contextmanager
def time_it() -> Iterator[None]:
    tic: float = time.perf_counter()
    try:
        yield
    finally:
        toc: float = time.perf_counter()
        print(f"Computation time = {1000*(toc - tic):.3f}ms")

如何使用它的示例：

# Example: vector dot product computation
with time_it():
    A = B = range(1000000)
    dot = sum(a*b for a,b in zip(A,B))
# Computation time = 95.353ms

附录

import time

# to check adjustability
assert time.get_clock_info('time').adjustable
assert time.get_clock_info('perf_counter').adjustable is False

测量小代码片段的执行时间。

时间单位：以秒为单位，以浮点数表示

import timeit
t = timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))')
t.timeit()
t.repeat()
>[1.2934070999999676, 1.3335035000000062, 1.422568500000125]

repeat（）方法可以方便地多次调用timeit（）并返回结果列表。重复（重复=3）¶有了这个列表，我们可以计算所有时间的平均值。默认情况下，timeit（）在计时期间暂时关闭垃圾收集。time.Timer（）解决了这个问题。赞成的意见：timeit.Timer（）使独立计时更具可比性。gc可能是被测函数性能的重要组成部分。如果是，gc（垃圾收集器）可以作为设置字符串中的第一条语句重新启用。例如：timeit.Timer（'li=列表（映射（lambda x:x*2，[1，2，3，4，5]）'，设置='gc.enable（）'）

源Python文档！

时间也可以通过%timeit魔法函数测量，如下所示：

%timeit -t -n 1 print("hello")

n 1仅用于运行功能1次。

这里有一个很好的文档记录和完全类型提示的装饰器，我将其用作通用工具：

from functools import wraps
from time import perf_counter
from typing import Any, Callable, Optional, TypeVar, cast

F = TypeVar("F", bound=Callable[..., Any])


def timer(prefix: Optional[str] = None, precision: int = 6) -> Callable[[F], F]:
    """Use as a decorator to time the execution of any function.

    Args:
        prefix: String to print before the time taken.
            Default is the name of the function.
        precision: How many decimals to include in the seconds value.

    Examples:
        >>> @timer()
        ... def foo(x):
        ...     return x
        >>> foo(123)
        foo: 0.000...s
        123
        >>> @timer("Time taken: ", 2)
        ... def foo(x):
        ...     return x
        >>> foo(123)
        Time taken: 0.00s
        123

    """
    def decorator(func: F) -> F:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            nonlocal prefix
            prefix = prefix if prefix is not None else f"{func.__name__}: "
            start = perf_counter()
            result = func(*args, **kwargs)
            end = perf_counter()
            print(f"{prefix}{end - start:.{precision}f}s")
            return result
        return cast(F, wrapper)
    return decorator

示例用法：

from timer import timer


@timer(precision=9)
def takes_long(x: int) -> bool:
    return x in (i for i in range(x + 1))


result = takes_long(10**8)
print(result)

输出：耗时：4.942629056秒真的

可以通过以下方式检查doctest：

$ python3 -m doctest --verbose -o=ELLIPSIS timer.py

类型提示：

$ mypy timer.py

给定要计时的函数，

测试.py：

def foo(): 
    # print "hello"   
    return "hello"

使用timeit的最简单方法是从命令行调用它：

% python -mtimeit -s'import test' 'test.foo()'
1000000 loops, best of 3: 0.254 usec per loop

不要尝试使用time.time或time.clock（天真地）来比较函数的速度。他们会给出误导性的结果。

PS.不要将打印语句放在您希望计时的函数中；否则测量的时间将取决于终端的速度。

我更喜欢这个。timeit医生太令人困惑了。

from datetime import datetime 

start_time = datetime.now() 

# INSERT YOUR CODE 

time_elapsed = datetime.now() - start_time 

print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))

注意，这里没有进行任何格式化，我只是在打印输出中写入hh:mm:ss，以便可以解释time_elapsed