Python's memory management is based on reference counting and garbage collection mechanisms. 1. The reference counting mechanism ensures that objects are released immediately when the number of references is 0. The return value of sys.getrefcount() is 1 more than the actual reference because it increases its reference itself; 2. Circular references cannot be cleaned through reference counting, and it depends on the generational recycling of the gc module. Calling gc.collect() can recycle unreachable objects; 3. In actual development, long-term holding of large object references should be avoided. We can use weakref weak references, timely place None to release memory, and use tracemalloc to monitor memory allocation; 4. Summary: Python combines reference counting and garbage collection to manage memory. Developers can improve program efficiency through reasonable use of tools and optimized reference management. Although memory management is automatic, it needs to pay attention to the risks of circular references and memory leakage.

Python's memory management is mostly automated for developers, but understanding its underlying mechanisms can help write more efficient code. Here is a concrete example to illustrate how Python memory management works, including reference counting, garbage collection, and object lifecycle.

1. Example of reference counting mechanism

Python uses reference counts to track the usage of objects. When an object's reference count becomes 0, it is immediately released.

 import sys

# Create a list object a = [1, 2, 3]
print(sys.getrefcount(a)) # Output: 2 (a and getrefcount parameters references)

b = a
print(sys.getrefcount(a)) # Output: 3

c = a
print(sys.getrefcount(a)) # Output: 4

# Delete the reference del b
print(sys.getrefcount(a)) # Output: 3

del c
print(sys.getrefcount(a)) # Output: 2

del a
# At this time, the reference count is 0 and the object is released

?? Note: sys.getrefcount() itself adds a reference, so the result is always 1 more than the actual one.

2. Recycling References and Garbage Collection (GC)

Reference counting cannot handle circular references, so Python's garbage collector (gc module) is needed.

 import gc

# Create a circular reference def create_cycle():
    x = {}
    y = {}
    x['y'] = y
    y['x'] = x
    return x # Return the reference, but the internal loop reference z = create_cycle()
# z points to a circular reference structure del z # Delete external references, but x and y still refer to each other# Manually trigger garbage collection collected = gc.collect()
print(f"Retrieve {collected} objects") # Usually output 2 (two dictionaries)

In this example, even if no variables refer to these two dictionaries after del z , they still cannot be released by reference counting because they refer to each other. Python's generational garbage collector detects and cleanses such unreachable objects.

3. Memory management tips (practical suggestions)

• Avoid unnecessary large object references : for example, when caching large amounts of data, consider using weak references ( weakref ).
• Dereference large objects in time : Set to None after processing big data to help quickly release memory.
• Monitor memory usage : You can use the tracemalloc module to track memory allocation.

 import tracemalloc

tracemalloc.start()

# simulate memory allocation data = [i for i in range(10000)]

current, peak = tracemalloc.get_traced_memory()
print(f"Current memory usage: {current / 1024:.1f} KB")
print(f"Peak Memory Usage: {peak / 1024:.1f} KB")

tracemalloc.stop()

4. Summary of key points

• Python manages memory using the reference counting garbage collection mechanism.
• The object is released immediately when the reference count is 0.
• Recycling references require auxiliary cleaning of the GC module.
• Developers can optimize memory usage through tools such as gc and tracemalloc .

Basically all this is not complicated but easy to ignore.

The above is the detailed content of python memory management example. For more information, please follow other related articles on the PHP Chinese website!