Summary  
This chapter covers how to perform line-by-line memory profiling in Python using the memory_profiler library, demonstrating the use of the @profile decorator and the memory_usage() function to identify and compare memory hotspots in different code implementations.  

General domain of usage  
Performance optimization and debugging of code memory consumption

`tracemalloc` works from inside your code. `memory_profiler` takes a different approach – it decorates functions and reports memory usage **line by line**, showing exactly how much memory each line adds or frees. It is the most readable tool for understanding the memory profile of a specific function.

Watch this video for a complete overview of profiling memory usage in Python with the memory_profiler library. You'll learn how to install memory_profiler, use the @profile decorator for line-by-line memory tracking, and apply memory_usage() for programmatic monitoring. The video walks through practical code examples, demonstrates how to interpret memory_profiler's output, and compares memory_profiler with tracemalloc using a detailed feature table. By the end, you'll know when and how to use memory_profiler for effective memory profiling in your Python projects.

- 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.

## Installation

```
pip install memory-profiler
```



## The `@profile` Decorator

Add `@profile` to any function and run the script with `python -m memory_profiler your_script.py`. Each line is annotated with memory usage and the increment from the previous line:

from memory_profiler import profile

@profile
def build_sales_report():
    # Loading raw sales data
    sales_records = [
        {"region": f"region_{record_id % 10}", "revenue": record_id * 150.0}
        for record_id in range(100000)
    ]

    # Grouping by region
    region_totals = {}
    for record in sales_records:
        region = record["region"]
        region_totals[region] = region_totals.get(region, 0) + record["revenue"]

    # Freeing raw data after aggregation
    del sales_records

    return region_totals

result = build_sales_report()
print(f"Regions: {len(result)}")

The `del sales_records` line shows a clear memory drop – confirming that the cleanup is effective.

The `@profile` decorator requires running the script via `python -m memory_profiler your_script.py` to produce line-by-line output. Inside a Jupyter environment it will execute the function normally but skip the memory report. Use `memory_usage()` for programmatic profiling within notebooks.

Note

## Using `memory_usage()` Programmatically

For use inside a script without the decorator, `memory_usage()` returns a time series of memory readings while a function runs:

from memory_profiler import memory_usage
import time

def process_batch(batch_size):
    data = list(range(batch_size))
    time.sleep(0.1)  # Simulating processing time
    return sum(data)

# Sampling memory every 10ms during the function call
mem_usage = memory_usage((process_batch, (500000,)), interval=0.01)

print(f"Min memory: {min(mem_usage):.1f} MiB")
print(f"Max memory: {max(mem_usage):.1f} MiB")
print(f"Peak delta: {max(mem_usage) - min(mem_usage):.1f} MiB")

## Comparing Two Implementations

`memory_profiler` makes it easy to compare the memory cost of two approaches side by side:

from memory_profiler import profile

@profile
def approach_list():
    # Building a full list of computed values
    return [value ** 2 for value in range(200000)]

@profile
def approach_generator():
    # Consuming a generator without storing results
    return sum(value ** 2 for value in range(200000))

approach_list()
approach_generator()

Running this with `python -m memory_profiler` shows the memory delta for each line in both functions – `approach_list` will show a large allocation for the list, while `approach_generator` stays nearly flat.



Reading the memory profile of a function
Programmatic use	Yes – snapshots in code	Yes – memory_usage()
Overhead	Low	Higher – samples RSS periodically


What does the `Increment` column in `memory_profiler` output represent?

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.

Profiling with memory_profiler

Installation

The `@profile` Decorator

Using `memory_usage()` Programmatically

Comparing Two Implementations

`tracemalloc` vs `memory_profiler`

Profiling with memory_profiler

Installation

The @profile Decorator

Using memory_usage() Programmatically

Comparing Two Implementations

tracemalloc vs memory_profiler

The `@profile` Decorator

Using `memory_usage()` Programmatically

`tracemalloc` vs `memory_profiler`