Python Coding Style – Call Sub Function Based on Variable Value

coding-stylepython

I have a function containing other functions. These function are called based on value of variable action.

These sub functions are logically grouped – i.e., they all deal with file manipulation.

Each function has 2 to 5 lines.

I would like to improve the style.

Is there a more concise way of achieving this end than what I have below? I feed there is a log of defining functions that contain not many LOC.

def my_function(action):

    return { '1': func_a, '2': func_b, '3': func_c, '4': func_d}.get(action, err)()

    def func_a():
        ...
        ...
        return ...
    def func_b():
        ...
        ...
        ...
        return ...
    def func_c():
        ...
        ...
        return ...
    def func_d():
        ...
        ...
        return ...
    def err():
        return

*discaimer: actual functions have logical names.

My issue is with the proliferation of functions to define

Best Answer

If you cannot factor out common code in these functions they may not be reduced in size, if you cannot factor out features into common feature paths they cannot be reduced in number.

That said this approach is marvelous in my opinion and I have used dictionaries of functions to great effect in the past.

I can give one suggestion to your approach: Don't nest all the functions inside of the dispatching function. This may alleviate some of your concerns of cleanliness, perhaps something like:

def my_function(action):
    return { '1': func_a, '2': func_b, '3': func_c, '4': func_d}.get(action, err)()

def func_a():
    ...
    ...
    return ...
def func_b():
    ...
    ...
    ...
    return ...

By having separate functions which return the dispatchable functions, you can effectively move those functions to wherever they best fit in your system hierarchy, and your dispatcher simply calls them out. However if the nesting approach is the best modeling given your system then stick with what you have.

Use the `ast` module

import ast                                                                                                  
                                                                                                            
def extract_return(file, fname):                                                                            
    for x in ast.walk(ast.parse(open(file).read())):                                                        
        if not(isinstance(x, ast.FunctionDef)):                                                             
            continue                                                                                        
        if not(x.name == fname):                                                                            
            continue                                                                                        
        for b in x.body:                                                                                    
            if isinstance(b, ast.Return):                                                                   
                if isinstance(b.value, ast.Name):                                                           
                    yield b.value.id

This defines a function which takes some python source's filename and a function name fname (your "x") and yields each identifier returned by function fname. Here, I assume that you are only interested in return statements that occur at the first level of function x and consequently, I don't visit subexpressions. Also, I'am using yield because in more general cases this could work like a filter which could be composed with other ones. In more complex cases, it can be preferable to subclass ast.NodeVisitor.

This is equivalent in size with the regex approach but far more reliable.

Python Best Practices – Defining Constants Based on Function Calls

This would be considered a run-time constant: the value cannot be known before the program starts, but it is unchanging throughout the entire application once set.

The major advantage to a run-time constant is that it makes it obvious to a developer that the value is unchanging and that it enforces this in some way (to prevent erroneous assignments when the value has already been set), but you acknowledge that it cannot be known until run-time. Compare the value of Pi (which can be known and set before runtime) to the installation path of an application (which can only be figured out once the application starts, but not change when the application is running).

Your example perfectly fits the bill for this: it is a value that is set once and will never change throughout your application and therefore can look like a constant. Just note that this is not a true constant as Python does not have them and you will therefore need some kind of workaround to actually enforce their constant-ness.

Best Answer

Related Solutions

How to Extract Name of Return Variable from Python Function

Use the ast module

Python Best Practices – Defining Constants Based on Function Calls

Related Topic

Use the `ast` module