### Install memory_profiler via pip

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This command installs or upgrades the memory_profiler package using pip, the standard Python package installer. Ensure you have pip installed and updated for the best experience.

```bash
pip install -U memory_profiler
```

--------------------------------

### Install memory_profiler for IPython

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This snippet shows how to integrate memory_profiler with IPython versions prior to 0.10 by modifying the user configuration file. It imports the necessary IPython API and loads the memory_profiler extension.

```python
# These two lines are standard and probably already there.
import IPython.ipapi
ip = IPython.ipapi.get()

# These two are the important ones.
import memory_profiler
memory_profiler.load_ipython_extension(ip)
```

--------------------------------

### Set memory tracking backend via API

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Illustrates how to set the memory tracking backend programmatically when using the memory_profiler API. This example shows the usage of the `memory_usage` function with the `backend` parameter.

```python
from memory_profiler import memory_usage
mem_usage = memory_usage(-1, interval=.2, timeout=1, backend="psutil")
```

--------------------------------

### Run and Plot Memory Usage with mprof

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This snippet demonstrates how to use the `mprof` command-line tool to run a Python script and plot its memory usage. It requires the `memory_profiler` library to be installed. The output is a plot generated using matplotlib.

```bash
mprof run --python python <script>
mprof plot
```

--------------------------------

### Profile Asynchronous Functions and Coroutines

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

This code demonstrates how to use the `@profile` decorator to profile asynchronous functions and coroutines. It includes examples of profiling a single async function and multiple concurrent tasks using `asyncio.gather`.

```python
import asyncio
from memory_profiler import profile

@profile
async def async_data_processing():
    # Allocate memory
    data = [1] * (10 ** 6)

    # Simulate async I/O
    await asyncio.sleep(0.5)

    # Allocate more memory
    more_data = [2] * (2 * 10 ** 7)

    # Simulate processing
    await asyncio.sleep(0.5)

    # Release memory
    del more_data

    return data

@profile
async def parallel_tasks():
    async def task(size, delay):
        data = [1] * size
        await asyncio.sleep(delay)
        return len(data)

    # Run multiple async tasks concurrently
    results = await asyncio.gather(
        task(10**5, 0.1),
        task(10**6, 0.2),
        task(10**5, 0.1),
    )
    return results

if __name__ == '__main__':
    # Run async function
    asyncio.run(async_data_processing())
    asyncio.run(parallel_tasks())
```

--------------------------------

### Cell Mode Peak Memory Measurement in IPython

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Measures peak memory consumption in IPython using the %%memit magic command in cell mode, including setup code. This is useful for profiling memory usage of more complex operations or sequences of commands.

```python
In [3]: %%memit l=range(1000000)
   ...: len(l)
   ...:
peak memory: 52.14 MiB, increment: 0.08 MiB
```

--------------------------------

### Set memory tracking backend via CLI

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Demonstrates how to specify a memory tracking backend when running a Python script using the memory_profiler command-line interface. This allows users to choose between different backends like 'psutil'.

```bash
python -m memory_profiler --backend psutil my_script.py
```

--------------------------------

### Command-Line Memory Profiling with `python -m memory_profiler` (Bash)

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

This section outlines how to use the `memory_profiler` module directly from the command line for line-by-line memory profiling. It covers basic usage, setting output precision, including child processes, selecting different backends, writing output to a file, enabling timestamps, entering the debugger on high memory usage, and passing arguments to the profiled script. The target script must use `@profile` decorators.

```bash
# Basic line-by-line profiling (script must have @profile decorators)
python -m memory_profiler example.py

# Set custom precision for memory output (3 decimal places)
python -m memory_profiler --precision 3 example.py

# Include memory from child processes
python -m memory_profiler --include-children multiproc_script.py

# Use different backends
python -m memory_profiler --backend psutil_pss example.py
python -m memory_profiler --backend tracemalloc example.py

# Write output to a file
python -m memory_profiler -o memory_report.txt example.py

# Enable timestamp mode for decorated functions
python -m memory_profiler --timestamp example.py

# Step into debugger when memory exceeds threshold (100 MiB)
python -m memory_profiler --pdb-mmem=100 example.py

# Pass arguments to the script
python -m memory_profiler example.py --arg1 value1 --arg2 value2
```

--------------------------------

### Generate and plot memory usage report with mprof

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This command sequence uses the `mprof` utility to run an executable, record its memory usage over time, and then generate a plot of that usage. This is useful for identifying memory bottlenecks in your application.

