Attribute Access and Descriptor Protocol in Python

Description
In Python, attribute access (such as obj.attr) may seem simple, but it involves underlying mechanisms like __getattribute__, __getattr__, and the descriptor protocol. Understanding these mechanisms helps developers control object behavior and avoid subtle bugs. For example, why can @property implement computed attributes? How do descriptors intercept attribute operations? These are key points in interviews to assess the depth of understanding of Python's object model.

Knowledge Explanation

1. Basic Attribute Access Flow
   When accessing obj.attr, Python searches for the attribute in the following order:

   • First, check if attr is a descriptor defined in the object's class or parent class (i.e., a class attribute that implements the __get__ method).
   • If no descriptor is found, look for an instance attribute in obj.__dict__.
   • If still not found, continue searching for class attributes in the class's __dict__ and the parent class chain.
   • If all attempts fail, trigger __getattr__ (if defined) or raise an AttributeError.

2. Core Methods of the Descriptor Protocol
   A descriptor is a class that implements any of the following methods:

   • __get__(self, obj, type=None) -> value: Intercepts attribute reading.
   • __set__(self, obj, value) -> None: Intercepts attribute assignment.
   • __delete__(self, obj) -> None: Intercepts attribute deletion.
     Based on whether __set__ is implemented, descriptors are divided into:
   • Data Descriptor (implements __set__): Has higher priority than instance attributes (e.g., @property).
   • Non-Data Descriptor (implements only __get__): Has lower priority than instance attributes (e.g., function methods defined in a class).

3. The Essence of the @property Decorator
   @property is a built-in data descriptor. For example:

   class Circle:
       def __init__(self, radius):
           self.radius = radius
   
       @property
       def area(self):
           return 3.14 * self.radius ** 2
   

   • When accessing c.area, the __get__ method of the property class is called to dynamically compute the value.
   • Because property implements __set__ (which prohibits assignment by default), it is a data descriptor. Even if an instance has __dict__['area'], the descriptor is called first.

4. Practical Example of a Custom Descriptor
   Suppose type validation is needed for assignment:

   class TypedDescriptor:
       def __init__(self, name, expected_type):
           self.name = name
           self.expected_type = expected_type
   
       def __get__(self, obj, objtype):
           if obj is None:
               return self  # Return the descriptor itself when accessed via the class
           return obj.__dict__.get(self.name)
   
       def __set__(self, obj, value):
           if not isinstance(value, self.expected_type):
               raise TypeError(f"Expected {self.expected_type}")
           obj.__dict__[self.name] = value  # Store in the instance dictionary
   
   class Person:
       name = TypedDescriptor("name", str)  # Class attribute is a descriptor instance
       age = TypedDescriptor("age", int)
   
       def __init__(self, name, age):
           self.name = name  # Triggers __set__
           self.age = age
   

   • When executing p = Person("Alice", 30), self.name = name actually calls TypedDescriptor.__set__ for type checking.
   • When reading p.name, __get__ is called to return the value from the instance's __dict__.

5. Relationship Between Descriptors and __getattribute__

   • All attribute access is ultimately handled by the object.__getattribute__ method, which has built-in logic for the descriptor protocol.
   • If you override __getattribute__, you must manually call super().__getattribute__() or handle descriptors; otherwise, the protocol may be broken.

Summary
The underlying mechanisms of attribute access reflect Python's philosophy of "convention over configuration." The descriptor protocol is the foundation for advanced features (such as ORM fields and property validation). Key points to remember: data descriptors have the highest priority, followed by non-data descriptors, and finally instance attributes.