Pythonで処理時間を測る方法|time・perf_counter・timeitの違い
「この処理、どれくらい時間がかかっているんだろう」「リスト内包表記と for 文、どちらが速い?」と思ったとき、Python では標準ライブラリだけで処理時間を測れます。ただし、測り方を間違えると「1 回目だけ遅かった」「画面表示の時間まで測っていた」といった理由で、まったく逆の結論を出してしまうことがあります。
この記事では、time.perf_counter() による基本の測り方、time.time() との違い、process_time()、timeit モジュールと py -m timeit、よくある間違いを実行結果つきで説明します。
載せている出力は、Windows 11・Core i7-13700F・Python 3.12.6 で実際に実行したものです。秒数は PC の性能や、そのとき動いているほかのアプリによって変わります。数字そのものより、差や傾向を読み取ってください。コードは sample.py などの名前で保存し、PowerShell でそのフォルダーに移動してから次のコマンドで実行できます。
py sample.py
処理時間を測る道具の一覧
先に全体像を表にまとめます。迷ったら「処理の前後を測るなら perf_counter、小さなコードの速さを比べるなら timeit」と覚えておけば十分です。
| 道具 | 測るもの | 向いている使い方 |
|---|---|---|
time.perf_counter() | 経過時間(いちばん細かい時計) | 処理の前後の差を測る。基本はこれ |
time.time() | 現在の時刻(1970 年からの秒数) | 「いつ起きたか」の記録。時間の計測には向かない |
time.monotonic() | 戻らないことが保証された経過時間 | タイムアウトなど、長めの時間の管理 |
time.process_time() | CPU が計算に使った時間 | 待ち時間(sleep や通信)を除いた計算の重さ |
timeit モジュール | 同じコードを何度も実行した時間 | 小さなコード同士の速さの比較 |
cProfile | 関数ごとの時間と呼び出し回数 | プログラムのどこが遅いかを探す |
基本:perf_counter() で前後の差を測る
いちばん基本の測り方は、処理の直前と直後に time.perf_counter()(性能を測るための時計)を呼び、その差を取る方法です。
import time
start = time.perf_counter()
total = sum(range(10_000_000))
elapsed = time.perf_counter() - start
print(f"合計: {total}")
print(f"かかった時間: {elapsed:.3f} 秒")
合計: 49999995000000
かかった時間: 0.073 秒
0 から 9,999,999 までの合計を計算するのに、この PC では約 0.073 秒かかりました。{elapsed:.3f} は「小数点以下 3 桁まで表示する」という f-string の書き方です。
perf_counter() が返す値そのもの(例:58601.68…)には意味がありません。公式ドキュメントにも「戻り値の基準点は定義されていないため、2 回呼び出した結果の差だけが有効」と書かれています。必ず「後 − 前」の差で使うと覚えてください。
time.time() と perf_counter() の違い
time.time() で時間を測る例もよく見かけますが、time.time() は「1970 年 1 月 1 日 0 時(UTC)から何秒たったか」という現在時刻(Unix 時間)を返す関数です。公式ドキュメントには「通常は減らない値を返すが、2 回の呼び出しの間にシステムの時計が戻されると、前回より小さい値を返すことがある」とあります。測っている最中に時計が自動で修正されると、経過時間がずれたりマイナスになったりする可能性があります。
一方、perf_counter() は「短い時間を測るための、利用できる中でいちばん分解能が高い時計」と説明されています。分解能とは「どれだけ細かく刻めるか」のことです。時計の性質は time.get_clock_info() で確かめられます。
import time
for name in ("time", "perf_counter", "monotonic", "process_time"):
info = time.get_clock_info(name)
print(f"{name:13} monotonic={info.monotonic!s:5} adjustable={info.adjustable!s:5} resolution={info.resolution}")
time monotonic=False adjustable=True resolution=0.015625
perf_counter monotonic=True adjustable=False resolution=1e-07
monotonic monotonic=True adjustable=False resolution=0.015625
process_time monotonic=True adjustable=False resolution=1e-07
monotonic は「値が戻らない」か、adjustable は「時刻合わせで値が変わる」か、resolution は分解能(秒)です。1e-07 は 0.1 マイクロ秒、0.015625 は約 15.6 ミリ秒を表します。time は「戻ることがあり、合わせ直される」時計、perf_counter は「戻らず、合わせ直されず、細かい」時計だと分かります。
monotonic の分解能が約 15.6 ミリ秒と粗い点にも注意が必要です。sum(range(10_000)) を monotonic で測ると 0.000000 秒、perf_counter では 0.000069 秒と出ました。値が進む前に処理が終わったのです。get_clock_info(name).implementation で調べると、この PC(Python 3.12)では monotonic が Windows の GetTickCount64()、perf_counter が QueryPerformanceCounter() を使っていました。Python 3.13 の公式ドキュメントでは、perf_counter が monotonic と同じ時計を使うように変わり、Windows の monotonic は QueryPerformanceCounter を使うと書かれています。短い処理は perf_counter で測り、monotonic はタイムアウトなど長めの時間の管理に使いましょう。
process_time():sleep を含まない CPU 時間
time.process_time() は、そのプログラムが CPU を使って計算していた時間(公式ドキュメントでは「現在のプロセスのシステム CPU 時間とユーザー CPU 時間の合計」)を返します。sleep で止まっている時間は含みません。1 秒の sleep と計算を組み合わせた処理を、3 つの時計で同時に測ってみます。
import time
def work():
time.sleep(1)
sum(range(10_000_000))
w0, p0, c0 = time.time(), time.perf_counter(), time.process_time()
work()
w1, p1, c1 = time.time(), time.perf_counter(), time.process_time()
print(f"time : {w1 - w0:.3f} 秒")
print(f"perf_counter : {p1 - p0:.3f} 秒")
print(f"process_time : {c1 - c0:.3f} 秒")
time : 1.070 秒
perf_counter : 1.070 秒
process_time : 0.062 秒
time と perf_counter は sleep の 1 秒を含む約 1.07 秒、process_time は計算した分の約 0.06 秒だけになりました。ファイルの読み込みやネットワークの待ち時間も、CPU が働いていない間は process_time に入りません。
体感の待ち時間を知りたいなら perf_counter、計算そのものの重さを知りたいなら process_time です。2 つの差が大きければ、その処理は「計算」より「待ち」に時間を使っています。待ち時間を減らす方法の 1 つが、関連記事の asyncio による同時待ちです。
ナノ秒で受け取る _ns 版
perf_counter・monotonic・process_time・time には、末尾に _ns が付いた版があり、ナノ秒(10 億分の 1 秒)単位の整数を返します。公式ドキュメントでは「float 型による精度の低下を避けるため」に使うと説明されています。float(小数)は大きな数になると細かい桁が丸められるためです。
たとえば start = time.perf_counter_ns() と end = time.perf_counter_ns() で 1,000 個のリストを作る処理をはさむと、end - start は 27200(ナノ秒、つまり 27.2 マイクロ秒)のような整数になりました。
単位の換算は、1 秒 = 1,000 ミリ秒(ms)= 1,000,000 マイクロ秒(μs、usec)= 1,000,000,000 ナノ秒(ns、nsec)です。ふだんは perf_counter() で困ることはほとんどなく、ログに整数で残したいときなどに _ns 版を使います。
with 文やデコレーターで測る小道具を作る
測りたい場所が何か所もあると、start と elapsed を毎回書くのは面倒です。with 文で囲むだけで測れる timer と、関数に付けるだけで測れる @timed を作っておくと便利です。
import functools
import time
from contextlib import contextmanager
@contextmanager
def timer(label):
start = time.perf_counter()
try:
yield
finally:
elapsed = time.perf_counter() - start
print(f"{label}: {elapsed:.3f} 秒")
def timed(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
try:
return func(*args, **kwargs)
finally:
elapsed = time.perf_counter() - start
print(f"{func.__name__}: {elapsed:.3f} 秒")
return wrapper
with timer("読み込み"):
lines = [f"{i},{i * 2}" for i in range(500_000)]
@timed
def parse(rows):
return [tuple(map(int, row.split(","))) for row in rows]
data = parse(lines)
print(len(data))
読み込み: 0.058 秒
parse: 0.156 秒
500000
どちらも try・finally で囲んでいるので、途中で例外が起きても時間は表示されます。with 文の仕組み(@contextmanager と yield)は「with 文とコンテキストマネージャー」の記事、functools.wraps や *args, **kwargs の意味は「デコレーター入門」の記事で詳しく説明しています。
1 回だけ測ると値が揺れる
同じ処理を 5 回続けて測ってみます。0〜999 の 2 乗のリストを作るだけの、1 回が数十マイクロ秒の処理です。
import time
def make_squares():
return [i * i for i in range(1000)]
for i in range(5):
start = time.perf_counter()
make_squares()
elapsed = time.perf_counter() - start
print(f"{i + 1} 回目: {elapsed * 1_000_000:.1f} マイクロ秒")
1 回目: 29.3 マイクロ秒
2 回目: 22.6 マイクロ秒
3 回目: 21.5 マイクロ秒
4 回目: 21.2 マイクロ秒
5 回目: 21.2 マイクロ秒
まったく同じ処理なのに、1 回目は 29.3 マイクロ秒、4 回目以降は 21.2 マイクロ秒と、約 1.4 倍の差がありました。3 回実行し直しても、1 回目が 29〜34 マイクロ秒、残りが 21〜23 マイクロ秒という傾向は同じでした。最初の 1 回だけ遅くなる原因はいくつか考えられ、ここでは特定していません。また、パソコンではほかのアプリや Windows 自体も動いているので、たまたま割り込まれて遅くなることもあります。
そこで使うのが、標準ライブラリの timeit です。同じコードを何千回・何万回と繰り返した合計時間を測り、それを何セットか繰り返して、いちばん速かったセットを結果にします。

timeit モジュールで正確に測る
timeit は小さなコード片の実行時間を測るためのモジュールで、時計には perf_counter が使われます(公式ドキュメントより)。関連記事の collections の解説でも、timeit で list.pop(0) と deque.popleft() の速さを比べています。
timeit.timeit():number 回の合計時間
timeit.timeit() には、測りたいコードを文字列で渡します。number は「何回繰り返すか」で、戻り値はその回数の合計時間(秒)です。1 回あたりではありません。
import timeit
t = timeit.timeit("[i * i for i in range(1000)]", number=10_000)
print(f"10,000 回の合計: {t:.4f} 秒")
print(f"1 回あたり: {t / 10_000 * 1_000_000:.2f} マイクロ秒")
10,000 回の合計: 0.2219 秒
1 回あたり: 22.19 マイクロ秒
number を省略すると、公式ドキュメントのとおり 100 万回繰り返します。timeit.timeit("sum(range(100))") は 0.34 秒前後でしたが、これは 100 万回の合計(1 回あたり約 0.34 マイクロ秒)です。重い処理を number なしで測ると、なかなか終わりません。
準備の処理は setup 引数に書くと、計測の前に 1 回だけ実行され、時間には含まれません。
timeit.repeat():何セットか測って最小値を見る
timeit.repeat() は、timeit を repeat 回(セット数)繰り返し、各セットの合計時間をリストで返します。
import timeit
results = timeit.repeat("[i * i for i in range(1000)]", number=10_000, repeat=5)
for r in results:
print(f"{r:.4f}")
best = min(results)
print(f"最小: {best:.4f} 秒 → 1 回あたり {best / 10_000 * 1_000_000:.2f} マイクロ秒")
0.2143
0.2130
0.2137
0.2131
0.2137
最小: 0.2130 秒 → 1 回あたり 21.30 マイクロ秒
なぜ平均ではなく最小値を使うのでしょうか。公式ドキュメントの repeat の説明には、おおむね次のように書かれています。「結果から平均や標準偏差を計算したくなるが、あまり役に立たない。多くの場合、最小値はその PC がそのコードを実行できる速さの下限を示し、大きい値は Python の速さのばらつきではなく、ほかのプロセスが計測を邪魔したことによるものが多い。注目すべきはおそらく min() だけで、そのうえで全体の値を見て、統計より常識で判断する」
邪魔が入ると遅くなることはあっても、速くなることはありません。だから「いちばん邪魔が少なかったセット」を代表値にするわけです。ただし、セットごとの値が大きくばらつくときは、計測中に重い処理が動いていた可能性があるので測り直しましょう。
なお、timeit は計測中にガベージコレクション(使わなくなったメモリの自動回収)を一時的に止めます。回収も含めて測りたいときは、setup の先頭に gc.enable() を書きます(公式ドキュメントより)。
自分の関数を測る:globals 引数と lambda
自分で定義した関数を timeit.timeit("squares_comp(1000)", number=10_000) のように文字列で渡すと、NameError: name 'squares_comp' is not defined というエラーになります。timeit は文字列を timeit モジュール専用の名前空間(名前の置き場所)で実行するため、自分のファイルの関数が見えないのです。globals=globals() を渡すと、自分のファイルの名前空間で実行されます。
import timeit
def squares_for(n):
result = []
for i in range(n):
result.append(i * i)
return result
def squares_comp(n):
return [i * i for i in range(n)]
for name in ("squares_for", "squares_comp"):
results = timeit.repeat(f"{name}(1000)", number=10_000, repeat=5, globals=globals())
print(f"{name:12}: {min(results) / 10_000 * 1_000_000:.2f} マイクロ秒")
squares_for : 24.38 マイクロ秒
squares_comp: 21.47 マイクロ秒
この PC では、for 文で append するより、リスト内包表記のほうが 1 割強速いという結果になりました。もう一度実行しても 24.68 と 21.26 で、ほぼ同じ差でした。文字列の代わりに timeit.timeit(lambda: squares_comp(1000), number=10_000) のように引数なしで呼べる関数を渡す書き方もでき、この場合は globals がなくても動きます(結果は 0.2149 秒でした)。
コマンドラインで測る:py -m timeit
ファイルを作らずに、コマンドラインからも測れます。
py -m timeit "[i * i for i in range(1000)]"
10000 loops, best of 5: 20.9 usec per loop
10000 loops は 1 セットで 10,000 回繰り返したこと(number)、best of 5 は 5 セット測っていちばん速いセットを採用したこと(repeat の既定値は 5)、20.9 usec per loop はそのセットの時間を回数で割った 1 回あたりの時間です。usec はマイクロ秒で、単位は処理の重さに合わせて自動で選ばれます。
ループ回数は自動で決まる
上の例では回数を指定していないのに 10000 loops になりました。公式ドキュメントによると、-n を指定しないときは 1, 2, 5, 10, 20, 50, … と回数を増やしながら試し、合計が 0.2 秒以上になる回数を使います。-v(詳しく表示)を付けると、その様子が見えます。
py -m timeit -v "[i * i for i in range(1000)]"
1 loop -> 3.01e-05 secs
2 loops -> 4.32e-05 secs
5 loops -> 0.000104 secs
(途中省略)
1000 loops -> 0.0208 secs
2000 loops -> 0.0422 secs
5000 loops -> 0.107 secs
10000 loops -> 0.214 secs
raw times: 213 msec, 210 msec, 211 msec, 220 msec, 211 msec
10000 loops, best of 5: 21 usec per loop
10000 回で初めて 0.2 秒を超えたので、number が 10000 に決まりました。続く raw times が 5 セットそれぞれの合計時間で、最小の 210 ミリ秒 ÷ 10,000 回 = 21 マイクロ秒が最後の行の値です。図 1 の右側は、このときの値を描いたものです。重い処理なら回数は少なくなり、たとえば sum(range(1_000_000)) では「50 loops, best of 5: 6.91 msec per loop」でした。
Python のコードでは timeit.Timer("コード").autorange() が同じ方法で回数を決めます(上の例では (10000, 0.212…) と、回数と合計時間を返しました)。
よく使うオプション
| オプション | 意味 | 例 |
|---|---|---|
-n N | 1 セットの回数(number) | -n 1000 |
-r N | セット数(repeat、既定は 5) | -r 3 |
-s S | 最初に 1 回だけ実行する準備(時間に含めない) | -s "import random" |
-u 単位 | 表示の単位(nsec / usec / msec / sec) | -u msec |
-p | process_time で測る | -p |
オプションの一覧は py -m timeit -h で表示できます。たとえば py -m timeit -s "import random; data = [random.random() for _ in range(10_000)]" "sorted(data)" で、ランダムな 1 万個の小数を並べ替える時間を測ると「500 loops, best of 5: 756 usec per loop」でした。PowerShell では、コード全体を「”」で囲み、中の文字列には「’」を使うと書きやすくなります。
よくある間違い
print を含めて測ってしまう
画面への表示は計算に比べてとても遅いので、測る範囲に print を入れると print の時間ばかり測ることになります。
import time
start = time.perf_counter()
total = 0
for i in range(1000):
total += i * i
calc = time.perf_counter() - start
start = time.perf_counter()
total = 0
for i in range(1000):
total += i * i
print(i, total)
with_print = time.perf_counter() - start
print(f"計算だけ : {calc * 1000:.3f} ミリ秒")
print(f"print 込み: {with_print * 1000:.3f} ミリ秒")
(途中の 1,000 行の表示は省略)
計算だけ : 0.050 ミリ秒
print 込み: 12.980 ミリ秒
この PC のコンソール画面で 3 回実行したところ、計算だけは約 0.05 ミリ秒、print 込みは 13〜14 ミリ秒で、250 倍以上の差になりました。表示の速さは使う画面(PowerShell、VS Code のターミナルなど)によっても変わります。結果の表示やログの出力は、測る範囲の外に出しましょう。
初回だけ遅いことに気づかない
「1 回だけ測ると値が揺れる」で見た 1 回目の遅さより、もっと極端な例もあります。関数の中で初めて import するときは、モジュールを読み込む時間がかかります。
import time
def load_json_module():
import json
return json.dumps({"a": 1})
for i in range(3):
start = time.perf_counter()
load_json_module()
print(f"{i + 1} 回目: {(time.perf_counter() - start) * 1_000_000:.1f} マイクロ秒")
1 回目: 12271.4 マイクロ秒
2 回目: 4.6 マイクロ秒
3 回目: 2.3 マイクロ秒
1 回目は約 12 ミリ秒、2 回目以降は数マイクロ秒で、2,000 倍以上の差です。2 回目以降は読み込み済みのモジュールが使い回されるためです。結果を覚えておくキャッシュ付きの関数も同じです。「アプリの起動直後の 1 回」が知りたいのか、「何度も呼んだときの速さ」が知りたいのかを決めてから測りましょう。
差が小さいものを 1 回の計測で判断する
timeit.repeat で測ると、for 文は 24 マイクロ秒台、リスト内包表記は 21 マイクロ秒台でした。では、これを perf_counter で 1 回ずつ測るとどうなるでしょうか。
import time
def squares_for(n):
result = []
for i in range(n):
result.append(i * i)
return result
def squares_comp(n):
return [i * i for i in range(n)]
for func in (squares_for, squares_comp):
start = time.perf_counter()
func(1000)
print(f"{func.__name__:12}: {(time.perf_counter() - start) * 1_000_000:.1f} マイクロ秒")
squares_for : 37.1 マイクロ秒
squares_comp: 23.4 マイクロ秒
for 文が 1.6 倍も遅いように見えます。ところが、最後の 2 行の順番を入れ替えて for func in (squares_comp, squares_for): にすると、結果は逆になりました。
squares_comp: 32.7 マイクロ秒
squares_for : 27.4 マイクロ秒
今度は内包表記のほうが遅く見えます。どちらの順番でも 3 回以上実行して同じ傾向でした。つまりこの 1 回だけの計測は、書き方の違いより「先に測ったほうが遅い」という影響のほうが大きいのです。数マイクロ秒〜数十マイクロ秒の差を比べるときは、必ず timeit で繰り返し測り、最小値で比べてください。
どこが遅いか分からないとき:cProfile
プログラム全体が遅いけれど、どの関数が原因か分からないときは、標準ライブラリの cProfile(プロファイラー)を使います。関数ごとの呼び出し回数と時間を一覧にしてくれます。次の prof.py を用意します。
def load():
return [f"{i},{i * 2}" for i in range(200_000)]
def parse(rows):
return [tuple(map(int, row.split(","))) for row in rows]
def total(data):
return sum(a + b for a, b in data)
print(total(parse(load())))
-s cumtime は「cumtime(その関数の中で呼んだ関数も含めた合計時間)の大きい順に並べる」という指定です。
py -m cProfile -s cumtime prof.py
59999700000
400009 function calls in 0.153 seconds
Ordered by: cumulative time
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.153 0.153 {built-in method builtins.exec}
1 0.005 0.005 0.153 0.153 prof.py:1(<module>)
1 0.086 0.086 0.105 0.105 prof.py:4(parse)
1 0.022 0.022 0.022 0.022 prof.py:1(load)
1 0.000 0.000 0.020 0.020 prof.py:7(total)
1 0.010 0.010 0.020 0.020 {built-in method builtins.sum}
200000 0.019 0.000 0.019 0.000 {method 'split' of 'str' objects}
200001 0.010 0.000 0.010 0.000 prof.py:8(<genexpr>)
(以下 2 行省略)
ncalls は呼び出し回数、tottime はその関数だけの時間(中で呼んだ関数を除く)、cumtime は中で呼んだ関数も含めた時間です。全体 0.153 秒のうち parse が 0.105 秒を占めていて、ここを直すのがいちばん効果的だと分かります。
なお、公式ドキュメントには「プロファイラーは実行のようすを調べるためのもので、ベンチマーク(速さの比較)のためのものではない」とあり、比較には timeit を使うよう案内されています。cProfile は計測のための処理が加わるので、時間は普段より少し長めに出ます。遅い場所を cProfile で見つけ、直した前後を timeit で比べるとよいでしょう。
まとめ
- 経過時間は
time.perf_counter()の「後 − 前」で測る。time.time() は時刻用で、戻ることがある - 1 回だけの計測は揺れる。比べるときは
timeit.repeat()やpy -m timeitで測り、最小値を見る - print を範囲に入れない。初回の遅さを意識する
- どこが遅いかを探すのは cProfile、直した効果を比べるのは timeit
関連する記事・ツール
- Pythonのデコレーター入門|@の仕組みとfunctools.wrapsを実例で解説
- Pythonのwith文とは?コンテキストマネージャーの仕組みと作り方
- Pythonのcollections入門|Counter・defaultdict・deque
- Pythonのasyncio入門|async・awaitの基本と同時に待つ方法
- Pythonのリスト・辞書・内包表記の基本|使い方とよくある間違いを実例で解説