If your Python application’s memory usage keeps increasing over time, you’re probably dealing with a memory leak. These can cause performance degradation, crashes, or higher costs—especially in long-running processes like web servers, data pipelines, and machine learning workloads.

In this guide, you’ll learn:

• What causes memory leaks in Python
• How to detect them with tracemalloc
• How to fix them
• Best practices to prevent leaks in the future

This is a practical tutorial, with code examples, that will help you track down and eliminate memory leaks in Python applications.

What Is a Python Memory Leak?

A memory leak in Python occurs when an application holds onto memory it no longer needs. Python uses automatic garbage collection, but it isn’t perfect. Some objects may never get released if they’re still referenced somewhere in your code.

Common causes of memory leaks in Python:

• Unclosed file handlers or sockets
• Lingering global variables
• Circular references that confuse the garbage collector
• C extensions that mishandle memory
• Growing data structures (lists, dicts, sets) that aren’t cleared

Why Use tracemalloc to Find Memory Leaks?

tracemalloc is a built-in Python module (Python 3.4+) that helps you trace memory allocation in Python code.

Key benefits of tracemalloc:

• Tracks memory allocation by line number
• Compares memory usage over time with snapshots
• No external installation required (built-in)

By using tracemalloc, you can pinpoint exactly where memory is increasing and why it’s happening.

How to Use tracemalloc to Detect and Fix Python Memory Leaks

Here’s a step-by-step breakdown of how to use tracemalloc effectively.

1. Import tracemalloc and Start Tracing Early

Start tracemalloc at the beginning of your script to capture all memory allocations.

pythonCopyEditimport tracemalloc

tracemalloc.start()

✅ Tip: By default, tracemalloc tracks 1 frame of the traceback. Increase this for deeper analysis:

pythonCopyEdittracemalloc.start(10)

2. Take Memory Snapshots Before and After the Suspected Leak

Snapshots allow you to compare memory usage over time.

pythonCopyEditsnapshot1 = tracemalloc.take_snapshot()

# Run your code that may have memory leaks
leaky_list = []
for _ in range(1000000):
    leaky_list.append("leak" * 1000)

snapshot2 = tracemalloc.take_snapshot()

3. Compare the Snapshots to Find the Leaks

After running the code, compare the two snapshots.

pythonCopyEdittop_stats = snapshot2.compare_to(snapshot1, 'lineno')

print("[ Top 10 Memory Increases ]")
for stat in top_stats[:10]:
    print(stat)

You’ll get output like this:

pgsqlCopyEdit/path/to/your_script.py:12: size=5.2 MiB (+5.2 MiB), count=100000 (+100000)

What does this tell you?

• The file and line number where memory is being allocated
• How much memory has increased
• How many new objects have been created

4. Investigate the Culprit

Once you identify the source of the leak:

• Review the logic—are you accidentally holding references?
• Are lists or dictionaries growing without being cleared?
• Did you forget to close a file, socket, or database connection?

5. Fix the Memory Leak

Depending on the problem, here are common fixes:

• Release unused data structures by clearing them or deleting objects.
• Close resources using with blocks: pythonCopyEditwith open('file.txt', 'r') as f: data = f.read()
• Break circular references with the weakref module if needed: pythonCopyEditimport weakref weak_obj = weakref.ref(obj)
• Fix C extensions that mismanage memory (if applicable).

Real-World Example of Fixing a Memory Leak in Python

Problem:

You have a web scraper that downloads millions of pages, but memory keeps increasing.

Diagnosis with tracemalloc:

The culprit is an ever-growing list:

pythonCopyEditpages = []

for url in urls:
    page = requests.get(url).text
    pages.append(page)  # Unintentional memory retention!

Solution:

Process pages immediately without storing them:

pythonCopyEditfor url in urls:
    page = requests.get(url).text
    process(page)  # No memory bloat

Or explicitly clear the list when done:

pythonCopyEditpages.clear()

tracemalloc Best Practices

To make the most of tracemalloc in large projects:

✅ Start tracemalloc with more frames for deeper traceback

pythonCopyEdittracemalloc.start(25)

✅ Group statistics by traceback for better context

pythonCopyEditstats = snapshot2.statistics('traceback')
for stat in stats[:3]:
    print(stat)
    for line in stat.traceback.format():
        print(line)

✅ Filter snapshots by module or file

pythonCopyEditfor stat in top_stats:
    if "my_module.py" in str(stat.traceback):
        print(stat)

tracemalloc vs memory_profiler vs objgraph: What Should You Use?

• Start with tracemalloc for most Python memory issues.
• Use objgraph when you need to visualize object growth.
• Combine with memory_profiler for process-wide tracking.

Best Practices to Prevent Python Memory Leaks

If you want to avoid memory leaks in Python long-term:

✅ Close file handlers, sockets, and DB connections
✅ Be careful with global variables and long-lived objects
✅ Use weakref to prevent circular references where appropriate
✅ Profile memory usage regularly in long-running processes
✅ Watch out for third-party libraries and C extensions that mishandle memory
✅ Use context managers (with statements) whenever possible

Frequently Asked Questions (FAQ)

What is a memory leak in Python?

A memory leak happens when an application continues to consume memory without releasing it. This often happens when objects remain referenced but are no longer needed.

How do I know if my Python app has a memory leak?

You’ll notice increasing memory usage over time. tracemalloc or process monitoring tools like htop can confirm it. Long-running scripts or servers are especially prone to leaks.

Can Python’s garbage collector fix memory leaks?

Sometimes, but not always. If references to objects are maintained somewhere (even by accident), the garbage collector won’t clean them up. Circular references can also trip it up.

Is tracemalloc available in Python 2?

No. tracemalloc was introduced in Python 3.4. For Python 2, you’ll need third-party tools like objgraph or memory_profiler.

Python memory leaks can be subtle but devastating, especially in long-running applications.
tracemalloc is a powerful tool built into Python that makes detecting and fixing memory leaks straightforward.

Recap of how to fix Python memory leaks with tracemalloc:

1. Start tracemalloc early
2. Take memory snapshots
3. Compare snapshots for differences
4. Analyze and refactor problem code
5. Apply best practices to prevent future leaks

By following this guide, you’ll optimize your Python applications, avoid memory bloat, and keep your systems running efficiently.

🛒 Ready to Level Up Your Dev Game?

Check out the exclusive merch collection for Python developers and software engineers at MadDosh Merch Store!