Errata

#### **Error description:**

The book's description of the attribute lookup process states that when accessing an attribute `x.name`, Python first checks if `name` exists as an overriding descriptor in the class `C` *or any of its ancestor classes*. This implies that the entire Method Resolution Order (MRO) is scanned for a data descriptor *before* any other lookup steps are taken.

However, this is incorrect. The actual behavior, as confirmed by the official Python documentation and empirical testing, is that Python finds the **first** occurrence of the attribute in the MRO and *then* determines how to proceed based on whether that first match is a data descriptor, a non-data descriptor, or a regular attribute.

As a result, a data descriptor in an ancestor class will **not** override a non-data-descriptor or even a regular attribute of the same name in a descendant class.

-----

#### **The problematic text:**

> When you use the syntax `x.name` to refer to an attribute of instance `x` of class `C`, lookup proceeds in three steps:
>
> 1. When `name` is in `C` (or in one of `C`'s ancestor classes) as the name of an overriding descriptor `v` (i.e., `type(v)` supplies methods `__get__` and `__set__`) the value of `x.name` is the result of `type(v).__get__(v, x, C)`.
> 2. Otherwise, when `name` is a key in `x.__dict__`, `x.name` fetches and returns the value at `x.__dict__['name']`.
> 3. Otherwise, `x.name` delegates the lookup to `x`'s class...

The key issue is in step 1's phrase "or in one of C's ancestor classes", which suggests a full preliminary scan.

-----

#### **Example that shows the discrepancy:**

This code shows that a regular class attribute (a string) in an intermediate class is found and used before the overriding (data) descriptor of the same name in an ancestor class.

```python
class OverridingMethodDescriptor:
"""A simple data descriptor with both __get__ and __set__."""
def __get__(self, instance, owner):
return "I am from the Grandparent's data descriptor"
def __set__(self, instance, value):
raise AttributeError("Cannot set")

class Grandparent:
# The data descriptor is defined in the highest ancestor.
special_attribute = OverridingMethodDescriptor()

class Parent(Grandparent):
# A regular, non-descriptor attribute is defined in the intermediate class.
special_attribute = "I am a simple string in Parent"

class Child(Parent):
# This class is empty and inherits from Parent.
pass

# MRO for Child is: (Child, Parent, Grandparent, object)
# The lookup for 'special_attribute' will find the string in Parent first.
c = Child()
print(c.special_attribute)

# Expected output based on the book's description (data descriptor should win):
# "I am from the Grandparent's data descriptor"

# Actual output (the first match in the MRO wins):
# "I am a simple string in Parent"
```

-----

#### **Suggested correction:**

The description of the lookup process should be rephrased to reflect that the MRO is traversed only once to find the first match. The logic then proceeds based on the type of that match.

A more accurate description of the lookup for `x.name` would be:

1. Search the MRO of `type(x)` for the **first occurrence** of the name `name`. Let this be `attr`. If not found, raise `AttributeError`.
2. If `attr` is a data descriptor (i.e., it has a `__set__` or `__delete__` method), return the result of its `__get__` method. The lookup stops here.
3. Otherwise, check if `name` exists in the instance's `__dict__`. If it does, return that value. The lookup stops here.
4. Otherwise, if `attr` is a non-data descriptor (i.e., it has a `__get__` method but no `__set__`), return the result of its `__get__` method.
5. Otherwise (if `attr` is a regular class attribute), return `attr` itself.

This revised logic correctly explains the behavior seen in the demonstration code and aligns with the official Python documentation on descriptors (in particular the definition of `object_getattribute`).