We've mentioned over and over that attribute bindings are computed only once, but that's not precisely true. It's actually possible for them to be computed zero times, or many times, if we set or delete the attribute the binding defines.
You may have wondered, ``how does a binding know whether it's been computed or not?" It knows because there is an entry in the object's dictionary for that attribute name. (Notice, by the way, that this means objects without dictionaries can't get much use out of bindings.)
But what if there's something already in the dictionary? Or what if you remove the value from the dictionary? Well, it's pretty much as you'd expect. If you set a value for an attribute, then the binding will not compute a value. If you delete the attribute, and try to access it, the binding will recompute the value. This behavior can actually be quite useful in the context of transactions: many PEAK transactional components delete certain bindings at the conclusion of a transaction, allowing them to be recomputed in the next transaction.
PEAK also makes use of the ability to override a binding by manually setting a value for an attribute. For example, most PEAK component classes' __init__ methods accept keyword arguments which can override attributes which would otherwise be determined by bindings. This is especially useful in conjunction with the binding.requireBinding class, which simply raises an error when you try to access the attribute. It's a handy way of specifying that a component must have the attribute, and that a subclass or instance must supply the value.
By the way, it's important to note that bindings do not participate in persistence, as they directly alter the associated object's dictionary, bypassing the normal ``set attribute" machinery. You should carefully consider the use of attribute bindings in persistent objects, as to how they will interact with your persistence machinery (e.g. whether they should be saved or not) and whether you will want to code them in such a way as to consider the object ``changed" when an attribute is computed.