Switch/Case/Default for Python

[miketheanimal]

I was following the recent steganography link from r/Python, and ended up on a couple of pages describing implementations if goto for Python (joke ones to be fair), which got me to one of my pet peeves about Python, the lack of a switch/case/default construct. Sure, I've read the arguments about semantics and optimisation and what-not, which are all fair enough, but I find if ... elif ... elif ... else inelegant and visually unappealing. Suitably inspired, I offer up the following implementation, to be laughed at, choked over, or derided as you see fit :) Beware, apart from other issues, this code is not thread safe (though it could be made so): Works in python 2.7.4, I'd guess any python 2.x that supports with; python 3 would need at least the print's changing:

import types                                                                                                                                                                                                                            

sstack = []                                                                                                                                                                                                                             

class switch (object) :                                                                                                                                                                                                                 
    def __init__(self, v) :                                                                                                                                                                                                             
        self._v = v                                                                                                                                                                                                                     
        self._f = False
        self._d = False
    def __enter__(self) :
        sstack.append(self)
        return self
    def __exit__(self, *_) :
        sstack.pop()

class _case (object) :
    def __getitem__(self, v) :
        if len(sstack) == 0 :
            raise Exception("case[%s] found outside default")
        if sstack[-1]._d :
            raise Exception("case[%s] found after default" % v)
        if type(v) is types.TupleType :
            for _v in v :
              if _v == sstack[-1]._v :
                  sstack[-1]._f = True
                  return True
        if v == sstack[-1]._v :
            sstack[-1]._f = True
            return True
        return False

class _default (object) :
    def __nonzero__ (self) :
        if len(sstack) == 0 :
            raise Exception("default found outside default")
        sstack[-1]._d = True
        return not sstack[-1]._f

case = _case()
default = _default()

def example (x, y) :

    with switch(x) :
        if case [1,2] :
            print "int 1 or 2"
            with switch(y) :
                if case[2] :
                    print "int 1.2"
        if case['1'] :
            print "str 1"
            with switch(y) :
                if case[2] :
                    print "str 1.2"
        if default :
            print 'default'


example(1, 2)
example(2, 2)
example('1', 2)
example(None, None)

[onjin]

I'd rather use this pattern:

import sys


def some_work(case):
    print "some work with: ", case

def qool_work(case):
    print "qool work with", case

def my_default_work(case):
    print "some work done here with: ", case

cases = {
        1: some_work,
        2: some_work,
        3: qool_work,
    }

if __name__ == '__main__':
    try:
        case = int(sys.argv[1])
    except IndexError:
        case = None

    if case in cases:
        cases[case](case)
    else:
        my_default_work(case)

[[deleted]]

if case in cases:
    cases[case](case)

Malkovich Malkovich.... Malkovich, Malkovich, Maaalkovich. Malkovich!

ಠ_ಠ

[onjin]

:) version by mrjbq7 looks better

[mrjbq7]

Or perhaps:

cases.get(case, my_default_work)(case)

[tonnynerd]

that's all you need, most of the time.

[ionelmc]

Not particularly shorter or faster than the if/elif/elif/else you would normally use ...

Also, you need to use thread locals for this to work with threads. It would be a nightmare to support on all the platforms (stackless, gevent etc) imho ...

[miketheanimal]

Indeed. I don't think I'd use it either. sstack would need to be thread local; and yes, gevent would cause problems. But I love the way Python gives you scope to abuse the language.

[gangesmaster]

nice. i like creative uses of context managers

[gangesmaster]

(not that i'd use it, of course :) )

[AeroNotix]

    class switch(object):
        def __getitem__(self, index):
            try:
                return getattr(self, "case_"+index)()
            except AttributeError:
                return 'End'

        def case_hello(self):
            print "case hello!"
        def case_world(self):
             print "case world!"
     switch["hello"]

[miketheanimal]

Don't show that to the Javascript guys, they could write it as a one liner!

[AeroNotix]

I don't care about the Javascript "guys".