blocks|key|1030973|text|如果您正在分析您的代码，并且可以使用IPython，那么它具有神奇的函数%25timeit。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1030974|%25%25timeit对细胞进行操作。|1030975|In+[2]:+%25timeit+cos(3.14)
10000000+loops,+best+of+3:+160+ns+per+loop

In+[3]:+%25%25timeit
+++...:+cos(3.14)
+++...:+x+=+2+%2B+3
+++...:+
10000000+loops,+best+of+3:+196+ns+per+loop|code-block|syntax|javascript|1030976|entityMap^0|10|7|0|0|8|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

If you are profiling your code and can use IPython, it has the magic function <code>%timeit</code>.

<code>%%timeit</code> operates on cells.

<pre><code>In [2]: %timeit cos(3.14)
10000000 loops, best of 3: 160 ns per loop

In [3]: %%timeit
 ...: cos(3.14)
 ...: x = 2 + 3
 ...: 
10000000 loops, best of 3: 196 ns per loop
</code></pre>

blocks|key|1246020|text|我看到这个问题已经得到了回答，但还是想补充一下我的2美分。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1246021|我也遇到过类似的情况，我必须测试几种方法的执行时间，因此编写了一个小脚本，对其中编写的所有函数调用timeit。|1246022|该脚本也可以作为github+gist+here使用。|offset|length|1246023|希望它能帮助你和其他人。|1246024|from+random+import+random
import+types

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