```bash
mprof run executable
mprof plot
```

--------------------------------

### Profile Arbitrary Code with runctx

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

Demonstrates how to use the `runctx` method of `LineProfiler` to profile arbitrary code snippets. This is useful for profiling code that is not easily decorated or when dynamic profiling is required. It requires importing `LineProfiler` and defining the function to be profiled.

```python
from memory_profilers import LineProfiler

# Assume function_to_profile is defined elsewhere
def function_to_profile(n):
    return [i for i in range(n)]

profiler3 = LineProfiler()
profiler3.add_function(function_to_profile)
profiler3.runctx(
    'result = function_to_profile(100000)',
    globals(),
    locals()
)
profiler3.print_stats()
```

--------------------------------

### Load memory_profiler Extension in IPython

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Loads the memory_profiler extension in IPython, enabling the use of magic commands like %mprun and %memit. This is done by adding 'memory_profiler' to the extensions list in the IPython configuration file.

```python
c.InteractiveShellApp.extensions = [
    'memory_profiler',
]
```

--------------------------------

### Line-by-Line Profiling in IPython using %mprun

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Performs line-by-line memory profiling of a function in IPython using the %mprun magic command. The function must be defined in a file and specified using the -f flag.

```python
In [1]: from example import my_func, my_func_2

In [2]: %mprun -f my_func my_func()
```

--------------------------------

### Select Memory Tracking Backends (Python)

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

This code illustrates how to utilize different backends for memory tracking with `memory_usage`. It covers Resident Set Size (RSS) using the default `psutil`, Proportional Set Size (PSS), Unique Set Size (USS), and Python's built-in `tracemalloc`. Note that PSS and USS require specific `psutil` versions, and `tracemalloc` needs source file access.

```python
from memory_profiler import memory_usage

def allocate_memory():
    data = [1] * (10 ** 7)
    return len(data)

# Default backend (psutil) measures RSS - Resident Set Size
rss_mem = memory_usage((allocate_memory, (), {}), backend='psutil', max_usage=True)
print(f"RSS (Resident Set Size): {rss_mem} MiB")

# PSS - Proportional Set Size (shared memory divided among processes)
try:
    pss_mem = memory_usage((allocate_memory, (), {}), backend='psutil_pss', max_usage=True)
    print(f"PSS (Proportional Set Size): {pss_mem} MiB")
except NotImplementedError:
    print("PSS requires psutil > 4.0.0")

# USS - Unique Set Size (memory unique to the process)
try:
    uss_mem = memory_usage((allocate_memory, (), {}), backend='psutil_uss', max_usage=True)
    print(f"USS (Unique Set Size): {uss_mem} MiB")
except NotImplementedError:
    print("USS requires psutil > 4.0.0")

# tracemalloc backend (Python's built-in memory tracer)
try:
    trace_mem = memory_usage((allocate_memory, (), {}), backend='tracemalloc', max_usage=True)
    print(f"tracemalloc: {trace_mem} MiB")
except RuntimeError:
    print("tracemalloc requires source file access")
```

--------------------------------

### Time-Based Memory Profiling with `mprof` (Bash)

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

The `mprof` command-line tool facilitates time-based memory profiling and visualization. This snippet shows how to run scripts, record memory usage over time, track child processes, plot the results with various customization options (titles, trend lines, flamegraphs), list recorded profiles, and manage profile files.

```bash
# Run a script and record memory usage over time
mprof run python my_script.py

# Run with function-level timestamps (requires @profile decorators)
mprof run --python python my_script.py

# Track child processes separately
mprof run --multiprocess my_script.py

# Include children's memory in parent total
mprof run --include-children my_script.py

# Combine both multiprocess and include-children
mprof run --multiprocess --include-children my_script.py

# Set custom sampling interval (in seconds)
mprof run -T 0.01 my_script.py

# Plot the most recent memory profile
mprof plot

# Plot with custom title
mprof plot -t "Memory Usage During Data Processing"

# Hide function timestamps in plot
mprof plot -n

# Show trend lines with slope values (detect memory leaks)
mprof plot -s

# Generate flamegraph visualization
mprof plot --flame

# List all recorded profiles
mprof list

# Remove specific profile files
mprof rm mprofile_20231115_143022.dat

# Clean up all profile files
mprof clean
```

--------------------------------

### Time-Based Memory Profiling with @profile and mprof

Source: https://github.com/pythonprofilers/memory_profiler/wiki/Usage

