start = time.perf_counter()

Performance Patterns

Meaning

It calls time.perf_counter() to obtain a high‑resolution, monotonic timestamp representing the current point in program execution. This avoids inaccuracies caused by system‑clock adjustments when measuring elapsed time. Use it whenever you need to benchmark code sections, profile functions, or measure operation latency.

Primary Function

Performance measurement

Communicative Purpose

Record the moment an operation begins so that later code can compute its duration.

Pattern

timer_var = time.perf_counter()

Core Structure

... = time.perf_counter()

Função primária

Performance measurement

Propósito comunicativo

Record the moment an operation begins so that later code can compute its duration.

Situações de gatilho

Data analysis: measuring the runtime of a pandas DataFrame transformation loop; Web services: timing the handling of an HTTP request to detect latency spikes

Contextos

General‑purpose scripts, data‑science notebooks, web services, command‑line utilities – any Python code where timing matters.

Padrão

timer_var = time.perf_counter()

Estrutura central

... = time.perf_counter()

Slots de substituição

timer_var: identifier

Colocados típicos

end = time.perf_counter()
elapsed = end - start
print(f"Elapsed: {elapsed:.4f}s\))

Substituições comuns

time.time()
time.perf_counter_ns()
time.monotonic()

Erros comuns

Forgetting to import the time module; using perf_counter for wall‑clock time when a calendar timestamp is needed; reusing the same variable for start and end, overwriting the start value.

Similar / contraste

time.monotonic() – also monotonic but lower resolution; time.process_time() – measures CPU time only, not elapsed wall‑clock time.

Interferências

Coming from C/C++: assuming `clock()` gives high‑resolution monotonic time → use time.perf_counter() instead.

Família do chunk

timing
performance measurement
benchmarking

Nuance

perf_counter is monotonic and includes time spent sleeping; use it for elapsed‑time measurements, not for timestamps that need to be persisted or compared across program runs.

Efeito pragmático

Provides reliable, high‑resolution timing without manual clock adjustments, preventing resource‑leak‑like timing bugs.

Dica de memória

Start the stopwatch with perf_counter

Nota

Ensure `import time` is present; the variable name can be any valid identifier.

Upgrade path

Replace with `start = time.perf_counter_ns()` for nanosecond precision, or wrap in a context manager for automatic start/end handling.

Frequência: HighFormulaicidade: FixedTipo de construção: variable assignmentPrioridade de aquisição: Recognition firstPrioridade de output: BothTag de espaçamento: Immediate

Examples

import time start = time.perf_counter() for i in range(1_000_000): _ = i * i end = time.perf_counter() print(f"Loop took {end - start:.4f} seconds\))

import time def compute(): total = 0 for i in range(100_000): total += i return total start = time.perf_counter() compute() elapsed = time.perf_counter() - start print(f"compute() took {elapsed:.6f}s\))

import time def timed_block(): start = time.perf_counter() # Simulate I/O delay time.sleep(0.75) end = time.perf_counter() return end - start duration = timed_block() print(f"Block duration: {duration:.3f} seconds\))