什么是条件变量初始化的pythonic方式？

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:

• https://stackoverflow.com/a/6402327/18097
• https://stackoverflow.com/a/7382688/18097

Which construct would be more acceptable?

Answer 1

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.

Answer 2

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 eg

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

Answer 3

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.

Answer 4

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.

Answer 5

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.