Record timestamps when entering and leaving profiled functions during time-based memory analysis. Decorate functions with `@profile` and run the script using `mprof run <script_name>.py`. This allows for more granular insights into memory usage related to function calls over time. Ensure the import `from memory_profiler import profile` is commented out for timestamp recording.

```bash
# Comment out: from memory_profiler import profile

# Decorate functions with @profile
# ...

mprof run <script_name>.py
mprof plot
```

--------------------------------

### IPython Magic Commands for Memory Profiling

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

This section covers IPython magic commands for interactive memory profiling. It includes `%memit` for measuring memory usage of single statements or cells, and `%mprun` for line-by-line profiling of functions.

```ipython
# Load the extension in IPython
%load_ext memory_profiler

# Measure memory of a single statement (like %timeit for memory)
%memit range(10000)
# Output: peak memory: 21.42 MiB, increment: 0.41 MiB

%memit range(1000000)
# Output: peak memory: 52.10 MiB, increment: 31.08 MiB

# Cell mode with setup code
%%memit l = range(1000000)
len(l)
# Output: peak memory: 52.14 MiB, increment: 0.08 MiB

# Options for %memit:
# -r<N>: repeat N times and take best result
# -t<T>: timeout after T seconds
# -i<I>: sampling interval
# -c: include children processes
# -o: return MemitResult object
# -q: quiet mode

%memit -r3 -i0.01 [x**2 for x in range(100000)]

# Line-by-line profiling of imported functions
from mymodule import my_func, helper_func

# Profile a single function
%mprun -f my_func my_func()

# Profile multiple functions in cell mode
%%mprun -f my_func -f helper_func
my_func()
helper_func()

# Options for %mprun:
# -f <function>: specify function to profile (required, can use multiple)
# -T <filename>: save text output to file
# -r: return LineProfiler object
# -c: include children process memory

%mprun -f my_func -T profile_output.txt my_func()
```

--------------------------------

### Import and use @profile decorator in Python

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This Python code shows the basic usage of the `@profile` decorator imported from the `memory_profiler` library. When applied to a function, it enables line-by-line memory profiling when the script is run with the memory profiler module.

```python
from memory_profiler import profile

@profile
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a
```

--------------------------------

### Cell Mode Line-by-Line Profiling in IPython

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Executes multiple functions with line-by-line memory profiling in IPython using the %%mprun magic command in cell mode. This allows profiling several functions within a single code block.

```python
In [3]: %%mprun -f my_func -f my_func_2
   ...: my_func()
   ...: my_func_2()
```

--------------------------------

### Memory Debugging with pdb Integration

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

Explains how to set memory-based breakpoints using the `--pdb-mmem` command-line option or within a script decorated with `@profile`. This feature automatically enters the pdb debugger when memory usage exceeds a specified threshold, aiding in debugging memory leaks and out-of-memory errors.

```python
# From command line - enters pdb when memory exceeds 100 MiB
# python -m memory_profiler --pdb-mmem=100 my_script.py

# In my_script.py:
from memory_profilers import profile

@profile
def memory_intensive_function():
    # This will trigger the debugger if it causes memory to exceed threshold
    data = []
    for i in range(100):
        chunk = [1] * (10**6)  # ~7.6 MiB per iteration
        data.extend(chunk)
        # Debugger breaks here when memory exceeds --pdb-mmem value
    return len(data)

if __name__ == '__main__':
    memory_intensive_function()

# When the debugger activates, you can:
# - Inspect variables: p len(data), p sys.getsizeof(data)
# - Step through code: n, s, c
# - Check current memory manually
# - Set additional breakpoints
```

--------------------------------

### Python Memory Profiler Decorator

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This Python snippet shows how to import and use the `profile` decorator from the `memory_profiler` library. Decorating a function with `@profile` enables detailed memory usage tracking for that function when the script is run with `mprof`.

```python
from memory_profiler import profile

@profile
def my_function():
    # function code here
```

--------------------------------

### Line-by-Line Memory Profiling with @profile Decorator

Source: https://github.com/pythonprofilers/memory_profiler/wiki/Usage

Profile a Python function line by line to analyze memory usage. Decorate the target function with `@profile` and run the script using `python -m memory_profiler <script_name>.py`. This method provides detailed memory consumption for each line executed within the decorated function.

```python
from memory_profiler import profile

@profile
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a

if __name__ == '__main__':
    my_func()
```

--------------------------------

### Time-Based Memory Profiling with mprof

