What's the pythonic way of conditional variable initialization?

Question

Due to the scoping rules of Python, all variables once initialized within a scope are available thereafter. Since conditionals do not introduce new scope, constructs in other languages (such as initializing a variable before that condition) aren't necessarily needed. For example, we might have:

def foo(optionalvar = None):
    # some processing, resulting in...
    message = get_message()
    if optionalvar is not None:
        # some other processing, resulting in...
        message = get_other_message()
    # ... rest of function that uses message

or, we could have instead:

def foo(optionalvar = None):
    if optionalvar is None:
        # processing, resulting in...
        message = get_message()
    else:
        # other processing, resulting in...
        message = get_other_message()
    # ... rest of function that uses message

Of course, the get_message and get_other_message functions might be many lines of code and are basically irrelevant (you can assume that the state of the program after each path is the same); the goal here is making message ready for use beyond this section of the function.

I've seen the latter construct used several times in other questions, such as:

Which construct would be more acceptable?

Doesn't that depend entirely whether you want `get_message` to run conditionally or unconditionally? — , Dec 06 '11 at 18:29
The idea here is not the function to call, but rather the construction of `message`: the function itself is irrelevant. — Robert P, Dec 06 '11 at 18:30
Whether it's a function or not, the one semantic difference is that one runs half of the code unconditionally. If it makes a difference, there's little point in debating style. — , Dec 06 '11 at 18:32
Agreed. Which is why I'm wondering if the second construct is considered decent style in python! :) (I think it is...I'm looking to see what others think.) — Robert P, Dec 06 '11 at 18:34
My point is, style is moot when the code is wrong. Unless you have two options with the same semantics, you must choose based on semantics rather than style. — , Dec 06 '11 at 18:36
Yes, the second function is perfectly acceptable, and it's what I would probably use. +1 delnan. — Michael Hoffman, Dec 06 '11 at 18:38
Then in that case, you can assume that the final state of the system is identical with each way the variable is constructed. — Robert P, Dec 06 '11 at 18:39
An edit to add the "pythonic" tag was just rejected. IMHO it makes sense (it's an active tag). @RobertP, you might consider adding that tag yourself. — Keith Thompson, Dec 06 '11 at 20:16

score 13 · Accepted Answer · answered Dec 06 '11 at 18:38

13

Python also has a very useful if syntax pattern which you can use here

  message = get_other_message() if optional_var else get_message()

Or if you want to compare strictly with None

  message = get_other_message() if optional_var is not None else get_message()

Unlike with example 1) you posted this doesn't call get_message() unnecessarily.

answered Dec 06 '11 at 18:38

Mikko Ohtamaa

82,057
50
264
435

1

This is **THE** Pythonic way to do conditional assignments (since v2.5), at least as far as the language itself is concerned. Check out [PEP 308](http://docs.python.org/release/2.5/whatsnew/pep-308.html) for more info. – voithos Dec 06 '11 at 19:09
It also looks like PEP 308 suggests that the second format was the previous acceptable way of doing this. Good to know! – Robert P Dec 06 '11 at 21:42

score 4 · Answer 2 · answered Dec 06 '11 at 18:41

In general second approach is better and more generic because it doesn't involve calling get_message unconditionally. Which may be ok if that function is not resource incentive but consider a search function

def search(engine):
    results = get_from_google()
    if engine == 'bing':
       results = get_from_bing()

obviously this is not good, i can't think of such bad scenario for second case, so basically a approach which goes thru all options and finally does the default is best e.g.

def search(engine):
    if engine == 'bing':
       results = get_from_bing()
    else:
       results = get_from_google()

score 1 · Answer 3 · answered Dec 06 '11 at 18:30

I think it's more pythonic to not set an explicit rule about this, and instead just keep to the idea that smallish functions are better (in part because it's possible to keep in your mind just when new names are introduced).

I suppose though that if your conditional tests get much more complicated than an if/else you may run the risk of all of them failing and you later using an undefined name, resulting in a possible runtime error, unless you are very careful. That might be an argument for the first style, when it's possible.

score 0 · Answer 4 · answered Dec 06 '11 at 18:31

The answer depends on if there are side effects of get_message() which are wanted.

In most cases clearly the second one wins, because the code which produces the unwanted result is not executed. But if you need the side effects, you should choose the first version.

score 0 · Answer 5 · answered Dec 06 '11 at 18:36

0

It might be better (read: safer) to initialize your variable outside the conditions. If you have to define other conditions or even remove some, the user of message later on might get an uninitialized variable exception.

answered Dec 06 '11 at 18:36

Manny D

20,310
2
29
31

What's the pythonic way of conditional variable initialization?

5 Answers5

Linked