Pythonプログラムの実行時間を知るにはどうすればいいですか？
私はPythonでコマンドラインプログラムを持っています。走り終わるのにかかる正確な時間を知りたい。
私はtimeitモジュールを見ました、しかしそれはコードの小さな断片のためだけのようです。プログラム全体を計時したいのですが。
Pythonで最も簡単な方法は次のとおりです。
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
これはあなたのプログラムが走るのに少なくとも10分の1秒かかると仮定しています。
プリント：
--- 0.764891862869 seconds ---
このtiming.pyモジュールを自分のsite-packagesディレクトリに置き、私のモジュールの先頭にimport timingを挿入するだけです。
import atexit
from time import clock
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print line
print secondsToStr(clock()), '-', s
if elapsed:
print "Elapsed time:", elapsed
print line
print
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
start = clock()
atexit.register(endlog)
log("Start Program")
表示したいプログラム内に重要な段階がある場合は、プログラム内からtiming.logを呼び出すこともできます。しかし、import timingを含めると、開始時間と終了時間、および全体の経過時間が表示されます。 （私のあいまいなsecondsToStr関数はご容赦ください。浮動小数点数秒をhh：mm：ss.sss形式にフォーマットするだけです。）
LinuxまたはUNIXの場合
time python yourprogram.py
Windowsでは、このStackoverflowの説明を参照してください。 Windowsコマンドラインでコマンドの実行時間を測定する方法
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"
time.clock()はプロセッサ時間を返します。これにより、このプロセスで使われた時間だけを計算することができます（Unixではとにかく）。ドキュメントには、「いずれにせよ、これはPythonまたはタイミングアルゴリズムのベンチマークに使用する関数です」と書かれています。
私はPaul McGuireの答えがとても好きですが、私はPython 3を使います。それで、興味がある人のために：* nix上のPython 3で動作する彼の答えの修正があります（私は、Windowsの下で、そのclock（）がtime（）の代わりに使用されるべきであると思います）：
#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta
def secondsToStr(elapsed=None):
if elapsed is None:
return strftime("%Y-%m-%d %H:%M:%S", localtime())
else:
return str(timedelta(seconds=elapsed))
def log(s, elapsed=None):
line = "="*40
print(line)
print(secondsToStr(), '-', s)
if elapsed:
print("Elapsed time:", elapsed)
print(line)
print()
def endlog():
end = time()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
start = time()
atexit.register(endlog)
log("Start Program")
あなたがこれが役に立つと思うなら、彼がほとんどの仕事をしたように、あなたはまだこの答えの代わりに彼の答えを支持するべきです;）.
PythonプロファイラーcProfileを使用して、 CPU時間 、さらに各関数内で費やされた時間と各関数の呼び出し回数を測定できます。どこから始めればよいかわからずにスクリプトのパフォーマンスを向上させたい場合、これは非常に便利です。 この回答 別のSO質問への回答はかなり良いです。 docs もご覧になることをお勧めします。
コマンドラインからcProfileを使用してスクリプトをプロファイルする方法の例を示します。
$ python -m cProfile euler048.py
1007 function calls in 0.061 CPU seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.061 0.061 <string>:1(<module>)
1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>)
1 0.005 0.005 0.061 0.061 euler048.py:2(<module>)
1 0.000 0.000 0.061 0.061 {execfile}
1 0.002 0.002 0.053 0.053 {map}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects}
1 0.000 0.000 0.000 0.000 {range}
1 0.003 0.003 0.003 0.003 {sum}
私はdatetimeモジュールが提供する出力が好きです。時間デルタオブジェクトは必要に応じて日、時間、分などを人間が読める形式で表示します。
例えば：
from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
出力例.
Duration: 0:00:08.309267
または
Duration: 1 day, 1:51:24.269711
更新： J.J.F. Sebastianが述べたように、このアプローチは現地時間でいくつかの難しいケースに遭遇するかもしれないので、使うのがより安全です：
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
Linuxにとってさらに良いこと：/usr/bin/time
$ /usr/bin/time -v python rhtest2.py
Command being timed: "python rhtest2.py"
User time (seconds): 4.13
System time (seconds): 0.07
Percent of CPU this job got: 91%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 0
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 15
Minor (reclaiming a frame) page faults: 5095
Voluntary context switches: 27
Involuntary context switches: 279
Swaps: 0
File system inputs: 0
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0
通常、timeだけが、より有能な/usr/bin/timeを隠す、より単純なShell組み込みです。
Rogeriopvlの解決策はうまくいきますが、より具体的な情報が必要な場合はpython組み込みプロファイラーを使うことができます。このページをチェックしてください。
http://docs.python.org/library/profile.html
プロファイラーは、すべての機能に費やされた時間のような多くの役に立つ情報をあなたに伝えます
次のスニペットは、経過時間を人間が読める形式の<HH:MM:SS>形式で出力します。
import time
from datetime import timedelta
start_time = time.time()
#
# Perform lots of computations.
#
elapsed_time_secs = time.time() - start_time
msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))
print(msg)
時計（）
バージョン3.3以降廃止予定：この関数の振る舞いはプラットフォームに依存します：代わりに perf_counter（） または process_time（） を使用してください。明確な振る舞いをするため。
time.perf_counter（）
パフォーマンスカウンタの値（小数秒単位）を返します。つまり、短い期間を測定するために、利用可能な最も高い解像度のクロックです。それは します はスリープの間に経過した時間を含み、システム全体です。
time.process_time（）
現在のプロセスのシステムとユーザーCPU時間の合計の値（小数秒単位）を返します。 は含まれません /睡眠中に経過した時間は含まれません。
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)
Ipythonは任意のスクリプトを "timeit"します。
def foo():
%run bar.py
timeit foo()
私はtimeitモジュールを見ましたが、それはそれがコードの小さな断片のためだけのようです。プログラム全体を計時したいのですが。
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
your_module.main()関数を1回実行し、time.time()関数をタイマーとして使用して経過時間を表示します。
Pythonで/usr/bin/timeをエミュレートするには、 /usr/bin/timeによる/ - Pythonサブプロセスを参照してください。 。
各関数のCPU時間を測定するために（例えば、time.sleep()の間に時間を含めないで）、profileモジュール（Python 2ではcProfile）を使うことができます。
$ python3 -mprofile your_module.py
timeitモジュールが使用するのと同じタイマーを使用したい場合は、上記のprofileコマンドに-pを渡すことができます。
timeitモジュールを使うだけです。 Python 2とPython 3の両方で動作します。
import timeit
start = timeit.default_timer()
#ALL THE PROGRAM STATEMETNS
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time) #It returns time in sec
それは秒で戻り、あなたはあなたの実行時間を持つことができます。単純ですが、プログラムの実行を開始するMain Functionにこれらを書くべきです。エラーが発生しても実行時間を取得したい場合は、パラメータ "Start"をそれに渡して、次のように計算します。
def sample_function(start,**kwargs):
try:
#your statements
Except:
#Except Statements
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time)
私もPaul McGuireの答えが好きで、私のニーズに合ったコンテキストマネージャフォームを思い付きました。
import datetime as dt
import timeit
class TimingManager(object):
"""Context Manager used with the statement 'with' to time some execution.
Example:
with TimingManager() as t:
# Code to time
"""
clock = timeit.default_timer
def __enter__(self):
"""
"""
self.start = self.clock()
self.log('\n=> Start Timing: {}')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""
"""
self.endlog()
return False
def log(self, s, elapsed=None):
"""Log current time and elapsed time if present.
:param s: Text to display, use '{}' to format the text with
the current time.
:param elapsed: Elapsed time to display. Dafault: None, no display.
"""
print s.format(self._secondsToStr(self.clock()))
if(elapsed is not None):
print 'Elapsed time: {}\n'.format(elapsed)
def endlog(self):
"""Log time for the end of execution with elapsed time.
"""
self.log('=> End Timing: {}', self.now())
def now(self):
"""Return current elapsed time as hh:mm:ss string.
:return: String.
"""
return str(dt.timedelta(seconds = self.clock() - self.start))
def _secondsToStr(self, sec):
"""Convert timestamp to h:mm:ss string.
:param sec: Timestamp.
"""
return str(dt.datetime.fromtimestamp(sec))
Pythonコードの実行時間を計るために使用できるtimeitモジュールがあります。 Pythonドキュメント（ https://docs.python.org/2/library/timeit.html ）に詳細なドキュメントと例があります。
line_profiler を使用してください。
line_profilerは、コードの個々の行が実行にかかる時間をプロファイルします。プロファイラーは、プロファイリングのオーバーヘッドを減らすためにCythonを介してCに実装されています。
from line_profiler import LineProfiler
import random
def do_stuff(numbers):
s = sum(numbers)
l = [numbers[i]/43 for i in range(len(numbers))]
m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()
結果は次のようになります。
Timer unit: 1e-06 s
Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4 def do_stuff(numbers):
5 1 10 10.0 1.5 s = sum(numbers)
6 1 186 186.0 28.7 l = [numbers[i]/43 for i in range(len(numbers))]
7 1 453 453.0 69.8 m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
Jupyter Notebooksを使用しているデータ担当者のために
セルでは、Jupyterの%%timeマジックコマンドを使用して実行時間を測定できます。
%%time
[ x**2 for x in range(10000)]
出力
CPU時間：ユーザー4.54ミリ秒、sys：0 ns、合計：4.54 ms
実時間：4.12ミリ秒
これは特定のｾﾙの実行時間だけを捕獲するでしょう。ノートブック全体（プログラム）の実行時間を記録したい場合は、同じディレクトリに新しいノートブックを作成し、新しいノートブックにすべてのセルを実行します。
上記のノートブックがexample_notebook.ipynbと呼ばれるとします。同じディレクトリ内の新しいノートブックで：
# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb
# Run the example_notebook with -t flag for time
%run -t example_notebook
出力
IPython CPUタイミング（概算）：ユーザー：0.00秒.
システム：0.00秒。
所要時間：0.00秒。
これはPaul McGuireの答えです。万が一誰かがそれを実行するのに問題を抱えていました。
import atexit
from time import clock
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
value = next(it)
else:
value = initializer
for element in it:
value = function(value, element)
return value
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print (line)
print (secondsToStr(clock()), '-', s)
if elapsed:
print ("Elapsed time:", elapsed)
print (line)
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
def main():
start = clock()
atexit.register(endlog)
log("Start Program")
ファイルをインポートした後、プログラムからtiming.main()を呼び出します。
私は、コード実行の一部を計時するために非常に単純な関数を使いました。
import time
def timing():
start_time = time.time()
return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))
それを使用するには、タイミング関数を取得するために測定するコードの前にそれを呼び出してからコメント付きのコードの後に関数を呼び出すと、時間がコメントの前に表示されます。
t = timing()
train = pd.read_csv('train.csv',
dtype={
'id': str,
'vendor_id': str,
'pickup_datetime': str,
'dropoff_datetime': str,
'passenger_count': int,
'pickup_longitude': np.float64,
'pickup_latitude': np.float64,
'dropoff_longitude': np.float64,
'dropoff_latitude': np.float64,
'store_and_fwd_flag': str,
'trip_duration': int,
},
parse_dates = ['pickup_datetime', 'dropoff_datetime'],
)
t("Loaded {} rows data from 'train'".format(len(train)))
出力は次のようになります。
[9.35s] Loaded 1458644 rows data from 'train'
私はこのように少しエレガントに感じます。
Timeitは、小さなコードブロックの実行時間を計算するために使用されるpythonのクラスです。
Default_timerは、このクラスのメソッドで、CPUの実行時間ではなくウォールクロックのタイミングを測定するために使用されます。したがって、他のプロセスの実行がこれを妨げる可能性があります。したがって、小さなコードブロックに役立ちます。
コードのサンプルは次のとおりです。
from timeit import default_timer as timer
start= timer()
#some logic
end = timer()
print("Time taken:", end-start)
metakermitの最新の回答 をpython 2.7に使用するには、 monotonic パッケージが必要です。
その場合、コードは次のようになります。
from datetime import timedelta
from monotonic import monotonic
start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))
Pythonプログラムの実行時間は、以下によっては矛盾する可能性があります。
- 同じプログラムを異なるアルゴリズムで評価することができます
- 実行時間はアルゴリズムによって異なります
- 実行時間は実装によって異なります
- 実行時間はコンピューターによって異なります
- 実行時間は小さな入力に基づいて予測することはできません
これは、最も効果的な方法は、「成長の順序」を使用し、それを正しく行うためにBigの「O」表記法を学ぶことです、 https://en.wikipedia.org/wiki/Big_O_notation
とにかく、この単純なアルゴリズムを使用して、毎秒特定のマシンカウントステップで任意のPythonプログラムのパフォーマンスを評価しようとすることができます。これを評価したいプログラムに適応させます
import time
now = time.time()
future = now + 10
step = 4 # why 4 steps? because until here already 4 operations executed
while time.time() < future:
step += 3 # why 3 again? because while loop execute 1 comparison and 1 plus equal statement
step += 4 # why 3 more? because 1 comparison starting while when time is over plus final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")
これがお役に立てば幸いです。
あなたはPythonで非常に単純な方法を得ることができますそれほど複雑なことをする必要はありません。
import time start = time.localtime() end = time.localtime() """Total execution time in second$ """ print(end.tm_sec - start.tm_sec)
マイクロ秒単位で時間を測定したい場合は、 Paul McGuire および Nicojo - の回答に完全に基づいて次のバージョンを使用できます。これはPython 3コードです。私はまたそれにいくつかの色を追加しました：
import atexit
from time import time
from datetime import timedelta, datetime
def seconds_to_str(elapsed=None):
if elapsed is None:
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
else:
return str(timedelta(seconds=elapsed))
def log(txt, elapsed=None):
colour_cyan = '\033[36m'
colour_reset = '\033[0;0;39m'
colour_red = '\033[31m'
print('\n ' + colour_cyan + ' [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
if elapsed:
print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)
def end_log():
end = time()
elapsed = end-start
log("End Program", seconds_to_str(elapsed))
start = time()
atexit.register(end_log)
log("Start Program")
log（）=>タイミング情報を表示する関数。
txt ==>ログに記録する最初の引数。タイミングを示す文字列です。
atexit ==>プログラム終了時に呼び出せる関数を登録するためのpythonモジュール。
これは、プログラムの経過時間を取得する最も簡単な方法です：-
プログラムの最後に次のコードを記述します。
import time
print(time.clock())