Is this a "pythonic" method of executing functions as a python switch statement for tuple values?

Question

I have a situation where I have six possible situations which can relate to four different results. Instead of using an extended if/else statement, I was wondering if it would be more pythonic to use a dictionary to call the functions that I would call inside the if/else as a replacement for a "switch" statement, like one might use in C# or php.

My switch statement depends on two values which I'm using to build a tuple, which I'll in turn use as the key to the dictionary that will function as my "switch". I will be getting the values for the tuple from two other functions (database calls), which is why I have the example one() and zero() functions.

This is the code pattern I'm thinking of using which I stumbled on with playing around in the python shell:

def one():
    #Simulated database value
    return 1

def zero():
    return 0

def run():
    #Shows the correct function ran
    print "RUN"
    return 1

def walk():
    print "WALK"
    return 1

def main():
    switch_dictionary = {}

    #These are the values that I will want to use to decide
    #which functions to use
    switch_dictionary[(0,0)] = run
    switch_dictionary[(1,1)] = walk

    #These are the tuples that I will build from the database
    zero_tuple = (zero(), zero())
    one_tuple = (one(), one())

    #These actually run the functions. In practice I will simply 
    #have the one tuple which is dependent on the database information
    #to run the function that I defined before
    switch_dictionary[zero_tuple]()
    switch_dictionary[one_tuple]()

I don't have the actual code written or I would post it here, as I would like to know if this method is considered a python best practice. I'm still a python learner in university, and if this is a method that's a bad habit, then I would like to kick it now before I get out into the real world.

Note, the result of executing the code above is as expected, simply "RUN" and "WALK".

edit

For those of you who are interested, this is how the relevant code turned out. It's being used on a google app engine application. You should find the code is considerably tidier than my rough example pattern. It works much better than my prior convoluted if/else tree.

def GetAssignedAgent(self):
    tPaypal = PaypalOrder() #Parent class for this function
    tAgents = []
    Switch = {}

    #These are the different methods for the actions to take
    Switch[(0,0)] = tPaypal.AssignNoAgent
    Switch[(0,1)] = tPaypal.UseBackupAgents
    Switch[(0,2)] = tPaypal.UseBackupAgents
    Switch[(1,0)] = tPaypal.UseFullAgents
    Switch[(1,1)] = tPaypal.UseFullAndBackupAgents
    Switch[(1,2)] = tPaypal.UseFullAndBackupAgents
    Switch[(2,0)] = tPaypal.UseFullAgents
    Switch[(2,1)] = tPaypal.UseFullAgents
    Switch[(2,2)] = tPaypal.UseFullAgents

    #I'm only interested in the number up to 2, which is why
    #I can consider the Switch dictionary to be all options available.
    #The "state" is the current status of the customer agent system
    tCurrentState = (tPaypal.GetNumberofAvailableAgents(), 
                     tPaypal.GetNumberofBackupAgents())

    tAgents = Switch[tCurrentState]()

Answer 1

Consider this idiom instead:

>>> def run():
...   print 'run'
... 
>>> def walk():
...   print 'walk'
... 
>>> def talk():
...    print 'talk'
>>> switch={'run':run,'walk':walk,'talk':talk}
>>> switch['run']()
run

I think it is a little more readable than the direction you are heading.

edit

And this works as well:

>>> switch={0:run,1:walk} 
>>> switch[0]()
run
>>> switch[max(0,1)]()
walk

You can even use this idiom for a switch / default type structure:

>>> default_value=1
>>> try:
...    switch[49]()
... except KeyError:
...    switch[default_value]()

Or (the less readable, more terse):

>>> switch[switch.get(49,default_value)]()
walk

edit 2

Same idiom, extended to your comment:

>>> def get_t1():
...    return 0
... 
>>> def get_t2():
...    return 1
... 
>>> switch={(get_t1(),get_t2()):run}
>>> switch
{(0, 1): <function run at 0x100492d70>}

Readability matters

Answer 2

It is a reasonably common python practice to dispatch to functions based on a dictionary or sequence lookup.

Given your use of indices for lookup, an list of lists would also work:

switch_list = [[run, None], [None, walk]]
  ...
switch_list[zero_tuple]()

What is considered most Pythonic is that which maximizes clarity while meeting other operational requirements. In your example, the lookup tuple doesn't appear to have intrinsic meaning, so the operational intent is being lost of a magic constant. Try to make sure the business logic doesn't get lost in your dispatch mechanism. Using meaningful names for the constants would likely help.