TLDR: The attribute is the value produced by looking up the attribute name.
According to the Python Language Reference, Attribute references, in the statement
value = obj.name
obj.name is an attribute reference, name is the attribute name, and the produced value is the attribute. Note that value is the attribute in this case because it was produced by the attribute reference, not because it is inherently related. For example, an attribute reference may produce a new value every time it is evaluated.
The primary must evaluate to an object of a type that supports attribute references, which most objects do. This object is then asked to produce the attribute whose name is the identifier. This production can be customized by overriding the
__getattr__()method. If this attribute is not available, the exception AttributeError is raised. Otherwise, the type and value of the object produced is determined by the object. Multiple evaluations of the same attribute reference may yield different objects.
In an attribute assignment such as
obj.name = value
the value does not necessarily become the attribute. If the attribute name points to a data descriptor, value may be stored, modified or discarded.
First let's talk about general objects in Python. The documentation defines 3 characteristics for every object:
- identity
An object’s identity never changes once it has been created; you may think of it as the object’s address in memory.
- type
An object’s type determines the operations that the object supports (e.g., “does it have a length?”) and also defines the possible values for objects of that type. The type() function returns an object’s type (which is an object itself). Like its identity, an object’s type is also unchangeable.
- value
The value of some objects can change. Objects whose value can change are said to be mutable; objects whose value is unchangeable once they are created are called immutable.
Understanding objects means understanding types, but types are objects also. These TypeObjects are one of the most important structures in Python and define the basic functionality of an object. Specifically they implement the getattr and setattr functions.
The default behavior for this implementation is described here:
The default behavior for attribute access is to get, set, or delete the attribute from an object’s dictionary. For instance,
a.xhas a lookup chain starting witha.__dict__['x'], thentype(a).__dict__['x'], and continuing through the base classes oftype(a)excluding metaclasses. If the looked-up value is an object defining one of the descriptor methods, then Python may override the default behavior and invoke the descriptor method instead. [...]
the methods for an class or an instance which can overwrite the default behaviour are __get__, __set__ and __delete__.
The documentation for the __get__ method specifies:
This method should return the computed attribute value or raise an AttributeError exception.
Summarizing all the above, my formal definition for an attribute would be along the lines of:
- attributes are objects with identity, type and value
- they are owned by another object
Further reading:
https://docs.python.org/3/reference/datamodel.html
https://docs.python.org/3/c-api/typeobj.html
https://docs.python.org/3/howto/descriptor.html?highlight=descriptor
https://realpython.com/python-descriptors/