Weak references do not increase the object reference count, allowing objects to be garbage collected, while strong references will prevent recycling; 2. Use weakref.ref to create weak references. When the object is destroyed, weak references return None; 3. WeakKeyDictionary takes the object as the key and does not prevent its recycling, which is suitable for caching; 4. WeakSet can be used in observer mode to avoid circular references and memory leaks caused by strong references; 5. Weak references are only suitable for hashable objects, and common tools include weakref.ref, WeakKeyDictionary, WeakValueDictionary and WeakSet; Weak references are an effective mechanism for managing memory and avoiding circular references, and are widely used in cache, callbacks and observer modes.

Weak reference in Python is a reference method that does not increase the object reference count. It allows you to refer to an object, but does not prevent the object from being garbage collected. This is very useful when caching, observer pattern, or avoiding circular references.

Here is a simple weak reference example to help you understand its basic usage.

? What is a weak quote?

Normal references (strong references) will prevent objects from being recycled:

 a = [1, 2, 3]
b = a # Strong reference, a will not be recycled

And weak references do not prevent recycling:

 import weakref

a = [1, 2, 3]
w = weakref.ref(a) # Create weak reference print(w()) # Output: [1, 2, 3], get the object del a through w() # Delete the original reference print(w()) # Output: None, the object has been recycled

? Practical example: Use weak reference to implement cache (WeakKeyDictionary)

Suppose you have a class that wants to cache data related to certain instances, but you don't want the cache to prevent the instance from being destroyed.

 import weakref

# Simulate a cache: the key is an object instance, and the value is some additional data cache = weakref.WeakKeyDictionary()

class Person:
    def __init__(self, name):
        self.name = name
        # Put some data into the cache cache[self] = f"Profile data for {name}"

    def __repr__(self):
        return f"Person({self.name})"

    def __del__(self):
        print(f"{self.name} was destroyed")

# Use example p = Person("Alice")
print("Data in cache:", cache[p])

p = None # Delete the reference, the object can be recycled# At this time, Person("Alice") is destroyed, and the corresponding entries in the cache are automatically cleared print("Cache size:", len(cache)) # Output: 0

Output:

 Data in cache: Profile data for Alice
Alice was destroyed cache size: 0

? Note: When p is set to None , Person instance is destroyed, WeakKeyDictionary automatically removes the key, which will not cause memory leakage.

? Another example: Avoid circular references in observer mode

 import weakref

class Subject:
    def __init__(self):
        # Use weak references to store observers and avoid circular references to self._observers = weakref.WeakSet()

    def add_observer(self, observer):
        self._observers.add(observer)

    def notify(self, msg):
        for observer in self._observers:
            observer.update(msg)

class Observer:
    def __init__(self, name):
        self.name = name

    def update(self, msg):
        print(f"{self.name} message received: {msg}")

    def __del__(self):
        print(f"{self.name} is recycled")

# Test subject = Subject()
obs1 = Observer("Xiao Ming")
obs2 = Observer("Little Red")

subject.add_observer(obs1)
subject.add_observer(obs2)

subject.notify("System updated")

del obs2 # delete obs2
subject.notify("Another message") # Xiaohong will not receive it again

Output:

 Xiao Ming received the message: The system has updated Xiao Hong received the message: The system has updated Xiao Hong was recycled Xiao Ming received the message: Another message

? WeakSet is used here. When obs2 is deleted, it will be automatically removed from _observers without manual cleaning.

?? Notes

• Weak references can only be used for hashable objects (such as class instances), and cannot be used for non-hashable types such as list and dict .
• If the object has no other strong references, the weak reference returns None .
• Common tools:
  • weakref.ref(obj) : Creates a weak reference to an object
  • weakref.WeakKeyDictionary() : The key is a weak reference
  • weakref.WeakValueDictionary() : The value is a weak reference
  • weakref.WeakSet() : The elements in the collection are weak references

Basically that's it. Weak references are powerful tools for managing memory and avoiding circular references, especially when implementing cache, callback, observer and other modes.

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