Source: https://github.com/pythonprofilers/memory_profiler/wiki/Usage

Analyze memory usage over time for external processes or Python scripts using the `mprof` executable. Use `mprof run <executable>` to record memory usage and `mprof plot` to visualize the results. This is useful for identifying memory bottlenecks that are not tied to specific lines of code.

```bash
mprof run <executable>
mprof plot
```

--------------------------------

### Redirect Memory Profiler Output to a File

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Redirects the output of the memory profiler decorator to a specified file stream. This is useful for logging memory usage details over time. The stream is opened in write-plus mode.

```python
from memory_profiler import profile

fp=open('memory_profiler.log','w+')
@profile(stream=fp)
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a
```

--------------------------------

### Track Child Process Memory Usage with mprof

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This demonstrates how to track memory usage in multiprocessing scenarios. The `--include-children` flag sums the memory of child processes with the parent's usage. The `--multiprocess` flag tracks each child independently. Both require `mprof` and matplotlib.

```bash
mprof run --include-children <script>
mprof run --multiprocess <script>
mprof plot
```

--------------------------------

### Integrate Memory Profiler Output with Python Logging

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

This snippet demonstrates how to use the `LogFile` class to redirect memory profiler output to Python's logging module. It configures a rotating file handler and shows how to control the verbosity of the logged memory increments.

```python
from memory_profiler import profile, LogFile
import logging
import sys

# Configure logger with rotating file handler
logger = logging.getLogger('memory_profile_log')
logger.setLevel(logging.DEBUG)

fh = logging.FileHandler('memory_profile.log')
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)

# Redirect stdout to LogFile for memory_profiler output
# reportIncrementFlag=False logs all lines
sys.stdout = LogFile('memory_profile_log', reportIncrementFlag=False)

@profile
def data_processing():
    raw_data = list(range(10**6))
    processed = [x * 2 for x in raw_data]
    filtered = [x for x in processed if x % 3 == 0]
    return filtered

# Only report lines with memory increments (filter out zero-increment lines)
sys.stdout = LogFile('memory_profile_log', reportIncrementFlag=True)

@profile
def memory_intensive_task():
    large_list = [1] * (10**7)
    del large_list
    small_list = [2] * (10**3)
    return small_list

if __name__ == '__main__':
    data_processing()
    memory_intensive_task()
```

--------------------------------

### Line-by-Line Memory Profiling with Precision Argument

Source: https://github.com/pythonprofilers/memory_profiler/wiki/Usage

Customize the precision of memory usage reporting in line-by-line profiling. Pass the 'precision' argument to the @profile decorator. Note that this precision setting is ignored if the script is run with `python -m memory_profiler`.

```python
from memory_profiler import profile

@profile(precision=4)
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a
```

--------------------------------

### Customizing @profile Decorator Output and Stream

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

The `@profile` decorator can be customized with `precision` for decimal places in memory reporting and `stream` to redirect output to a file. This allows for more controlled and persistent memory profiling results.

```python
from memory_profiler import profile

# Write profiling output to a file with 4 decimal places of precision
fp = open('memory_profile.log', 'w+')

@profile(precision=4, stream=fp)
def allocate_arrays():
    small_array = [1] * (10 ** 5)
    large_array = [2] * (10 ** 6)
    del large_array
    return small_array

@profile(precision=4, stream=fp)
def process_strings():
    strings = ['hello' * 1000 for _ in range(10000)]
    processed = [s.upper() for s in strings]
    return len(processed)

if __name__ == '__main__':
    allocate_arrays()
    process_strings()
    fp.close()
```

--------------------------------

### Programmatic Control with LineProfiler Class

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

This snippet shows how to use the `LineProfiler` class for programmatic control over profiling. It covers registering functions, enabling/disabling profiling, and displaying results, including using `LineProfiler` as a context manager.

```python
from memory_profiler import LineProfiler, show_results
import sys

def function_to_profile(n):
    data = list(range(n))
    squared = [x**2 for x in data]
    filtered = [x for x in squared if x % 2 == 0]
    return filtered

def another_function(items):
    result = []
    for item in items:
        result.append(item * 2)
    return result

# Create profiler with options
profiler = LineProfiler(
    include_children=False,
    backend='psutil'
)

# Register functions to profile
profiler.add_function(function_to_profile)
profiler.add_function(another_function)

# Enable profiling
profiler.enable()

# Run code
result1 = function_to_profile(100000)
result2 = another_function(result1)

# Disable profiling
profiler.disable()

# Display results
show_results(profiler, stream=sys.stdout, precision=2)

# Alternative: use as context manager
profiler2 = LineProfiler()
profiler2.add_function(function_to_profile)

with profiler2:
    function_to_profile(50000)

show_results(profiler2)
```

