Скачать или смотреть Understanding Python Memory Management: Why Is Memory Not Released?

Explore why memory isn't released in Python, even when object reference counts drop to zero.
---
This video is based on the question https://stackoverflow.com/q/65289933/ asked by the user 'credtz' ( https://stackoverflow.com/u/14800684/ ) and on the answer https://stackoverflow.com/a/65290344/ provided by the user 'ShadowRanger' ( https://stackoverflow.com/u/364696/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Memory not released, even as object ref count 0

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Python Memory Management: Why Is Memory Not Released?

Python's memory management can be a source of confusion for developers, especially when it appears that memory is not being released even after an object's reference count drops to zero. In this guide, we'll tackle this puzzling problem using a simple code example and a clear breakdown of the underlying mechanisms.

The Problem: Memory Not Released

Consider the following code snippet:

[[See Video to Reveal this Text or Code Snippet]]

Code Explanation

In this code, we define two functions. The memtest() function checks the memory usage of the current process, while myfunc() creates a list of 10 million integers. The key point of interest is that upon calling myfunc(), we expect the memory usage to decrease after x goes out of scope. However, the output shows otherwise:

[[See Video to Reveal this Text or Code Snippet]]

Understanding the Output

Before myfunc(): The memory usage is approximately 9.5 MB.

After myfunc(): The memory usage jumps to about 89.5 MB.

Despite x being out of scope, the memory used seems not to be released.

Why Isn’t the Memory Released?

Reference Counting Basics

Python employs a technique known as reference counting to manage memory. When the reference count of an object drops to zero, it indicates that there are no references to it, and one would expect the memory to be freed. However, memory management in Python is more complex for several reasons:

Allocators Holding Memory: Memory allocators often do not return memory to the operating system immediately. They retain memory to satisfy future needs without having to request new memory, which can be a costly operation.

Immediate Release: The del statement removes the reference to the object, but it does not necessarily guarantee the immediate release of the underlying memory resources. The memory might still be held by the allocator.

Example With del

Let’s investigate further with another test:

[[See Video to Reveal this Text or Code Snippet]]

Again, the output shows:

[[See Video to Reveal this Text or Code Snippet]]

In this case, del x is called to explicitly delete the reference, yet the memory usage still does not drop.

Conclusion: No Immediate Memory Release

To summarize, the observation that your memory is not released, even when a variable's reference count drops to zero (or even when you use del), is explained by:

Memory retention by allocators: They keep the memory to fulfill future allocation requests more efficiently.

Behavior of del: The del statement merely removes the current reference to the object. As the variable is a local one, Python would finalize that variable's scope and release its reference upon completion of the function itself.

When to be Concerned?

If you notice that repeated calls to a function consistently increase memory usage, that could signal a genuine memory leak. However, in many cases, the memory initially used by Python programs is reused for subsequent allocations after being released.

Python's memory management involves many intricate behaviors that can sometimes perplex users, but understanding these mechanisms can greatly enhance your development experience.

By breaking down memory management in this way, we aim to demystify why memory may appear not to release after its references are gone. Remember, the next time you see seemingly excessive memory usage, it might just be Python being efficient.