def+list_with_comprehension():
++++#+1K+random+numbers+between+0+to+100
++++l+=+[int(random()*100+%25+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%2B")

++++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:+%25(funcname)s"
python+-m+timeit+"import+timeit_demo;+timeit_demo.%25(funcname)s();"\n\n
echo+"------------------------------------------------------------"
'''+%25+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")|code-block|syntax|javascript|1246025|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/abhijitmamarde/0af8c54bfff21c6a3d65^0|0|0|K|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I see the question has already been answered, but still want to add my 2 cents for the same.

I have also faced similar scenario in which I have to test the execution times for several approaches and hence written a small script, which calls timeit on all functions written in it.

The script is also available as github gist <a href="https://gist.github.com/abhijitmamarde/0af8c54bfff21c6a3d65" rel="nofollow noreferrer">here</a>.

Hope it will help you and others.

<pre><code>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")
</code></pre>

blocks|key|1246082|text|这里有一个对steven答案的简单包装。这个函数不会重复运行/求平均值，只是让你不必到处重复计时代码:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1246083|'''function+which+prints+the+wall+time+it+takes+to+execute+the+given+command'''
def+time_func(func,+*args):+#*args+can+take+0+or+more+
++import+time
++start_time+=+time.time()
++func(*args)
++end_time+=+time.time()
++print("it+took+this+long+to+run:+{}".format(end_time-start_time))|code-block|syntax|javascript|1246084|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a simple wrapper for steven's answer. This function doesn't do repeated runs/averaging, just saves you from having to repeat the timing code everywhere :)

<pre><code>'''function which prints the wall time it takes to execute the given command'''
def time_func(func, *args): #*args can take 0 or more 
 import time
 start_time = time.time()
 func(*args)
 end_time = time.time()
 print("it took this long to run: {}".format(end_time-start_time))
</code></pre>

blocks|key|1031118|text|测试套件没有尝试使用导入的timeit，因此很难判断其意图是什么。尽管如此，这是一个规范的答案，因此详细说明Martijn's+answer的完整timeit示例似乎是正确的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1031119|docs+for+timeit提供了许多值得查看的示例和标志。命令行上的基本用法是：|1031120|$+python+-mtimeit+"all(True+for+_+in+range(1000))"
2000+loops,+best+of+5:+161+usec+per+loop
$+python+-mtimeit+"all([True+for+_+in+range(1000)])"
2000+loops,+best+of+5:+116+usec+per+loop|code-block|syntax|javascript|1031121|使用-h运行以查看所有选项。Python+MOTW在timeit上有一个很棒的部分，它展示了如何从命令行通过导入和多行代码字符串运行模块。|1031122|在脚本形式中，我通常这样使用它：|1031123|import+argparse
import+copy
import+dis
import+inspect
import+random
import+sys
import+timeit

def+test_slice(L):
++++L[:]

def+test_copy(L):
++++L.copy()

def+test_deepcopy(L):
++++copy.deepcopy(L)

if+__name__+==+"__main__":
++++parser+=+argparse.ArgumentParser()
++++parser.add_argument("--n",+type=int,+default=10+**+5)
++++parser.add_argument("--trials",+type=int,+default=100)
++++parser.add_argument("--dis",+action="store_true")
++++args+=+parser.parse_args()
++++n+=+args.n
++++trials+=+args.trials
++++namespace+=+dict(L+=+random.sample(range(n),+k=n))
++++funcs_to_test+=+[x+for+x+in+locals().values()+
+++++++++++++++++++++if+callable(x)+and+x.__module__+==+__name__]
++++print(f"{'-'+*+30}\nn+=+{n},+{trials}+trials\n{'-'+*+30}\n")

++++for+func+in+funcs_to_test:
++++++++fname+=+func.__name__
++++++++fargs+=+",+".join(inspect.signature(func).parameters)
++++++++stmt+=+f"{fname}({fargs})"
++++++++setup+=+f"from+__main__+import+{fname}"
++++++++time+=+timeit.timeit(stmt,+setup,+number=trials,+globals=namespace)
++++++++print(inspect.getsource(globals().get(fname)))

++++++++if+args.dis:
++++++++++++dis.dis(globals().get(fname))

++++++++print(f"time+(s)+=>+{time}\n{'-'+*+30}\n")|1031124|您可以很容易地插入所需的函数和参数。在使用impure+functions时要小心，并注意状态。|1031125|示例输出：|1031126|$+python+benchmark.py+--n+10000
------------------------------
n+=+10000,+100+trials
------------------------------

def+test_slice(L):
++++L[:]

time+(s)+=>+0.015502399999999972
------------------------------

def+test_copy(L):
++++L.copy()

time+(s)+=>+0.01651419999999998
------------------------------

def+test_deepcopy(L):
++++copy.deepcopy(L)

time+(s)+=>+2.136012
------------------------------|1031127|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/36237455/6243352|1|https://docs.python.org/3/library/timeit.html|2|https://pymotw.com/3/timeit/|3|https://en.wikipedia.org/wiki/Pure_function^0|D|6|21|6|1I|G|0|0|9|6|0|F|1|0|0|2|2|Q|6|E|B|2|0|0|0|L|G|3|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|F|3|G|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@$9|1N|A|1O|1|1P]]|E|$]]|$1|H|3|I|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@$9|1W|A|1X|1|1Y]]|E|$]]|$1|O|3|P|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|20|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|21|8|@]|D|@$9|22|A|23|1|24]]|E|$]]|$1|U|3|V|5|6|7|25|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|26|8|@]|D|@]|E|$K|L]]|$1|Y|3|-4|5|6|7|27|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]|16|$5|11|12|13|E|$14|17]]|18|$5|11|12|13|E|$14|19]]|1A|$5|11|12|13|E|$14|1B]]]]

The testing suite doesn't make an attempt at using the imported <code>timeit</code> so it's hard to tell what the intent was. Nonetheless, this is a canonical answer so a complete example of <code>timeit</code> seems in order, elaborating on <a href="https://stackoverflow.com/a/36237455/6243352">Martijn's answer</a>.
The <a href="https://docs.python.org/3/library/timeit.html" rel="nofollow noreferrer">docs for <code>timeit</code></a> offer many examples and flags worth checking out. The basic usage on the command line is:
<pre class="lang-none prettyprint-override"><code>$ python -mtimeit &quot;all(True for _ in range(1000))&quot;
2000 loops, best of 5: 161 usec per loop
$ python -mtimeit &quot;all([True for _ in range(1000)])&quot;
2000 loops, best of 5: 116 usec per loop
</code></pre>
Run with <code>-h</code> to see all options. <a href="https://pymotw.com/3/timeit/" rel="nofollow noreferrer">Python MOTW</a> has a great section on <code>timeit</code> that shows how to run modules via import and multiline code strings from the command line.
In script form, I typically use it like this:
<pre><code>import argparse
import copy
import dis
import inspect
import random
import sys
import timeit

def test_slice(L):
 L[:]

def test_copy(L):
 L.copy()

def test_deepcopy(L):
 copy.deepcopy(L)

if __name__ == &quot;__main__&quot;:
 parser = argparse.ArgumentParser()
 parser.add_argument(&quot;--n&quot;, type=int, default=10 ** 5)
 parser.add_argument(&quot;--trials&quot;, type=int, default=100)
 parser.add_argument(&quot;--dis&quot;, action=&quot;store_true&quot;)
 args = parser.parse_args()
 n = args.n
 trials = args.trials
 namespace = dict(L = random.sample(range(n), k=n))
 funcs_to_test = [x for x in locals().values() 
 if callable(x) and x.__module__ == __name__]
 print(f&quot;{'-' * 30}\nn = {n}, {trials} trials\n{'-' * 30}\n&quot;)

 for func in funcs_to_test:
 fname = func.__name__
 fargs = &quot;, &quot;.join(inspect.signature(func).parameters)
 stmt = f&quot;{fname}({fargs})&quot;
 setup = f&quot;from __main__ import {fname}&quot;
 time = timeit.timeit(stmt, setup, number=trials, globals=namespace)
 print(inspect.getsource(globals().get(fname)))

 if args.dis:
 dis.dis(globals().get(fname))

 print(f&quot;time (s) =&gt; {time}\n{'-' * 30}\n&quot;)
</code></pre>
You can pretty easily drop in the functions and arguments you need. Use caution when using <a href="https://en.wikipedia.org/wiki/Pure_function" rel="nofollow noreferrer">impure functions</a> and take care of state.
Sample output:
<pre class="lang-none prettyprint-override"><code>$ python benchmark.py --n 10000
------------------------------
n = 10000, 100 trials
------------------------------

def test_slice(L):
 L[:]

time (s) =&gt; 0.015502399999999972
------------------------------

def test_copy(L):
 L.copy()

time (s) =&gt; 0.01651419999999998
------------------------------

def test_deepcopy(L):
 copy.deepcopy(L)

time (s) =&gt; 2.136012
------------------------------
</code></pre>

blocks|key|1246165|text|另一个简单的timeit示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1246166|def+your_function_to_test():
+++#+do+some+stuff...

time_to_run_100_times+=+timeit.timeit(lambda:+your_function_to_test,+number=100)|code-block|syntax|javascript|1246167|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another simple timeit example:
<pre class="lang-py prettyprint-override"><code>def your_function_to_test():
 # do some stuff...

time_to_run_100_times = timeit.timeit(lambda: your_function_to_test, number=100)
</code></pre>

blocks|key|1246205|text|以下是如何使用timeit对函数计时的示例|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1246206|import+timeit

def+time_this():
++++return+[str(i)+for+i+in+range(5000)]

timeit.timeit(time_this,+number=1000)|code-block|syntax|javascript|1246207|这将返回执行time_this()函数1000次所用的时间(秒)。|1246208|entityMap^0|7|6|0|0|6|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Here is an example of how to time a function using <code>timeit</code>:
<pre><code>import timeit

def time_this():
 return [str(i) for i in range(5000)]

timeit.timeit(time_this, number=1000)
</code></pre>
This will return the time in seconds it took to execute the <code>time_this()</code> function 1000 times.

I've a python script which works just as it should, but I need to write the execution time. I've googled that I should use <a href="https://docs.python.org/2/library/timeit.html" rel="noreferrer"><code>timeit</code></a> but I can't seem to get it to work.

My Python script looks like this:

<pre><code>import sys
import getopt
import timeit
import random
import os
import re
import ibm_db
import time
from string import maketrans
myfile = open("results_update.txt", "a")

for r in range(100):
 rannumber = random.randint(0, 100)

 update = "update TABLE set val = %i where MyCount &gt;= '2010' and MyCount &lt; '2012' and number = '250'" % rannumber
 #print rannumber

 conn = ibm_db.pconnect("dsn=myDB","usrname","secretPWD")

for r in range(5):
 print "Run %s\n" % r 
 ibm_db.execute(query_stmt)
 query_stmt = ibm_db.prepare(conn, update)

myfile.close()
ibm_db.close(conn)
</code></pre>

What I need is the time it takes to execute the query and write it to the file <code>results_update.txt</code>. The purpose is to test an update statement for my database with different indexes and tuning mechanisms.

How can I time a code segment for testing performance with Pythons timeit?

数据库

Python

我有一个python脚本，它可以正常工作，但我需要编写执行时间。我在谷歌上搜索过我应该使用，但我似乎不能让它工作。我的Python脚本如下所示：import sysimport getoptimport timeitimport randomimport osimport reimport ibm_dbimport t...

问如何使用Pythons timeit对代码段进行计时以测试性能？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用Pythons timeit对代码段进行计时以测试性能？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用Pythons timeit对代码段进行计时以测试性能？
EN