05 · 怎么量：计时、剖析、内存

# 你手上的三个时钟分别是什么脾气
import time

for name in ("time", "perf_counter", "process_time", "monotonic"):
    info = time.get_clock_info(name)
    print("%-13s 精度 %.9f s ｜ 会不会被系统调时间影响: %s" % (
        name, info.resolution, "会" if info.adjustable else "不会"))

# perf_counter 数的是墙上的时间，process_time 数的是 CPU 真给你的时间
import time

t1 = time.perf_counter(); c1 = time.process_time()
time.sleep(0.5)                      # 等待：墙上的钟在走，CPU 没在为你干活
s = sum(i * i for i in range(2_000_000))
t2 = time.perf_counter(); c2 = time.process_time()

print("perf_counter （墙上时间）  %.3f s" % (t2 - t1))
print("process_time （CPU 时间）  %.3f s" % (c2 - c1))
print("差值 ≈ 花在等待上的时间     %.3f s" % ((t2 - t1) - (c2 - c1)))

# 量 → 改 → 再量：一个可复用的计时上下文管理器
import contextlib, time

@contextlib.contextmanager
def timed(label):
    t = time.perf_counter()
    try:
        yield
    finally:
        print("%-22s %7.1f ms" % (label, (time.perf_counter() - t) * 1000))

rows = [i * 0.5 for i in range(200_000)]

def normalize(x, lo=0.0, hi=100.0):
    return (x - lo) / (hi - lo)

with timed("改之前（调函数）"):
    out1 = [normalize(x) for x in rows]

with timed("改之后（算式内联）"):
    out2 = [x / 100.0 for x in rows]

print("结果一样吗:", out1 == out2)

# 同一处改动，用 timeit 重复测量取最小值
import timeit

setup = """
rows = [i * 0.5 for i in range(200_000)]
def normalize(x, lo=0.0, hi=100.0):
    return (x - lo) / (hi - lo)
"""
before = min(timeit.repeat("[normalize(x) for x in rows]", setup, repeat=9, number=5)) / 5
after = min(timeit.repeat("[x / 100.0 for x in rows]", setup, repeat=9, number=5)) / 5
print("改之前 %.1f ms ｜ 改之后 %.1f ms ｜ 快了 %.1f 倍"
      % (before * 1000, after * 1000, before / after))

# timeit.repeat 为什么看最小值：噪声只会往上加，不会往下减
import statistics, timeit

setup = "data = list(range(20000))"
stmt = "sum(x * x for x in data)"

rs = timeit.repeat(stmt, setup=setup, repeat=15, number=20)
per = [r / 20 for r in rs]           # 除以 number，换算成「一次」的耗时

print("15 轮，每轮 20 次，单次耗时（毫秒）：")
print("  ".join("%.2f" % (p * 1000) for p in sorted(per)))
print("最小值 %.2f ms ｜ 中位数 %.2f ms ｜ 平均 %.2f ms ｜ 最大值 %.2f ms" % (
    min(per) * 1000, statistics.median(per) * 1000,
    statistics.mean(per) * 1000, max(per) * 1000))
print("最大值比最小值大 %.0f%%" % ((max(per) / min(per) - 1) * 100))

> python -m timeit -s "data=list(range(20000))" "sum(x*x for x in data)"
500 loops, best of 5: 793 usec per loop

# 三样会让你测出假数字的东西
import functools, time, timeit

# ① 第一次里混着一次性的钱
t = time.perf_counter(); import numpy as np
print("① import numpy 这一次就要 %.3f s —— 而你想测的那段可能只有几毫秒"
      % (time.perf_counter() - t))
a = np.random.rand(2_000_000)
runs = []
for _ in range(5):
    t = time.perf_counter(); a.sum(); runs.append(time.perf_counter() - t)
print("   同一句 a.sum() 连测 5 次(ms): " + " ".join("%.2f" % (r * 1000) for r in runs)
      + " ← 最大是最小的 %.1f 倍" % (max(runs) / min(runs)))

# ② 缓存：第二次量的根本不是同一件事
@functools.lru_cache(maxsize=None)
def slow(n):
    return sum(i * i for i in range(n))

t = time.perf_counter(); slow(2_000_000); c1 = time.perf_counter() - t
t = time.perf_counter(); slow(2_000_000); c2 = time.perf_counter() - t
print("② 带缓存的函数：第一次 %.4f s ｜ 第二次 %.7f s ｜ 「快了」%.0f 倍" % (c1, c2, c1 / c2))

# ③ timeit 默认把垃圾回收关了
stmt = "[[0] * 100 for _ in range(3000)]"
off = min(timeit.repeat(stmt, repeat=7, number=20)) / 20
on = min(timeit.repeat(stmt, setup="import gc; gc.enable()", repeat=7, number=20)) / 20
print("③ 同一段代码：timeit 默认(GC 关) %.2f ms ｜ 打开 GC %.2f ms" % (off * 1000, on * 1000))

