Passing Variables between Defs

[JoeBorgione]

Global variables seem to draw the scorn if not ire of most python developers, and recently I've been faced with a situation where creating a variable in a series of defs needs to be passed back to  main().  I did a little searching with my friend and associate Dr. Google and found a stack over flow thread which gave me an idea. 

In the script I'm (re) writing, I'd like to follow the form of defining my defs() and then calling them from main().  However, each of my defs() use a try/except block, and if there is an exception anywhere along the line I need to abort the final processing.

This is what I came up with in concept:

errorList = []
def first():
    try:
        #some code
    except:
        errorList.append(1)

def second():
    try:
        #some other code
    except:
        errorList.append(1)
    
def main():
    first()
    second()
    if len(errorList) == 0:
        # final operations
    else:
        # don't execute final operations    
    
main()‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Pretty simple concept right?

Taking it one step further, I started thinking how about this:

def1List = []
def2List = []

def one():
    #blah,blah
    append def1List(someValueFromBlah)
    append def1List(anotherValueFromBlah)

def two():
    # blah2 blah2
    append def2List(someValueFromBlah2)
    append def2List(anotherValueFromBlah2)
    
def three():
    if def1List[0] == myTargetValue:
        do something
    elif defList[1] == myOtherTargetValue:
        do something else...
    myValue = def2List[0]
    myOtherValue = def2List[1]
    # use myValue and MyOtherValue as I need to...‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

These look like they'll work for me in a number of different applications, but I'd like to here from you (and you know who you are) as to whether or not these are:

Good Practice

Bad Practice

Something everybody does already

Etc

Etc....

[DanPatterson_Retired]

each def could use a return which could be checked to bypass any failures.  Although I don't recommend 'chaining' as in the pattern below... but hopefully you get the drift.

 def first(a):
    """ """
    if not isinstance(a, (int, float)):
        return False
    return a*2
    
def second(b):
    """ """
    if not isinstance(b, (int, float)):
        return False
    return b + 2
    
def third(c):
    """ """
    if not isinstance(c, (int, float)):
        return "totally blew it"
    return "{} ta dahhhh".format(c)
    
def may_nhh(val):
    """ """
    back = first(val)
    if not back:
        return "bailed on a"
    again = second(back)
    if not again:
        return "bailed on b"
    finallement = third(again)
    return finallement
    

may_nhh(5)
'12 ta dahhhh'

may_nhh('a')
'bailed on a'
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

[JoshuaBixby]

Unless you are cleaning something up after the error in your defs, why not let the error get raised in the def and then capture it in main from a try/except there:

def first():
        #some code

def second():
        #some other code
    
def main():
    funcs = first, second
    for func in funcs:
        try:
            func()
        except:
            # don't execute final operations
    
    # final operations
    
main()‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