Python Pseudo-Switch

[James Stroud]

Hello All,

Because of my poorly designing a database, I have recently found it necessary
to explore the wonders of the Python pseudo-switch:

do_case = { "A" : lambda x: x["bob"],
"B" : lambda x: x["carol"],
"C" : lambda x: "Ted",
"D" : lambda x: do_something(x) }

my_thing = do_case[get_value_from_ thin_air()](adict)
How to handle this kind of thing when lambda is removed from the language,
beside the obvious def'ing those tiny little functions?

James

--
James Stroud
UCLA-DOE Institute for Genomics and Proteomics
Box 951570
Los Angeles, CA 90095

http://www.jamesstroud.com/

[Dan Bishop]

James Stroud wrote:

Hello All,

Because of my poorly designing a database, I have recently found it necessary to explore the wonders of the Python pseudo-switch:

do_case = { "A" : lambda x: x["bob"],
"B" : lambda x: x["carol"],
"C" : lambda x: "Ted",
"D" : lambda x: do_something(x) }

my_thing = do_case[get_value_from_ thin_air()](adict)
How to handle this kind of thing when lambda is removed from the language, beside the obvious def'ing those tiny little functions?

You can always re-invent lambda.

def lambda2(arg_nam es, expression): .... exec 'def _(%s): return %s' % (','.join(arg_n ames), expression)
.... return _
.... add = lambda2(('x', 'y'), 'x + y')
add(3, 4)

7

[Jason Mobarak]

James Stroud wrote:

Hello All,

Because of my poorly designing a database, I have recently found it necessary to explore the wonders of the Python pseudo-switch:

do_case = { "A" : lambda x: x["bob"],
"B" : lambda x: x["carol"],
"C" : lambda x: "Ted",
"D" : lambda x: do_something(x) }

class CaseThing:
def pref_A (self, x):
return x["bob"]
def pref_B (self, x):
return x["carol"]
def pref_C (self, x);
return "Ted"
def pref_D (self, x)
return do_something(x)
def getThing (self, x):
attr = getattr(self, 'pref_%s' % (x,))
if attr is not None:
return attr
else:
raise SomeError("Thin g %s does not exist" % (x,))

my_thing = CaseThing().get Thing(get_value _from_thin_air) (adict)

You can do something similar with method decorators for more complex
strings than what's allowed for python method names.
my_thing = do_case[get_value_from_ thin_air()](adict)
How to handle this kind of thing when lambda is removed from the language, beside the obvious def'ing those tiny little functions?

James

--
James Stroud
UCLA-DOE Institute for Genomics and Proteomics
Box 951570
Los Angeles, CA 90095

http://www.jamesstroud.com/

[Jason Mobarak]

# -*- python -*-

import sys
def switchFor (target):
sw = '__switch_table __'
# please pretend the frame hack is not here,
# it happens to work for classes and messing with
# frame stack in a try/except is probably okay
try:
raise Exception()
except:
defs = sys.exc_info()[2].tb_frame.f_bac k.f_locals
if sw not in defs:
defs[sw] = {}
table = defs[sw]
def _(meth):
table[target] = meth
return meth
return _
class SwitchMixin (object):

def __init__ (self):
self.__switch_t able__ = self.__switch_t able__.copy()

def switchOn (self, target, *args, **kw):
return self.__switch_t able__[target](self, *args, **kw)
if __name__ == '__main__':

class SwitchTest(Swit chMixin):

@switchFor("foo ")
def switch (self, arg):
print arg * 3

@switchFor("bar ")
def switch (self, arg):
print "__%s__" % (arg,)

@switchFor("baz ")
def switch (self, arg):
print arg + ''.join(reverse d(arg))

st = SwitchTest()

st.switchOn("fo o", "oof")
st.switchOn("ba r", "rab")
st.switchOn("ba z", "zab")