# cProfile：一份最小但完整的剖析报告
import cProfile, pstats, io, random

def load(n=200_000):
    random.seed(0)
    return [random.random() * 100 for _ in range(n)]

def normalize(x, lo=0.0, hi=100.0):          # 被调用 20 万次的小函数
    return (x - lo) / (hi - lo)

def clean(rows):
    return [normalize(x) for x in rows]

def featurize(rows):
    return [r * r + r for r in rows]          # 一个大循环，不调用别的函数

def pipeline():
    rows = load()
    rows = clean(rows)
    return featurize(rows)

if __name__ == "__main__":
    pr = cProfile.Profile()
    pr.enable(); pipeline(); pr.disable()

    s = io.StringIO()
    (pstats.Stats(pr, stream=s)
        .strip_dirs()                 # ⭐ 去掉长路径，否则一行刷满屏幕
        .sort_stats("tottime")        # ⭐ 先按 tottime 排：谁自己最费
        .print_stats(6))
    print(s.getvalue())

         400009 function calls in 0.127 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.037    0.037    0.055    0.055 p07.py:4(load)
        1    0.037    0.037    0.059    0.059 p07.py:11(clean)
   200000    0.022    0.000    0.022    0.000 p07.py:8(normalize)
   200000    0.018    0.000    0.018    0.000 {method 'random' of '_random.Random' objects}
        1    0.011    0.011    0.011    0.011 p07.py:14(featurize)
        1    0.001    0.001    0.127    0.127 p07.py:17(pipeline)

# 剖析器自己是要钱的，而且不是每个函数收一样多
import cProfile, time

def tiny(x):
    return x + 1

def many_small(n=1_000_000):        # 一百万次函数调用
    s = 0
    for i in range(n):
        s = tiny(s)
    return s

def one_big(n=1_000_000):           # 同样一百万次循环，但不调用函数
    s = 0
    for i in range(n):
        s = s + 1
    return s

def wall(fn):
    best = float("inf")
    for _ in range(3):
        t = time.perf_counter(); fn(); best = min(best, time.perf_counter() - t)
    return best

def under_profiler(fn):
    pr = cProfile.Profile()
    t = time.perf_counter()
    pr.enable(); fn(); pr.disable()
    return time.perf_counter() - t

for name, fn in [("many_small（一百万次函数调用）", many_small),
                 ("one_big  （一百万次纯循环）", one_big)]:
    a, b = wall(fn), under_profiler(fn)
    print("%s  裸跑 %.3f s ｜ cProfile 下 %.3f s ｜ 放大 %.1f 倍" % (name, a, b, b / a))

# 内存怎么量：峰值 vs 结束时，以及 getsizeof 为什么骗你
import sys, tracemalloc

def build_list(n=1_000_000):
    return [i * 2 for i in range(n)]      # 结果整个落地

def build_sum(n=1_000_000):
    return sum(i * 2 for i in range(n))   # 生成器，不落地

for fn in (build_list, build_sum):
    tracemalloc.start()
    r = fn()
    cur, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    print("%-11s 结束时占 %7.1f MB ｜ 峰值 %7.1f MB" % (fn.__name__, cur / 1e6, peak / 1e6))
    del r

# getsizeof 只数「这个对象自己」，不数它指着的东西
lst = [i * 2 for i in range(1_000_000)]
print("getsizeof(列表)        %.1f MB  ← 只是一百万个指针" % (sys.getsizeof(lst) / 1e6))
print("加上里面每个 int       %.1f MB  ← 才是真账"
      % ((sys.getsizeof(lst) + sum(sys.getsizeof(x) for x in lst)) / 1e6))

# 峰值和「结束时」是两个数，OOM 杀的是峰值
import os, tracemalloc

tracemalloc.start()

rows = [i * 2 for i in range(1_000_000)]        # 第一份
kept = [x for x in rows if x % 3 == 0]          # 第二份：此刻两份同时活着
snap = tracemalloc.take_snapshot()              # ⭐ 趁两份都在，拍一张
_, peak_both = tracemalloc.get_traced_memory()
del rows                                        # 放掉第一份
cur_after, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()

print("两份都活着时的峰值 %.1f MB" % (peak_both / 1e6))
print("放掉第一份之后     %.1f MB" % (cur_after / 1e6))
print("\n分配得最多的三行（快照拍摄时刻）：")
for st in snap.statistics("lineno")[:3]:
    fr = st.traceback[0]
    print("  %5.1f MB   %s:%d" % (st.size / 1e6, os.path.basename(fr.filename), fr.lineno))