--------------------------------

### Track Memory Usage with Child Process Tracking (Python)

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

This snippet demonstrates how to use `memory_usage` to track memory consumption, including that of child processes spawned using the `multiprocessing` module. It shows two approaches: summing all child processes' memory with the parent and tracking each child process individually. Requires the `memory_profiler` library.

```python
from memory_profiler import memory_usage
import multiprocessing as mp
import time

def worker_task(size, duration):
    """Allocate memory and hold it for a duration."""
    data = [1] * size
    time.sleep(duration)
    return len(data)

def spawn_workers():
    """Spawn multiple worker processes."""
    pool = mp.Pool(processes=4)
    tasks = [
        pool.apply_async(worker_task, (10**6, 2)),
        pool.apply_async(worker_task, (10**6, 2)),
    ]
    results = [t.get() for t in tasks]
    pool.close()
    pool.join()
    return results

# Include children's memory summed with parent
mem_with_children = memory_usage(
    (spawn_workers, (), {}),
    include_children=True,
    interval=0.5
)
print(f"Total memory (parent + children): {mem_with_children}")

# Track each child process separately
mem_multiprocess = memory_usage(
    (spawn_workers, (), {}),
    multiprocess=True,
    interval=0.5
)
print(f"Memory per process: {mem_multiprocess}")
# Output shows nested lists: [[parent_mem, child1_mem, child2_mem], ...]
```

--------------------------------

### Generate Flame Graph Plot with mprof

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This command generates a flame graph visualization of memory usage from a recorded `mprof` run. This plot type is useful for understanding function call stacks and their associated memory consumption. It relies on `mprof` and matplotlib.

```bash
mprof plot --flame
```

--------------------------------

### Set Memory Threshold for Debugger Breakpoint

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

This command allows you to set a memory usage threshold (in MB) to automatically trigger a `pdb` debugger session. When a decorated function exceeds this threshold, execution pauses, enabling in-depth debugging. This requires the `@profile` decorator and `memory_profiler`.

```bash
python -m memory_profiler --pdb-mmem=100 my_script.py
```

--------------------------------

### TimeStamper Class for Function Timing and Blocks

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

Illustrates the usage of the `TimeStamper` class for recording entry and exit timestamps of functions and code blocks. It supports different backends and can be used as a decorator or a context manager. The results can be displayed using `show_results()`.

```python
from memory_profilers import TimeStamper
import time

# Create timestamper
ts = TimeStamper(backend='psutil', include_children=False)

@ts
def step_one():
    data = [1] * (10**6)
    time.sleep(0.1)
    return data

@ts
def step_two(data):
    processed = [x * 2 for x in data]
    time.sleep(0.1)
    return processed

@ts
def step_three(data):
    result = sum(data)
    time.sleep(0.1)
    return result

# Run functions
data = step_one()
processed = step_two(data)
result = step_three(processed)

# Show timestamp results
ts.show_results()

# Use timestamp context manager for blocks
with ts.timestamp("data_processing_block"):
    data = [i**2 for i in range(100000)]
    filtered = [x for x in data if x % 2 == 0]

ts.show_results()
```

--------------------------------

### Redirect Memory Profiler Output to a Logger

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Redirects the memory profiler output to Python's logging module, allowing for more advanced log management, such as using RotatingFileHandler. The sys.stdout is replaced with a LogFile instance.

```python
from memory_profiler import LogFile
import sys
sys.stdout = LogFile('memory_profile_log')
```

--------------------------------

### Customized Memory Profiler Reporting (Increment Only)

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Configures the memory profiler to only report entries with memory increments by setting reportIncrementFlag to False in the LogFile class. This helps in filtering out non-essential memory usage data.

```python
from memory_profiler import LogFile
import sys
sys.stdout = LogFile('memory_profile_log', reportIncrementFlag=False)
```

--------------------------------

### Monitor Memory Usage of Current Process

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Monitors the memory usage of the current Python process over a specified interval and timeout. It returns a list of memory usage values in MiB. The PID can be set to -1 to monitor the current process.

```python
from memory_profiler import memory_usage
mem_usage = memory_usage(-1, interval=.2, timeout=1)
print(mem_usage)
```

--------------------------------

