Writing multiple if-else statement clauses as a switch-style case can be a hassle to maintain, especially if you’re working with dynamic switches.

With no specific case or switch implementation in python’s standard library, I’ve liked using dispatch tables.

A dispatch table can be defined as a mapping of pointers to functions.

Let’s review a simple example.

A simple if-else statement set would look like the following (assuming the run_* functions are available)

class IfElse:
def run(self, version: str, data: bytes):
if version.startswith("alpha"):
return run_alpha(data)
elif version.startswith("beta"):
return run_beta(data)
elif version.startswith("gamma"):
return run_gamma(data)
elif version.startswith("delta"):
return run_delta(data)


But with a dispatch table we can turn that into:

class DispatchTable:
table = {
"alpha": run_alpha,
"beta": run_beta,
"gamma": run_gamma,
"delta": run_delta
}
def run(self, version: str, data: bytes):
return self.table[version](data)


What’s great about dispatch tables is that we have added a new element of key definition.

We can dynamically define these keys based on whatever we want and append those to the data-structure on whatever conditions and operations we need to support in our code.

In my opinion, this kind of approach is much more desirable for a couple important reasons.

The dispatch mechanism doesn’t need to know anything specific about our function handlers.

This also converts a linear time lookup to a constant time lookup. Dictionaries are hash tables in python, so the look-up process takes a constant time, while the if-elif statement set needs a linear scan across the whole set of statements (this could get problematic if you’re dynamically writing statements that could span thousands of cases 🤖).