Python 脚本耗时怎么测：用 perf_counter 与 process_time 区分等待和计算

python3 --version
mkdir timing-demo
cd timing-demo

"""Measure elapsed and current-process CPU time. Python 3.10+."""
import argparse
import json
from statistics import median
import time


def measure(action):
    wall_start = time.perf_counter_ns()
    cpu_start = time.process_time_ns()
    result = action()
    cpu_ns = time.process_time_ns() - cpu_start
    wall_ns = time.perf_counter_ns() - wall_start
    return {
        "wall_seconds": wall_ns / 1_000_000_000,
        "cpu_seconds": cpu_ns / 1_000_000_000,
        "result": result,
    }


def compute():
    total = 0
    for number in range(1_000_000):
        total += number
    return total


def repeat_count(value):
    try:
        count = int(value)
    except ValueError as exc:
        raise argparse.ArgumentTypeError("repeat must be an integer") from exc
    if not 1 <= count <= 10:
        raise argparse.ArgumentTypeError("repeat must be between 1 and 10")
    return count


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("mode", choices=("wait", "compute"))
    parser.add_argument("--repeat", type=repeat_count, default=3)
    args = parser.parse_args()
    action = (lambda: time.sleep(0.2)) if args.mode == "wait" else compute
    runs = [measure(action) for _ in range(args.repeat)]
    report = {
        "mode": args.mode,
        "runs": runs,
        "median_wall_seconds": median(row["wall_seconds"] for row in runs),
        "median_cpu_seconds": median(row["cpu_seconds"] for row in runs),
    }
    print(json.dumps(report, allow_nan=False, indent=2))


if __name__ == "__main__":
    main()

python3 stage_timing.py --help
python3 stage_timing.py wait --repeat 3 > wait.json
python3 stage_timing.py compute --repeat 3 > compute.json
python3 -m json.tool wait.json
python3 -m json.tool compute.json

import json
from pathlib import Path
from unittest.mock import patch
import stage_timing

wait = json.loads(Path("wait.json").read_text(encoding="utf-8"))
compute = json.loads(Path("compute.json").read_text(encoding="utf-8"))
assert wait["mode"] == "wait" and compute["mode"] == "compute"
for report in (wait, compute):
    assert len(report["runs"]) == 3
    assert all(row["wall_seconds"] >= 0 for row in report["runs"])
    assert all(row["cpu_seconds"] >= 0 for row in report["runs"])
assert all(row["result"] is None for row in wait["runs"])
assert all(row["result"] == 499999500000 for row in compute["runs"])
assert stage_timing.compute() == 499999500000

# Deterministic arithmetic test, independent of server load.
with patch.object(stage_timing.time, "perf_counter_ns", side_effect=[10, 210]), \
     patch.object(stage_timing.time, "process_time_ns", side_effect=[20, 70]):
    measured = stage_timing.measure(lambda: "done")
assert measured == {"wall_seconds": 200 / 1e9,
                    "cpu_seconds": 50 / 1e9, "result": "done"}

# Failed work must propagate its exception, not return a success measurement.
def fail():
    raise RuntimeError("demo failure")

try:
    stage_timing.measure(fail)
except RuntimeError as exc:
    assert str(exc) == "demo failure"
else:
    raise AssertionError("failure was swallowed")
print("PASS: results, clock arithmetic, and failure propagation")

python3 check_timing.py
if python3 stage_timing.py wait --repeat 0 > invalid.json 2> invalid.err; then
    echo "unexpected success" >&2
    exit 1
else
    code=$?
    test "$code" -eq 2 || exit 1
    test ! -s invalid.json || exit 1
    grep -F "repeat must be between 1 and 10" invalid.err
fi