Summary
This chapter explains how to measure and analyze memory allocations using Python’s tracemalloc module by taking and comparing snapshots to identify memory growth, peak usage, and hotspot lines in code.

General domain of usage
Performance and memory profiling

Before optimizing memory usage, you need to measure it. `tracemalloc` is Python's built-in memory tracer – it tracks every allocation made by the interpreter and lets you take snapshots, compare them, and pinpoint exactly which line of code is responsible for the most memory.



Get an overview of how to use Python's built-in tracemalloc module to measure and analyze memory usage in your code. This video walks you through starting and stopping memory tracing, taking and comparing snapshots, finding memory peaks, and identifying which lines of code are responsible for allocations. You'll see practical examples that demonstrate how tracemalloc helps you pinpoint memory issues and optimize your Python applications.

- video metadata (use this info when making a video) --
Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

## Basic Usage

`tracemalloc.start()` begins tracing. `tracemalloc.take_snapshot()` captures the current allocation state. `tracemalloc.stop()` ends tracing:

import tracemalloc

tracemalloc.start()

# Allocating some data to trace
employee_records = [
    {"id": emp_id, "name": f"Employee_{emp_id}", "salary": 50000 + emp_id * 100}
    for emp_id in range(10000)
]

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics("lineno")

print("Top 3 memory allocations:")
for stat in top_stats[:3]:
    print(stat)

tracemalloc.stop()

Each stat line shows the file, line number, total size, and number of allocations for that line.

## Comparing Two Snapshots

The most useful pattern is comparing a snapshot before and after an operation to see exactly what was allocated:

import tracemalloc

tracemalloc.start()

snapshot_before = tracemalloc.take_snapshot()

# Operation to measure
transaction_log = []
for transaction_id in range(50000):
    transaction_log.append({
        "id": transaction_id,
        "amount": transaction_id * 12.5,
        "status": "pending",
    })

snapshot_after = tracemalloc.take_snapshot()

top_stats = snapshot_after.compare_to(snapshot_before, "lineno")

print("Memory growth by line:")
for stat in top_stats[:5]:
    print(stat)

tracemalloc.stop()

`compare_to()` shows the **delta** – only lines where allocations increased.



## Finding the Peak

`tracemalloc.get_traced_memory()` returns the current and peak memory used since tracing started:

import tracemalloc

tracemalloc.start()

# Allocating and then partially freeing data
batch_one = [list(range(1000)) for _ in range(500)]
current, peak = tracemalloc.get_traced_memory()
print(f"After batch one – current: {current / 1024:.1f} KB, peak: {peak / 1024:.1f} KB")

del batch_one

batch_two = [list(range(100)) for _ in range(500)]
current, peak = tracemalloc.get_traced_memory()
print(f"After batch two – current: {current / 1024:.1f} KB, peak: {peak / 1024:.1f} KB")

tracemalloc.stop()

Peak memory tells you the worst-case usage during execution – important for sizing containers and servers.

## Inspecting Top Allocations with Traceback

Use `statistics("lineno")` and access `traceback[0]` to get the file and line responsible for each allocation:

import tracemalloc

tracemalloc.start()

report_data = {f"report_{report_id}": list(range(500)) for report_id in range(1000)}

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics("lineno")

for stat in top_stats[:5]:
    frame = stat.traceback[0]
    print(f"{frame.filename}:{frame.lineno} – {stat.size / 1024:.1f} KB – {stat.count} allocs")

tracemalloc.stop()

What does `snapshot_after.compare_to(snapshot_before, "lineno")` show?

Master the skills needed to understand Python's memory management internals and performance optimization techniques. This course is designed for intermediate and advanced Python developers who want to understand how Python handles memory, write memory-efficient code, detect and fix memory leaks, and optimize performance in real-world applications.

Explore the essentials of Python's memory management, including reference counting, garbage collection, and memory allocation strategies.

Get hands-on experience with practical techniques for writing memory-efficient Python code, including specialized data structures and tools for controlling object lifecycle.

Master the skills needed to profile memory usage and detect memory leaks in Python applications.

Explore the essentials of advanced memory and performance optimization patterns, including object interning, memory inspection tools, and the GIL's impact on memory access.

Measuring Memory with tracemalloc

Basic Usage

Comparing Two Snapshots

Finding the Peak

Inspecting Top Allocations with Traceback