Attribute Interception and Management in Python

Problem Description:
In Python, when accessing, setting, or deleting an object's attributes, the interpreter follows a specific lookup chain. The attribute interception mechanism allows developers to customize attribute access behavior through special methods (such as __getattr__, __getattribute__, __setattr__, and __delattr__). Please explain the roles, differences, and typical use cases of these methods, and describe how to avoid common pitfalls (such as infinite recursion).

Solution Process:

1. Basic Attribute Access Flow

When accessing an attribute via obj.attr, the Python interpreter looks it up in the following order:

1. Instance Attribute: Checks if attr exists in obj.__dict__.
2. Class Attribute: Checks the __dict__ of the class (obj.__class__) and its inheritance chain.
3. Attribute Interception Methods: If not found, __getattr__ may be triggered (only when the attribute does not exist).

Note: The __getattribute__ method is triggered on every attribute access and has the highest priority.

2. Detailed Explanation of Key Methods

(1) __getattr__(self, name)

• Trigger Condition: Called when the normal attribute lookup (instance, class, inheritance chain) fails.
• Typical Use: Implementing "virtual attributes" (e.g., dynamically computed values), the proxy pattern, or providing friendly error messages.

class DynamicAttributes:
    def __getattr__(self, name):
        if name == "virtual_attr":
            return "Dynamically computed attribute value"
        raise AttributeError(f"Attribute {name} does not exist")

obj = DynamicAttributes()
print(obj.virtual_attr)  # Output: Dynamically computed attribute value
print(obj.invalid_attr)  # Triggers AttributeError

(2) __getattribute__(self, name)

• Trigger Condition: Called on every attribute access (including existing attributes).
• Risk: If implemented incorrectly (e.g., internally accessing self.xxx again), it can easily lead to infinite recursion.
• Safe Implementation: Must access attributes via super().__getattribute__() or object.__getattribute__().

class LoggingAttributes:
    def __getattribute__(self, name):
        print(f"Accessing attribute: {name}")
        return super().__getattribute__(name)  # Key: Avoid recursion

obj = LoggingAttributes()
obj.x = 10
print(obj.x)  # First prints log, then returns 10

(3) __setattr__(self, name, value)

• Trigger Condition: Called every time an attribute is set (e.g., obj.attr = value).
• Common Pitfall: Directly using self.name = value will trigger __setattr__ again, causing recursion.
• Correct Approach: Operate on self.__dict__ or call the parent class method.

class SafeSetter:
    def __setattr__(self, name, value):
        if name == "readonly_attr":
            raise AttributeError("Read-only attribute cannot be modified")
        super().__setattr__(name, value)  # Or self.__dict__[name] = value

obj = SafeSetter()
obj.flexible_attr = "Modifiable"  # Normal
obj.readonly_attr = "Value"       # Triggers AttributeError

(4) __delattr__(self, name)

• Trigger Condition: Called when deleting an attribute (del obj.attr).
• Implementation Key: Similarly, avoid direct del self.name to prevent recursion.

class ProtectedDeleter:
    def __delattr__(self, name):
        if name.startswith("protected_"):
            raise AttributeError("Protected attribute cannot be deleted")
        super().__delattr__(name)

obj = ProtectedDeleter()
obj.protected_data = "Important Data"
del obj.protected_data  # Triggers error

3. Method Comparison and Priority

Priority Example:

class Test:
    def __getattribute__(self, name):
        print("Calling __getattribute__")
        return super().__getattribute__(name)
    
    def __getattr__(self, name):
        print("Calling __getattr__")
        return "Default Value"

obj = Test()
obj.existing_attr = "Exists"
print(obj.existing_attr)  # Only triggers __getattribute__
print(obj.non_existing)   # First triggers __getattribute__, then __getattr__

4. Practices to Avoid Infinite Recursion

• In __getattribute__:
  Prohibit direct access to self.attr or self.__dict__[attr] (the latter also triggers __getattribute__). Must use super() or object class methods.

  # Incorrect example (recursion):
  def __getattribute__(self, name):
      return self.__dict__[name]  # Triggers itself again!
  
  # Correct example:
  def __getattribute__(self, name):
      return object.__getattribute__(self, name)
  

• In __setattr__:
  Avoid self.name = value, use self.__dict__[name] = value or super().__setattr__(name, value) instead.

5. Practical Application Scenarios

• Data Validation: Check the validity of attribute values (e.g., type, range) via __setattr__.
• Lazy Evaluation: Dynamically generate time-consuming attribute values in __getattr__.
• Proxy Pattern: Forward attribute access to internal objects (e.g., return self._internal.attr).
• Attribute Aliasing: Map old attribute names to new names via __getattribute__.

class LazyLoader:
    def __init__(self):
        self._data = None
    
    def __getattr__(self, name):
        if name == "heavy_data":
            if self._data is None:
                print("Loading time-consuming data...")
                self._data = "Simulated Data"
            return self._data
        raise AttributeError

obj = LazyLoader()
print(obj.heavy_data)  # Loads on first access
print(obj.heavy_data)  # Returns cached data directly

6. Summary

• __getattr__ and __getattribute__ handle "missing attributes" and "all access" respectively; they must be clearly distinguished.
• Always use super() or object class methods when operating on attributes to avoid recursion.
• Proper use of these methods enables flexible data encapsulation, dynamic behavior, and security control.