从实例中查找属性

Question

From Python in a Nutshell

Getting an attribute from an instance

When you use the syntax x.name to refer to an attribute of instance x of class C , the lookup proceeds in three steps:

1. When name is found in C (or in one of C 's ancestor classes) as the name of an overriding descriptor v (ie, 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 (according to the same two-step lookup used for C.name , as just detailed)

   • When a descriptor v is found, the overall result of the attribute lookup is, again, type(v).__get__(v, x, C)

   • When a nondescriptor value v is found, the overall result of the attribute lookup is just v

When these lookup steps do not find an attribute, Python raises an AttributeError exception. However, for lookups of x.name , when C defines or inherits the special method __getattr__ , Python calls C.__getattr__(x,'name') rather than raising the exception. It's then up to __getattr__ to either return a suitable value or raise the appropriate exception, normally AttributeError .

1. Are step 1 and the first part of step 3 the same? If yes, why does the same step appear twice?

2. Do they both happen "when name is found in C (or in one of C 's ancestor classes) as the name of an overriding descriptor v " ?

---

 __getattribute__(self, name) 

At every request to access attribute xy , Python calls x.__getattribute__('y') , which must get and return the attribute value or else raise AttributeError . The normal semantics of attribute access (using x.__dict__ , C.__slots__ , C 's class attributes, x.__getattr__ ) are all due to object.__getattribute__ . When class C overrides __getattribute__ , it must implement all of the attribute access semantics it wants to offer. Most often, the most convenient way to implement attribute access semantics is by delegating (eg, calling object.__getattribute__(self, ...) as part of the operation of your override of __getattribute__ ).

Answer 1

Are step 1 and the first part of step 3 the same? If yes, why the same step appear twice?

Step 1 requires both __get__ and __set__ (although actually, either __set__ or __delete__ along with __get__ would trigger it). Step 3 happens unconditionally if the attribute isn't found through steps 1 or 2.

Do they both happen "when name is found in C (or in one of C's ancestor classes) as the name of an overriding descriptor v"?

No. An "overriding descriptor" triggers step 1; another kind of descriptor or a non-descriptor will only be considered in step 3. (The official Python docs don't use the term "overriding descriptor"; they refer to a descriptor with __set__ or __delete__ as a "data descriptor", and if a data descriptor has __get__ , the __get__ will take priority over an object found in an instance dict.)