分析函数内部的“ return”语句

Question

Sometimes inside one function we need to use the return statement several times.

When developer changes a function with multiple returns inside, it's easy to oversee some parts of code where yet another return was "hidden". If unit tests do not cover all possible paths, disaster is guaranteed - it's only a question of time.

def my_function():
    '''Multiple "return" inside'''

    if condition 1:
        return 1, 2, 3
    if condition 2:
        return 2, 3, 4

    return 5  # this is wrong: only 1 value returned, while 3-tuple expected

Let's assume here: last return is wrong, because other callers expect tuple of 3 items.

I wonder if you know an easy way how to catch such parts of code automatically? I thought I could use AST, but I could not find any useful example of this.

This question is about automatic code analysis and listing such cases found - could be with running a separate script.

Of course I could write a try-to-guess parser (with eg regex) and then 'manually' check all unclear cases, but maybe there is a simpler way...

Answer 1

Depending on what version of Python you're using and what you really want to achieve, there are several ways to refactor the code.

One way, as has been already suggested, is to use Type Hints in Python 3.

Another way is refactor your code such that instead of using multiple return statements, you call other more atomic methods that handle those conditions and return the appropriate values. You use exception handling in those atomic methods to make sure the output is as desired, or raise an exception if final return type is unexpected.

def my_function():
    '''Multiple "return" inside'''

    if condition 1:
        output = func_handle_condition_one()
    if condition 2:
        output = func_handle_condition_two()

    output = some_other_value

    if type(output) is not tuple:
        raise TypeError("Invalid type for output")
    return output

Additionally, ensure that you're using the right constructs for your conditions (such as whether you want to use multiple if or the if-elif-else construct). You could even re-factor your calling code to call the right function instead of calling one that has so many conditional statements.

Answer 2

Why not set a variable that gets returned at the end and check for its length

def my_function():
    '''Multiple "return" inside'''

    return_value=(0,0,0)

    if condition 1:
        return_value=(1, 2, 3)
    elif condition 2:
        return_value=(2, 3, 4)
    else:
        return_value=5  # this is wrong: only 1 value returned, while 3-tuple expected

    try:
        if len(return_value)==3:
            return return_value
        else:
            print("Error: must return tuple of length 3")
    except:
        print("Error: must return tuple")

Answer 3

My proposal for the final type check of the result would be:

assert isinstance(return_value, tuple) and len(return_value) == 3

Advantage: as assert is easily switched off after debugging phase; still succinct statement for formulating the expectation.