Pythonic way to call different methods for each setting in a configuration screen

A possible solution would be having a dictionary attribute that stores the function names like this:

def __init__(self):
    self.params_reactions = {
        0: self.react_to_param1,  # Each value is a reference of a function in the class
        1: self.react_to_param2,
        2: self.react_to_param3
        # Continues...
    }

And then you could just call the reaction function if the index is present and matches a key of the dictionary:

def _on_value_change_event(self, idx, user_dict):
    # Your code as well

    if idx in self.params_reactions:
        self.params_reactions[idx].__call__()

    # You could raise an exception if 'idx' is not found
    # It depends on how you want to treat a possible exception to the program's flow

Doing things in a "pythonic" way often involves using dictionaries, one of the language's primary data-structures which have been highly optimized for speed and minimal memory usage.

With that in mind, the first thing I'd do is to get the configuration parameters in the CSV file into one. Since there's one per row of the CSV file, a logical thing to do would be to use a csv.DictReader to read them since it returns each row as a dictionary of values. You can easily build a dictionary-of-dictionaries out of those by using the unique csv_row_count (aka idx) field of each one as the key for upper-level dict.

Here's what I mean:

import csv
from pprint import pprint

CONFIG_FILEPATH = 'parameters.csv'

config_params = {}
with open(CONFIG_FILEPATH, 'r', newline='') as configfile:
    reader = csv.DictReader(configfile, escapechar='\\')
    csv_row_count = reader.fieldnames[0]  # First field is identifier.
    for row in reader:
        idx = int(row.pop(csv_row_count))  # Remove and convert to integer.
        config_params[idx] = row

print('config_params =')
pprint(config_params, sort_dicts=False)

So if your CSV file contained the rows like this:

csv_row_count,cat_name,attr_name,disp_str,unit,data_type,min_val,max_val,def_val,incr,cur_val,desc
15,LEDS,led_gen_use_als,Automatic LED Brightness,-,bool,0.0,1.0,TRUE,1.0,TRUE,Do you want activate automatic brightness control for all the LED's?
16,LEDS,led_gen_als_led_modifier,LED Brightness Modifier,-,float,0.1,1.0,1,0.05,1,The modifier for LED brightness. Used as static LED brightness value when 'led_gen_use_als' == false.
17,LEDS,led_gen_launch_show,Enable launch control LEDs,-,bool,0.0,1.0,TRUE,1.0,TRUE,Show when launch control has been activated\, leds will blink when at launch RPM

Reading it with the above code would result in the following dictionary-of-dictionaries being built:

config_params =
{15: {'cat_name': 'LEDS',
      'attr_name': 'led_gen_use_als',
      'disp_str': 'Automatic LED Brightness',
      'unit': '-',
      'data_type': 'bool',
      'min_val': '0.0',
      'max_val': '1.0',
      'def_val': 'TRUE',
      'incr': '1.0',
      'cur_val': 'TRUE',
      'desc': 'Do you want activate automatic brightness control for all the '
              "LED's?"},
 16: {'cat_name': 'LEDS',
      'attr_name': 'led_gen_als_led_modifier',
      'disp_str': 'LED Brightness Modifier',
      'unit': '-',
      'data_type': 'float',
      'min_val': '0.1',
      'max_val': '1.0',
      'def_val': '1',
      'incr': '0.05',
      'cur_val': '1',
      'desc': 'The modifier for LED brightness. Used as static LED brightness '
              "value when 'led_gen_use_als' == false."},
 17: {'cat_name': 'LEDS',
      'attr_name': 'led_gen_launch_show',
      'disp_str': 'Enable launch control LEDs',
      'unit': '-',
      'data_type': 'bool',
      'min_val': '0.0',
      'max_val': '1.0',
      'def_val': 'TRUE',
      'incr': '1.0',
      'cur_val': 'TRUE',
      'desc': 'Show when launch control has been activated, leds will blink '
              'when at launch RPM'}}

The Dispatching of the Functions

Now, as far as reacting to each parameter change goes, one way to do it would be by using a function decorator to define when the function of the decorator it is applied to will get called based on the value of its first argument. This will eliminate the need for a long series of if-statements in your _on_value_change_event() method — because it can be replaced with a single call to the named decorated function.

I got the idea for implementing a decorator to achieve this from the article Learn About Python Decorators by Writing a Function Dispatcher, although I have implemented it in a slightly different manner using a class (instead of a function with nested-functions), which I think is a little "cleaner". Also note how the decorator itself uses an internal dictionary named registry to do the store information about and to do the actual dispatching — another "pythonic" way to do things.

Again, here's what I mean:

class dispatch_on_value:
    """ Value-dispatch function decorator.

    Transforms a function into a value-dispatch function, which can have
    different behaviors based on the value of its first argument.

    See: http://hackwrite.com/posts/learn-about-python-decorators-by-writing-a-function-dispatcher
    """
    def __init__(self, func):
        self.func = func
        self.registry = {}

    def dispatch(self, value):
        try:
            return self.registry[value]
        except KeyError:
            return self.func

    def register(self, value, func=None):
        if func is None:
            return lambda f: self.register(value, f)
        self.registry[value] = func
        return func

    def __call__(self, *args, **kw):
        return self.dispatch(args[0])(*args, **kw)

@dispatch_on_value
def react_to_param(idx):  # Default function when no match.
    print(f'In default react_to_param function for idx == {idx}.')

@react_to_param.register(15)
def _(idx):
    print('In react_to_param function registered for idx 15')

@react_to_param.register(16)
def _(idx):
    print('In react_to_param function registered for idx 16')

@react_to_param.register(17)
def _(idx):
    print('In react_to_param function registered for idx 17')

# Test dispatching.
for idx in range(14, 19):
    react_to_param(idx)  # Only this line would go in your `_on_value_change_event()` method.

Here's the output produced that shows it works. Note that there wasn't a function registered for every possible value, in which the the default function gets called.

In default react_to_param function for idx == 14.
In react_to_param function registered for idx 15
In react_to_param function registered for idx 16
In react_to_param function registered for idx 17
In default react_to_param function for idx == 18.

You should use something better than a CSV. A YAML file, for example. https://tutswiki.com/read-write-yaml-config-file-in-python/