Executing functions within switch dictionary

Question

I have encountered a problem when putting all the modules I\'ve developed into the main program. The switch dictionary I\'ve created can be seen below:

def T         


        

Answer 1

As noted, the functions will get invoked during dictionary construction. Besides that, there's two other issues I see here:

• Redefining switcher during every invocation of the function Tank_Shape_Calcs, this generally isn't a good idea.
• Requiring all arguments to be passed (due to their definition as positionals) when only a handful of them might be needed, this is why we have *args :-)

If my understanding of what you're up to is correct, I'd move switcher outside the function, as a Tank_Shape to function object mapping:

switcher = {
    0: vertical.Vertical_Tank,
    1: horiz.Horiz_Cylinder_Dished_Ends,
    2: strapping.Calc_Strapped_Volume,
    3: poly.Fifth_Poly_Calcs
}

Then, define Tank_Shape_Calcs to take the excess arguments as a tuple with *args:

def Tank_Shape_Calcs(Tank_Shape, *args):
    return switcher.get(Tank_Shape, lambda *_: "ERROR: Tank type not valid")(*args)

and invoke your function after .getting it.

This also plays off Jean's trick to define a lambda in .get but does so with *_ in order to allow it to get called with many args (which are consequently ignored).

Answer 2

What you are doing in your code, is creating a dictionary with integer keys (0-3) and function results as values. Hence, you first call all the functions and then access the return values of these functions. I would change your code as following:

def Tank_Shape_Calcs(Tank_Shape, level, area, dish, radius, length, Strapping_Table, Tank_Number):
    switcher = {
        0: (vertical.Vertical_Tank, (level, area)),
        1: (horiz.Horiz_Cylinder_Dished_Ends, (dish, radius, level, length)),
        2: (strapping.Calc_Strapped_Volume, (Strapping_Table, level)),
        3: (poly.Fifth_Poly_Calcs, (Tank_Number,))
    }
    func, args = switcher.get(Tank_Shape, (None, None))
    if func is not None: 
        return func(*args)

Here, you get first the function you want to call with the according arguments and call it.

Answer 3

All your functions are executed when you build the dictionary, not when you access the key.

You need to use lambda (without any parameters, they are already known) to make sure the function is only called when required:

switcher = {
    0: lambda : vertical.Vertical_Tank(level, area),
    1: lambda : horiz.Horiz_Cylinder_Dished_Ends(dish, radius, level, length),
    2: lambda : strapping.Calc_Strapped_Volume(Strapping_Table, level),
    3: lambda : poly.Fifth_Poly_Calcs(Tank_Number)
}

then call when you return, with the error message as a lambda that returns it:

return switcher.get(Tank_Shape, lambda : "ERROR: Tank type not valid")()