Using a Dictionary to `switch`¶

Python does not have a switch/case statement. Why not?

https://www.python.org/dev/peps/pep-3103/

So what to use instead of “switch-case”?

`switch` / `case`¶

What is `switch`?¶

Many languages have a “switch-case” construct:

switch(argument) {
    case 0:
        return "zero";
    case 1:
        return "one";
    case 2:
        return "two";
    default:
        return "nothing";
};

How do you say this in Python?

`if-elif` chains¶

The obvious way to say it is a chain of elif statements:

if argument ==  0:
    return "zero"
elif argument == 1:
    return "one"
elif argument == 2:
    return "two"
else:
    return "nothing"

And there is nothing wrong with that, but….

dict as switch¶

The elif chain is neither elegant nor efficient. There are a number of ways to say it in python – but one elegant one is to use a dict:

arg_dict = {0:"zero", 1:"one", 2: "two"}
arg_dict.get(argument, "nothing")

Simple, elegant and fast.

You can do a dispatch table by putting functions as the value.

Example: The mailroom2 solution.

Switch with functions¶

What would this be like if you used functions instead? Think of the possibilities.

In [11]: def my_zero_func():
    return "I'm zero"

In [12]: def my_one_func():
    return "I'm one"

In [13]: switch_func_dict = {
    0: my_zero_func,
    1: my_one_func,
}

In [14]: switch_func_dict.get(0)()
Out[14]: "I'm zero"

Again, fast and efficient.

This is possible because functions are “first class objects” in Python.

OO switch/case¶

Another way to do the equivalent of switch / case is subclassing.

If you haven’t learned about classes in Python this will be pretty confusing. But here’s a high level overview:

In C, before C++, a common idiom was something like:

switch(object_type) {
    case circle:
        draw_a_circle();
    case square:
        draw_a_square();
    case polygon:
        draw_a_polygon();
    default:
        draw_nothing();
};

That is, a different function is called depending on what type of “thing” you are dealing with.

This is actually a really common idiom in C. And even in modern OO code written by old C developers – I had a developer on my team do exactly this in a program we were working on. It was a map drawing program (written in Python), and there was code all over it like:

if layer.type == "tiles":
    do_something_with_tiles
elif layer.type == "grid":
    do_somethign_with_grid

This was a maintainability nightmare – if you added a new layer type, you had to find every one of these constructs and add another elif block to it.

The OO way¶

With object oriented programming, you can “subclass” objects, and use “polymorphism” to achieve this kind of selection. Say you have a bunch of objects you want to be able to draw. Give each of them a draw() method, and then the above switch statement becomes:

the_object.draw()

That’s IT!

You don’t have to test to see which type of object it is, you only have to know that it knows how to draw itself.

Now when you add a new object type – all you need to do is make sure it has a draw() method (and other needed methods) and then all the other code will know how to use it without your changing anything.

Using a Dictionary to switch¶

switch / case¶

What is switch?¶

if-elif chains¶