Lazyutils provides a few simple utilities for lazy evaluation of code.
The lazy decorator defines an attribute with deferred initialization:
.. code::python
import math from lazyutils import lazy
- class Vec:
- def __init__(self, x, y):
- self.x, self.y = x, y
@lazy def magnitude(self):
print('computing...') return math.sqrt(self.x**2 + self.y**2)
Now the magnitude
attribute is initialized and cached upon first use:
>>> v = Vec(3, 4)
>>> v.magnitude
computing...
5.0
The attribute is writable and apart from the deferred initialization, it behaves just like any regular Python attribute.
>>> v.magnitude = 42
>>> v.magnitude
42
Lazy attributes can be useful either to simplify the implementation of the __init__ method of objects that initialize a great number or variables or as an optimization that delays potentially expensive computations that may not be necessary in the object's lifecycle.
The delegate_to() function delegates some attribute to an attribute during the class definition:
.. code::python
from lazyutils import delegate_to
- class Arrow:
magnitude = delegate_to('vector')
- def __init__(self, vector, start=Vec(0, 0)):
- self.vector = vector self.start = start
Now, the .magnitude
attribute of Arrow
instances is delegated to
.vector.magnitude
. Delegate fields are useful in class composition when one
wants to expose a few selected attributes from the inner objects. delegate_to()
handles attributes and methods with no distinction.
>>> a = Arrow(Vec(6, 8))
>>> a.magnitude
computing...
10.0
Aliasing is a very simple form of delegation. We can create simple aliases for attributes using the alias() and readonly() functions:
class MyArrow(Arrow): abs_value = readonly('magnitude') origin = alias('start')
This exposes two additional properties: "abs_value" and "origin". The first is just a read-only view on the "magnitude" property. The second exposes read and write access to the "start" attribute.