以下是我在阅读了许多好答案以及其他几篇文章之后的发现。

首先，如果你在timeit和time.time之间进行辩论，timeit有两个优点：

timeit选择操作系统和Python版本上可用的最佳计时器。然而，timeit禁用垃圾收集，这不是您可能想要或不想要的。

现在的问题是，时间并不是那么简单，因为它需要设置，当你有大量的导入时，事情会变得很糟糕。理想情况下，您只需要一个装饰器或使用块和度量时间。不幸的是，没有内置功能可用于此，因此您有两个选项：

选项1：使用时间预算库

timebudget是一个多功能且非常简单的库，您可以在pip安装后仅在一行代码中使用它。

@timebudget  # Record how long this function takes
def my_method():
    # my code

选项2：使用我的小模块

我创建了一个名为timing.py的计时实用程序模块。只需将这个文件放到项目中并开始使用它。唯一的外部依赖是runstats，它同样很小。

现在，只需在函数前面放置一个装饰器，就可以对任何函数计时：

import timing

@timing.MeasureTime
def MyBigFunc():
    #do something time consuming
    for i in range(10000):
        print(i)

timing.print_all_timings()

如果您想对代码的一部分计时，只需将其放入块中：

import timing

#somewhere in my code

with timing.MeasureBlockTime("MyBlock"):
    #do something time consuming
    for i in range(10000):
        print(i)

# rest of my code

timing.print_all_timings()

优势：

有几个半备份版本，所以我想指出几个亮点：

出于前面描述的原因，请使用timeit中的计时器，而不是time.time。如果需要，可以在计时期间禁用GC。Decorator接受带有命名或未命名参数的函数。能够在块计时中禁用打印（与timing.MeasureBlockTime（）一起使用为t，然后为t.passed）。能够为块计时启用gc。

（仅使用Ipython）您可以使用%timeit来测量平均处理时间：

def foo():
    print "hello"

然后：

%timeit foo()

结果如下：

10000 loops, best of 3: 27 µs per loop

给定要计时的函数，

测试.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.不要将打印语句放在您希望计时的函数中；否则测量的时间将取决于终端的速度。

如果您想方便地对函数计时，可以使用一个简单的修饰符：

import time

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        original_return_val = func(*args, **kwargs)
        end = time.perf_counter()
        print("time elapsed in ", func.__name__, ": ", end - start, sep='')
        return original_return_val

    return wrapper

您可以在您希望计时的函数上使用它，如下所示：

@timing_decorator
def function_to_time():
    time.sleep(1)

function_to_time()

无论何时调用function_to_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 benchmark import benchmark

with benchmark("Test 1+1"):
    1+1
=>
Test 1+1 : 1.41e-06 seconds

或者，如果您需要时间值

with benchmark("Test 1+1") as b:
    1+1
print(b.time)
=>
Test 1+1 : 7.05e-07 seconds
7.05233786763e-07

基准.py：

from timeit import default_timer as timer

class benchmark(object):

    def __init__(self, msg, fmt="%0.3g"):
        self.msg = msg
        self.fmt = fmt

    def __enter__(self):
        self.start = timer()
        return self

    def __exit__(self, *args):
        t = timer() - self.start
        print(("%s : " + self.fmt + " seconds") % (self.msg, t))
        self.time = t

改编自http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html