I'd like to do something like:
def get_foo(): return self._foo or self._foo = Bar() I am looking for the cleanest way to do it. Is it possible with or equals?
My attempts failed:
>>> foo = None >>> foo or 'bar' 'bar' >>> foo >>> foo or foo = 'bar' File "<stdin>", line 1 SyntaxError: can't assign to operator >>> foo or (foo = 'bar') File "<stdin>", line 1 foo or (foo = 'bar') ^ SyntaxError: invalid syntax In Python, you cannot use assignments in expressions. So you have to do the assignment and the return statement on two different lines:
def get_foo(self): self._foo = self._foo or Bar() return self._foo But in general, it's better to write it out:
def get_foo(self): if not self._foo: self._foo = Bar() return self._foo 
||= in ruby always get's me little bit confused for a moment, but I'm no ruby programmer and I expect that ruby programmers read it just fine.
Python's assignment operator doesn't pass through the assigned value, primarily because in other languages it has proven to be a fruitful generator of accidental =/== bugs. Instead you have to be explicit:
def get_foo(self): if self._foo is None: self._foo= Bar() return self._foo You can make an expression with side-effects if you really want to:
def set_foo(self, v): self._foo= v return v return self._foo or self.set_foo(Bar()) but it's generally considered a Bad Thing.
I might be wrong, but this looks like a job for the ||= operator.
def get_foo(): return self._foo |= Bar() My Perl is rusty at best, but ||= seems to return an R-value, so the return should work.
Edit: Woopsie, this is Python. It doesn't have a ||=. Bummer.
Then I'd use the simulated ternary operator:
def get_foo() self._foo = self._foo is None and Bar() or self._foo return self._foo Edit 2: Python has a real ternary operator. Use it instead of the above.
def get_foo() self._foo = Bar() if self._foo is None else self._foo return self._foo 
self._foo = self._foo if self._foo else Bar().
self._foo = Bar() if self._foo is None else self._foo. But why assign self._foo to self._foo in the 99% case where self._foo is no longer None once it has been initialized? Just use if self._foo is None: self._foo = Bar() followed by return self._foo. No ternary magic, just easy-to-read code.x = x is None and 0 or x - surprise, you never get the 0 assignment because bool(0) is False. Far and away the most common use of this idiom is for lazy initialization of an expensive-to-evaluate attribute (such as a database field), where the attribute is initialized to None, and then on first access, it gets set to its real value. For the following 'n' accesses (might be 0, might be a million), the lazy-init value or an updated non-None value is used.
None and is thingie.