您可以在要计时的块前后使用time.time()或time.clock()。

import time

t0 = time.time()
code_block
t1 = time.time()

total = t1-t0

这个方法不像timeit那样精确(它不平均几次运行)，但它很简单。

time.time()(在Windows和Linux中)和time.clock()(在Linux中)对于快速函数来说不够精确(你得到total = 0)。在这种情况下，或者如果你想通过几次运行来平均时间，你必须手动多次调用函数(我认为你已经在你的示例代码中这样做了，当你设置它的number参数时，timeit会自动执行)

import time

def myfast():
   code

n = 10000
t0 = time.time()
for i in range(n): myfast()
t1 = time.time()

total_n = t1-t0

在Windows中，正如Corey在评论中所述，time.clock()具有更高的精度(微秒而不是秒)，并且比time.time()更受欢迎。

专注于一件具体的事情。磁盘I/O很慢，所以如果您要调整的只是数据库查询，我就把它从测试中去掉。

如果您需要计算数据库执行的时间，请寻找数据库工具，例如询问查询计划，并注意性能不仅随确切的查询和您拥有的索引而变化，还随数据负载(您存储了多少数据)而变化。

也就是说，你可以简单地把你的代码放在一个函数中，并使用time .timeit()运行该函数:

def function_to_repeat():
    # ...

duration = timeit.timeit(function_to_repeat, number=1000)

这将禁用垃圾收集，重复调用function_to_repeat()函数，并使用timeit.default_timer()计算这些调用的总持续时间，这是特定平台可用的最准确的时钟。

你应该把设置代码移出重复函数;例如，您应该首先连接到数据库，然后仅计时查询。使用setup参数导入或创建这些依赖项，并将它们传递到你的函数中:

def function_to_repeat(var1, var2):
    # ...

duration = timeit.timeit(
    'function_to_repeat(var1, var2)',
    'from __main__ import function_to_repeat, var1, var2', 
    number=1000)

将从脚本中抓取全局函数to_repeat, var1和var2，并将它们每次重复传递给函数。

我看到这个问题已经有了答案，但我仍然想补充我的2美分。

我也遇到过类似的情况，我必须测试几种方法的执行时间，因此写了一个小脚本，在其中编写的所有函数上调用timeit。

该脚本也可作为github gist在这里。

希望对你和其他人有所帮助。

from random import random
import types

def list_without_comprehension():
    l = []
    for i in xrange(1000):
        l.append(int(random()*100 % 100))
    return l

def list_with_comprehension():
    # 1K random numbers between 0 to 100
    l = [int(random()*100 % 100) for _ in xrange(1000)]
    return l


# operations on list_without_comprehension
def sort_list_without_comprehension():
    list_without_comprehension().sort()

def reverse_sort_list_without_comprehension():
    list_without_comprehension().sort(reverse=True)

def sorted_list_without_comprehension():
    sorted(list_without_comprehension())


# operations on list_with_comprehension
def sort_list_with_comprehension():
    list_with_comprehension().sort()

def reverse_sort_list_with_comprehension():
    list_with_comprehension().sort(reverse=True)

def sorted_list_with_comprehension():
    sorted(list_with_comprehension())


def main():
    objs = globals()
    funcs = []
    f = open("timeit_demo.sh", "w+")

    for objname in objs:
        if objname != 'main' and type(objs[objname]) == types.FunctionType:
            funcs.append(objname)
    funcs.sort()
    for func in funcs:
        f.write('''echo "Timing: %(funcname)s"
python -m timeit "import timeit_demo; timeit_demo.%(funcname)s();"\n\n
echo "------------------------------------------------------------"
''' % dict(
                funcname = func,
                )
            )

    f.close()

if __name__ == "__main__":
    main()

    from os import system

    #Works only for *nix platforms
    system("/bin/bash timeit_demo.sh")

    #un-comment below for windows
    #system("cmd timeit_demo.sh")

撇开时间不提，您所显示的代码完全不正确:执行100个连接(完全忽略除最后一个连接外的所有连接)，然后在执行第一个执行调用时，向它传递一个局部变量query_stmt，该变量仅在执行调用之后才初始化。

首先，让你的代码正确，不要担心时间:即一个函数建立或接收一个连接，并在该连接上执行100或500或任意数量的更新，然后关闭连接。一旦您的代码正常工作，就应该考虑在它上使用timeit !

具体来说，如果你想计时的函数是一个叫做foobar的无参数函数，你可以使用timeit。Timeit(2.6或更高版本——2.5和之前版本更复杂):

timeit.timeit('foobar()', number=1000)

从3.5开始，globals形参使得timeit可以直接用于带形参的函数:

timeit.timeit('foobar(x,y)', number=1000, globals = globals())

您最好指定运行次数，因为对于您的用例来说，默认的100万可能太高了(导致在这段代码中花费大量时间;-)。

您可以在要计时的块前后使用time.time()或time.clock()。

import time

t0 = time.time()
code_block
t1 = time.time()

total = t1-t0

这个方法不像timeit那样精确(它不平均几次运行)，但它很简单。

time.time()(在Windows和Linux中)和time.clock()(在Linux中)对于快速函数来说不够精确(你得到total = 0)。在这种情况下，或者如果你想通过几次运行来平均时间，你必须手动多次调用函数(我认为你已经在你的示例代码中这样做了，当你设置它的number参数时，timeit会自动执行)

import time

def myfast():
   code

n = 10000
t0 = time.time()
for i in range(n): myfast()
t1 = time.time()

total_n = t1-t0

在Windows中，正如Corey在评论中所述，time.clock()具有更高的精度(微秒而不是秒)，并且比time.time()更受欢迎。

另一个简单的timeit例子:

def your_function_to_test():
   # do some stuff...

time_to_run_100_times = timeit.timeit(lambda: your_function_to_test, number=100)