Tuneables/Configurable for a module

I am writing a module in python which has many functions to be used in a variety of situations, resulting in changing default values over time. (Currently this is a .py file I am importing) Many of the functions have the same hard-coded defaults. I would like to make these defaults configureable, ideally through some functionality that can be accessed via a jupyter notebook that has already imported the module or at the very least that can be set at the time of import or via a config file.

I know how to do this using other languages but have been struggling to do the same in python. I do not want defaults to be hardcoded. I know that some of the difficulty with this is that the module is only imported once, meaning variables inside the module are no longer accessable after the import is complete. If there is a way of looking at this more pythonically, I would accept an answer that explains why my desired solution is non-pythonic and what a good alternative would be.

For example here is what the functions would look like:

function1(arg1 = default_param1):
    return arg1
function2(arg1 = default_param1, arg2 = default_param3):
    other cool stuff

Here is what I would like to be able to do something similar to this:

import foo_module.py as foo
foo.function1()
foo.default_param1 = new_value
foo.function1()

==> arg1
==> new_value

Of course, with this setup you can always change the value input every time you call the function, but this is less than ideal.

In this case how would I change default_param1 accross the entire module via the code that is importing the module?

Edit: to clarify, this module would not be accessed via the command line. A primary use case is to import it into a jupyter notebook.

Solution

You could use environment variables such that, upon being imported, your module reads these variables and adjusts the defaults accordingly.

You could set the environment variables ahead of time using os.environ. So,

import os

os.environ['BLAH'] = '5'
import my_module

Inside my_module.py, you'd have something like

import os

try:
    BLAH_DEFAULT = int(os.environ['BLAH'])
except:
    BLAH_DEFAULT = 3

If you'd rather not fiddle with environment variables and you're okay with the defaults being mutable after importation, my_module.py could store the defaults in a global dict. E.g.

defaults = {
    'BLAH': 3,
    'FOO': 'bar',
    'BAZ': True
}

Your user could update that dictionary manually (my_module.defaults['BAZ']=False) or, if that bothers you, you could hide the mechanics in a function:

def update_default(key,value):
    if key not in defaults:
        raise ValueError('{} is not a valid default parameter.'.format(key))

    defaults[key]=value

You could spiff up that function by doing type/range checks on the passed value.

However, keep in mind that, unlike in languages like C++ and Java, nothing in Python is truly hidden. A user would be able to directly reference my_module.defaults thus bypassing your function.