仅Python 3：

由于从Python 3.3开始，time.cclock（）已被弃用，因此您将希望使用time.perf_counter（）进行系统范围的计时，或使用time.process_time（）进行进程范围的计时（就像您以前使用time.cclok（）的方式一样）：

import time

t = time.process_time()
#do some stuff
elapsed_time = time.process_time() - t

新函数process_time将不包括睡眠期间经过的时间。

使用探查器模块。它提供了非常详细的概况。

import profile
profile.run('main()')

它输出类似于：

          5 function calls in 0.047 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 :0(exec)
        1    0.047    0.047    0.047    0.047 :0(setprofile)
        1    0.000    0.000    0.000    0.000 <string>:1(<module>)
        0    0.000             0.000          profile:0(profiler)
        1    0.000    0.000    0.047    0.047 profile:0(main())
        1    0.000    0.000    0.000    0.000 two_sum.py:2(twoSum)

我发现它很有启发性。

测量时间（秒）：

from timeit import default_timer as timer
from datetime import timedelta

start = timer()

# ....
# (your code runs here)
# ...

end = timer()
print(timedelta(seconds=end-start))

输出：

0:00:01.946339

使用一个上下文管理器可以很有趣地做到这一点，它可以自动记住进入with块时的开始时间，然后在块退出时冻结结束时间。通过一些小技巧，您甚至可以从同一个上下文管理器函数获得块内的运行时间计数。

核心库没有这个（但可能应该有）。一旦就位，您可以执行以下操作：

with elapsed_timer() as elapsed:
    # some lengthy code
    print( "midpoint at %.2f seconds" % elapsed() )  # time so far
    # other lengthy code

print( "all done at %.2f seconds" % elapsed() )

以下是足以完成此任务的contextmanager代码：

from contextlib import contextmanager
from timeit import default_timer

@contextmanager
def elapsed_timer():
    start = default_timer()
    elapser = lambda: default_timer() - start
    yield lambda: elapser()
    end = default_timer()
    elapser = lambda: end-start

以及一些可运行的演示代码：

import time

with elapsed_timer() as elapsed:
    time.sleep(1)
    print(elapsed())
    time.sleep(2)
    print(elapsed())
    time.sleep(3)

注意，通过设计此函数，elapsed（）的返回值在块退出时被冻结，并且进一步的调用返回相同的持续时间（在这个玩具示例中大约为6秒）。

以下是一个答案，使用：

对代码片段进行计时的简洁上下文管理器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

使用time.time（）测量两点之间经过的墙上时钟时间：

import time

start = time.time()
print("hello")
end = time.time()
print(end - start)

这给出了以秒为单位的执行时间。

Python 3.3之后的另一个选项可能是使用perf_counter或process_time，具体取决于您的需求。在3.3之前，建议使用time.clock（感谢Amber）。但是，它目前已被弃用：

在Unix上，将当前处理器时间作为浮点数返回以秒表示。准确度，事实上就是定义“处理器时间”的含义取决于C函数的含义具有相同名称。在Windows上，此函数返回自该函数的第一次调用，作为浮点数，基于Win32函数QueryPerformanceCounter（）。分辨率通常为优于一微秒。自3.3版起已弃用：此函数的行为取决于在平台上：改用perf_counter（）或process_time（），根据您的要求，要有明确的行为。