Calculate attribute if it doesn't exist

Question

I am trying to access an attribute that shouldn't be created in the __init__ method of my class but can be calculated by calling another method. I am trying to make it so that if I try to access the attribute and it does not exist it will be automatically calculated. However, I don't want it to be recalculated if the attribute does exist, even if the value would be different. For example:

class SampleObject(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def calculate_total(self):
        self.total = self.a + self.b

sample = SampleObject(1, 2)
print sample.total   # should print 3
sample.a = 2
print sample.total   # should print 3
sample.calculate_total()
print sample.total   # should print 4

My best solution so far is to make a get_total() method that does what I need.

class SampleObject2(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def calculate_total(self):
        self.total = self.a + self.b

    def get_total(self):
        if hasattr(self, 'total'):
            return self.total
        else:
            self.calculate_total()
            return self.total

sample2 = SampleObject2(1, 2)
print sample2.get_total() # prints 3
sample2.a = 2
print sample2.get_total() # prints 3
sample2.calculate_total()
print sample2.get_total() # prints 4

This is working fine, but I have read that using getters in python is discouraged and I was hoping to avoid calling this function every time I wanted to access the attribute. Is this my best solution, or is there a cleaner, more pythonic way of doing this?

This is an example that I made up. In my actual problem, calculate_total() is a time consuming process that won't necessarily need to be called. So I don't want to execute it in the init method.

Answer 1

You want to use the @property decorator. Create a method, that will be accessed like a normal attribute, that does lazy computation:

class SampleObject:

    def __init__(self):
        # ...
        self._total = None

    @property
    def total(self):
        """Compute or return the _total attribute."""
        if self._total is None:
            self.compute_total()

        return self._total

Answer 2

Pyramid (a Web framework) comes with a reify decorator that is similar to property (shown by Austin Hastings) but it works a little differently: the function is only executed once, and after that, the value returned by the function is always used. It essentially does what Austin's code does, but without having to use a separate attribute: it's a generalization of that pattern.

You probably don't want to use a whole Web framework just for this one decorator, so here is an equivalent one I wrote:

import functools

class Descriptor(object):
    def __init__(self, func):
        self.func = func
    def __get__(self, inst, type=None):
        val = self.func(inst)
        setattr(inst, self.func.__name__, val)
        return val

def reify(func):
    return functools.wraps(func)(Descriptor(func))

Usage:

class ReifyDemo:
    @reify
    def total(self):
        """Compute or return the total attribute."""
        print("calculated total")
        return 2 + 2    # some complicated calculation here

r = ReifyDemo()
print(r.total)     # prints 'calculated total 4' because the function was called
print(r.total)     # prints just '4` because the function did not need to be called