Automatic initialization of variable

What about hasattr?

if not hasattr(self, 'A') or self.A is None:
    self.A = createContent()

If initialization is expensive, and you therefore only want to initialize the variable when it's needed, one Pythonic way would be to simply try to use it, and if that fails, initialize it.

For example:

try:
    do_something(self.A)
except AttributeError:
    self.A = initialize(self)
    do_something(self.A)

You would need to wrap every line of code that uses A in a situation where you can't be sure that it isn't defined yet in such a try/except block.

The other way would be to do an explicit check for A every time like @Nsh has proposed. But somebody, either you or Python, will have to do the checking at some point.

Assuming your attribute self.A is some sort of static object, we can implement it using a property that creates it on demand:

class Something(object):
    @property
    def A(self):
        try:
            return self._A
        except AttributeError:
            self._A=CreateAnA()
            return self._A

This way you don't need to duplicate the check. You could add a setter etc if you need those operations. The downside is primarily that it's not obvious when you do create it (as it's a side effect of reading an attribute), and there's a slight performance penalty for the indirect lookup (which could be avoided using __getattr__, at the expense of other failed lookups).

Thanks to the suggestions above, I came up with this:

class myClass:
    def __getattr__(self,name):
        if name == 'attributeA':
            print "initializing A"
            self.attributeA = self.expensiveInit()
            return self.attributeA
    def doStuff(self):
        print self.attributeA
    def expensiveInit(self):
        return 'gold'


a = myClass()
a.doStuff()
a.doStuff()
a.doStuff()

Do you think this is correct/pythonic?