### Measure Peak Memory Usage in IPython using %memit

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Measures the peak memory consumption of a Python expression in IPython using the %memit magic command. It reports the peak memory usage and the increment during execution.

```python
In [1]: %memit range(10000)
peak memory: 21.42 MiB, increment: 0.41 MiB

In [2]: %memit range(1000000)
peak memory: 52.10 MiB, increment: 31.08 MiB
```

--------------------------------

### Line-by-Line Memory Analysis with @profile Decorator

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

The `@profile` decorator from the memory_profiler library enables line-by-line memory profiling of Python functions. It displays memory usage, increments, and counts for each line executed within the decorated function. This helps identify memory-intensive operations.

```python
from memory_profiler import profile

@profile
def process_data():
    # Allocate a list of 1 million integers (~7.6 MiB)
    a = [1] * (10 ** 6)

    # Allocate a larger list of 20 million integers (~152 MiB)
    b = [2] * (2 * 10 ** 7)

    # Delete the large list to free memory
    del b

    return a

if __name__ == '__main__':
    result = process_data()

# Output:
# Line #    Mem usage    Increment  Occurrences   Line Contents
# ============================================================
#      3   38.816 MiB   38.816 MiB           1   @profile
#      4                                         def process_data():
#      5   46.492 MiB    7.676 MiB           1       a = [1] * (10 ** 6)
#      6  199.117 MiB  152.625 MiB           1       b = [2] * (2 * 10 ** 7)
#      7   46.629 MiB -152.488 MiB           1       del b
#      8   46.629 MiB    0.000 MiB           1       return a
```

--------------------------------

### Programmatic Memory Tracking with memory_usage()

Source: https://context7.com/pythonprofilers/memory_profiler/llms.txt

The `memory_usage()` function from memory_profiler allows programmatic tracking of memory consumption for the current process, specific functions, or arbitrary code snippets. It supports configurable intervals, timeouts, and can return maximum usage or values with timestamps.

```python
from memory_profiler import memory_usage
import time

# Monitor current process for 1 second with 0.2s intervals
mem_usage = memory_usage(-1, interval=0.2, timeout=1)
print(f"Current process memory samples: {mem_usage}")
# Output: Current process memory samples: [45.32, 45.32, 45.32, 45.32, 45.32]

# Monitor a function by passing it as a tuple (func, args, kwargs)
def heavy_computation(size, multiplier=1):
    time.sleep(0.5)
    data = [i * multiplier for i in range(size)]
    time.sleep(0.5)
    return sum(data)

mem_usage = memory_usage(
    (heavy_computation, (1000000,), {'multiplier': 2}),
    interval=0.1,
    timeout=5
)
print(f"Function memory usage over time: {mem_usage}")
# Output: Function memory usage over time: [45.5, 46.2, 78.4, 78.4, 78.5, ...]

# Get maximum memory usage only
max_mem = memory_usage(
    (heavy_computation, (1000000,), {}),
    max_usage=True
)
print(f"Maximum memory used: {max_mem} MiB")
# Output: Maximum memory used: 85.2 MiB

# Get memory with timestamps
mem_with_time = memory_usage(-1, interval=0.1, timeout=0.5, timestamps=True)
print(f"Memory with timestamps: {mem_with_time}")
# Output: Memory with timestamps: [(45.3, 1699123456.789), (45.3, 1699123456.889), ...]

# Get function return value along with memory usage
mem_usage, result = memory_usage(
    (heavy_computation, (100000,), {}),
    retval=True
)
print(f"Memory: {mem_usage}, Result: {result}")
```

--------------------------------

### Monitor Memory Usage of a Python Function

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

Monitors the memory usage of a specified Python function with its arguments. The function and its arguments are passed as a tuple to the memory_usage function. This allows for detailed memory profiling of specific code blocks.

```python
def f(a, n=100):
    import time
    time.sleep(2)
    b = [a] * n
    time.sleep(1)
    return b

from memory_profiler import memory_usage
memory_usage((f, (1,), {'n' : int(1e6)}))
```

--------------------------------

### Customize mprof Plot Title and Settings

Source: https://github.com/pythonprofilers/memory_profiler/blob/master/README.rst

These commands show how to customize the memory usage plots generated by `mprof`. You can set a custom title using `-t`, hide function timestamps with `-n`, and plot trend lines with slope information using `-s` to identify potential memory leaks. These require `mprof` and matplotlib.

```bash
mprof plot -t 'Recorded memory usage'
mprof plot -n
mprof plot -s
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.