Pympler

Warnings

• breaking Pympler dropped support for Python 2.7 and Python 3.5 starting with version 1.0. Older Python versions require Pympler < 1.0.
  Fix: Upgrade to Python 3.6+ or use an older Pympler version (e.g., `pip install 'Pympler<1.0'` for Python 2.7/3.5).
• gotcha Repeated calls to `muppy.get_objects()` in a tight loop can themselves consume significant memory, potentially masking or exacerbating actual memory leak issues. The `get_objects()` function collects references to all live Python objects.
  Fix: Use `tracker.SummaryTracker` and `print_diff()` for analyzing memory changes over time, which is designed for efficient diffing. If `muppy.get_objects()` is necessary, ensure careful management of the returned object list to avoid accumulating references.
• gotcha The `asizeof` module's accuracy can be affected by internal CPython object layout changes in newer Python versions, potentially leading to discrepancies in reported sizes for certain object types.
  Fix: Be aware of this limitation for critical memory analysis. Cross-reference with `sys.getsizeof` for shallow sizes or consider using `tracemalloc` for different perspectives on memory allocation if absolute precision for all object types is crucial.
• gotcha Pympler operations, particularly those that traverse the entire object graph (e.g., `muppy.get_objects()`, `asizeof.asizeof()` on complex objects), can be computationally intensive and may introduce a noticeable performance overhead in performance-critical applications.
  Fix: Use Pympler primarily during development and testing phases. In production, use sparingly or integrate only highly optimized, targeted checks. Avoid calling such functions frequently in performance-sensitive code paths.

Install

• pip install Pympler Install latest version

Imports

• asizeof

  from pympler import asizeof

  For sizing individual Python objects recursively.
• muppy

  from pympler import muppy

  For on-line monitoring of all objects in a Python application.
• summary

  from pympler import summary

  To format and print summaries of object lists obtained from muppy or classtracker.
• tracker

  from pympler import tracker

  For tracking changes in overall memory or specific class instances over time.

Quickstart

This quickstart demonstrates basic memory profiling using `pympler.asizeof` to get the recursive size of an object, and `pympler.muppy` and `pympler.summary` to get a snapshot and diff of all objects in memory. It also includes a simplified example of `pympler.tracker` to show changes over time.

from pympler import asizeof, muppy, summary

class MyObject:
    def __init__(self, data):
        self.data = data
        self.large_list = [0] * 1000 # A list consuming some memory

# 1. Measure the size of an individual object recursively
obj = MyObject('some string data')
print(f"Size of obj: {asizeof.asizeof(obj)} bytes")

# 2. Get a summary of all objects in memory
all_objects_before = muppy.get_objects()
sum1 = summary.summarize(all_objects_before)
print("\n--- Memory Summary (Before) ---")
summary.print_(sum1, limit=5) # Print top 5 largest object types

# Create more objects
my_list = [MyObject(f'data_{i}') for i in range(10)]

# 3. Get a diff in memory usage
all_objects_after = muppy.get_objects()
sum2 = summary.summarize(all_objects_after)
print("\n--- Memory Summary (After, diff) ---")
diff = summary.diff(sum1, sum2)
summary.print_(diff, limit=5) # Print top 5 changes

# Example of tracker for change over time (simplified)
tr = tracker.SummaryTracker()

# Perform some operations that might create new objects
def create_temp_objects():
    local_list = ["temp_str"] * 500

create_temp_objects()

print("\n--- Tracker Diff after create_temp_objects() ---")
tr.print_diff(limit=5)