Question

I’m working on a project where I’m batch generating XML files which can import to the IDE of an industrial touchscreen.

Each XML file represents a screen, and most screens require the same functions and the process for dealing with them is the same, with the exception of the fact that each screen type has a unique configuration function.

I’m using a ScreenType class to hold attributes specific to a screen type, so I decided to write a unique configuration for each type, and pass it as a parameter to the __init__() of this class. This way, when I pass around my ScreenType as it is needed, it’s configuration function will stay bundled and can be used whenever needed.

But I’m not sure what will happen if my configuration function itself has a dependency. For example:

def configure_inputdiag(a, b, c):
    numerical_formatting = get_numerics(a)
    # ...
    return configured_object

Then, when it comes time to create an instance of a ScreenType

myscreentype = ScreenType(foo, man, shoe, configure_inputdiag)

get_numerics is a module scoped function, but myscreentype could (and does) get passed within other modules.

Does this create a problem with dependencies? I’d try to test it myself, but it seems like I don’t have a fundamental understanding behind what’s going on when I pass a function as a parameter. I don’t want to draw incorrect conclusions about what’s happening.

What I’ve tried: Googling, Search SO, and I didn’t find anything specifically for Python.

Thanks in advance.

Answer 1

There’s no problem.

The function configure_inputdiag will always refer to get_numerics in the context where it was defined. So, even if you call configure_inputdiag from some other module which knows nothing about get_numerics, it will work fine.

Passing a function as a parameter produces a reference to that function. Through that reference, you can call the function as if you had called it by name, without actually knowing the name (or the module from which it came). The reference is valid for the lifetime of the program, and will always refer to the same function. If you store the function reference, it basically becomes a different name for the same function.