GNU Info

(python2.1-ref.info)Customizing attribute access

---

Next: Emulating callable objects Prev: Basic customization Up: Special method names

---

Enter node , (file) or (file)node

Customizing attribute access
----------------------------

The following methods can be defined to customize the meaning of
attribute access (use of, assignment to, or deletion of `x.name') for
class instances.  For performance reasons, these methods are cached in
the class object at class definition time; therefore, they cannot be
changed after the class definition is executed.

`__getattr__(self, name)'
     Called when an attribute lookup has not found the attribute in the
     usual places (i.e. it is not an instance attribute nor is it found
     in the class tree for `self').  `name' is the attribute name.
     This method should return the (computed) attribute value or raise
     an `AttributeError' exception.

     Note that if the attribute is found through the normal mechanism,
     `__getattr__()' is not called.  (This is an intentional asymmetry
     between `__getattr__()' and `__setattr__()'.)  This is done both
     for efficiency reasons and because otherwise `__setattr__()' would
     have no way to access other attributes of the instance.  Note that
     at least for instance variables, you can fake total control by not
     inserting any values in the instance attribute dictionary (but
     instead inserting them in another object).

`__setattr__(self, name, value)'
     Called when an attribute assignment is attempted.  This is called
     instead of the normal mechanism (i.e. store the value in the
     instance dictionary).  NAME is the attribute name, VALUE is the
     value to be assigned to it.

     If `__setattr__()' wants to assign to an instance attribute, it
     should not simply execute `self.NAME = value' -- this would cause
     a recursive call to itself.  Instead, it should insert the value
     in the dictionary of instance attributes, e.g.,
     `self.__dict__[NAME] = value'.

`__delattr__(self, name)'
     Like `__setattr__()' but for attribute deletion instead of
     assignment.  This should only be implemented if `del obj.NAME' is
     meaningful for the object.