Question

Consider the following:

    def funcA():
        some process = dynamicVar
        if dynamicVar == 1:
            return dynamicVar
        else:
            print "no dynamicVar"

    def main():
        outcome = funcA()

If the ‘some process’ part results in a 1, the var dynamicVar is passed back as outcome to the main func. If dynamicVar is anything but 1, the routine fails as no arguments are being return.

I could wrap the outcome as a list:

    def funcA():
        outcomeList = []
        some process = dynamicVar
        if dynamicVar == 1:
            outcomeList.append(dynamicVar)
            return outcomeList
        else:
            print "no dynamicVar"
            return outcomeList

    def main():
        outcome = funcA()
        if outcome != []:
            do something using dynamicVar
        else:
            do something else!

or maybe as a dictionary item. Each of the 2 solutions I can think of involve another set of processing in the main / requesting func.

Is this the ‘correct’ way to handle this eventuality? or is there a better way?

What is the proper way of dealing with this. I was particularly thinking about trying to catch try: / except: errors, so in that example the uses are reversed, so something along the lines of:

    def funcA():
        some process = dynamicVar
        if dynamicVar == 1:
            return
        else:
            outcome = "no dynamicVar"
            return outcome 

    def main():
        try:
            funcA()
        except:
            outcome = funcA.dynamicVar 

Answer 1

I believe when you write a function, it’s return value should be clear and expected. You should return what you say you will return. That being said, you can use None as a meaningful return value to indicate that the operation failed or produced no results:

def doSomething():
    """
    doSomething will return a string value 
    If there is no value available, None will be returned
    """
    if check_something():
        return "a string"

    # this is being explicit. If you did not do this,
    # None would still be returned. But it is nice
    # to be verbose so it reads properly with intent.   
    return None

Or you can make sure to always return a default of the same type:

def doSomething():
    """
    doSomething will return a string value 
    If there is no value available, and empty string 
    will be returned
    """
    if check_something():
        return "a string"

    return ""

This handles the case with a bunch of complex conditional tests that eventually just fall through:

def doSomething():
    if foo:
        if bar:
            if biz:
                return "value"
    return ""