Storing code in a list or dictionary?

Question

Instead of doing a long if..elif, is there a way to store code in a list or dictionary to be run? Something like:

my_dict = {'up': 'y=y+1', 'down': 'y=y-1', 'left': 'x=x-1', 'right': x=x+1'}

Then you match up the choice to the dict and run the result?

Or is the next best thing to a traditional if..elif chain a conditional expression:

x = x+1 if choice == 'right' else x-1 if choice == 'left' else x
y = y+1 if choice == 'up' else y-1 if choice == 'down' else y

Part of the reason I am asking, apart from sheer curiosity, is that I am writing a game in Pygame to help learn Python coding. I have 12 keys I am checking for being pressed, and I am using a very long and ungainly if..elif structure that makes me think there has to be a more beautiful way of doing it. Basically what I have looks like this:

for event in pygame.event.get():
        if event.type == pygame.QUIT:
            crashed = True
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_t:
                red += 10
            elif event.key == pygame.K_g:
                red -= 10
            elif event.key == pygame.K_5:
                red += 1
            elif event.key == pygame.K_b:
                red -= 1
            elif event.key == pygame.K_y:
                green += 10
            elif event.key == pygame.K_h:
                green -= 10
            elif event.key == pygame.K_6:
                green += 1
            elif event.key == pygame.K_n:
                green -= 1
            elif event.key == pygame.K_u:
                blue += 10
            elif event.key == pygame.K_j:
                blue -= 10
            elif event.key == pygame.K_7:
                blue += 1
            elif event.key == pygame.K_m:
                blue -= 1

Is that what my Python code is supposed to look like? Or is there a more Pythonic way to code this?

You can put functions into any variable, including as a value in a `dict`. Or even as a key, but you don't want that :). — Cyphase, Aug 15 '15 at 21:33
There's not much you can do about things like arbitrary key commands/actions. Using an `if..elif` structure is a fine way to do it. — TigerhawkT3, Aug 15 '15 at 21:36
see if [this SO QA](http://stackoverflow.com/questions/60208/replacements-for-switch-statement-in-python) helps — Pynchia, Aug 15 '15 at 21:44
see the updated accepted answer for further info and example use — Nikos M., Aug 16 '15 at 16:36

score 2 · Accepted Answer · edited Aug 16 '15 at 16:32

2

Yes, there is a way but by using functions:

def up():
    y=y+1

def down():
    y=y-1

def left():
    x=x-1

def right():
    x=x+1


d = {'up': up, 'down': down, 'left': left, 'right': right};

then call it like d['up']().

To avoid using global variables, you may use OOP approach:

class player:
    def __init__(self, x=0, y=0):
       self.x = x
       self.y = y

    def up(self):
        self.y += 1

    def down(self):
        self.y -= 1

    def left(self):
        self.x -= 1

    def right(self):
        self.x += 1

    def move(self, direction):
        # call the appropriate method that corresponds to given direction
        getattr(self, direction)()

Example use:

p = player(0,0)
p.move('up') # and so on..

edited Aug 16 '15 at 16:32

Nikos M.

8,033
4
36
43

answered Aug 15 '15 at 21:36

Assem

11,574
5
59
97

2

This would require globals. Messy messy. – Cyphase Aug 15 '15 at 21:37
It would also be approximately the same size and complexity as the `if..elif`. There's not much point to this. – TigerhawkT3 Aug 15 '15 at 21:39
@Cyphase, true, to fix it, one approach is using OO design, so parameters are local to each instance – Nikos M. Aug 15 '15 at 21:39
You don't need globals if you make the functions methods of an object. – Tom Dalton Aug 15 '15 at 21:41
@Cyphase I updated it including an OOP approach as Nikos M. suggested – Assem Aug 15 '15 at 21:45
`object` is a built-in; in fact, it's the base object. You shouldn't use it as an identifier. – Cyphase Aug 15 '15 at 21:48
changed it to `player` – Assem Aug 15 '15 at 21:50
You might want to add self to your methods – Padraic Cunningham Aug 15 '15 at 23:09
1

Thanks, this is pretty much what I was trying to understand. – Sindyr Aug 16 '15 at 14:47

score 2 · Answer 2 · answered Aug 15 '15 at 21:42

For this situation, one way to do it is to store the values you want to add/subtract in the dictionary, then retrieve them and add them. Something like this:

offsets = {
    'up': (0, 10),
    'down': (0, -10),
    'left': (-10, 0),
    'right': (10, 0)
}
xOffset, yOffset = offsets[choice]
x += xOffset
y += yOffset

You can store functions in a dictionary, but the functions won't be able to modify variables of their calling context. If you find that the "code snippets" you are storing all have the same structure (as here where each is "add something to x" or "add something to y"), what you may be able to do is factor out that code into one place, and only store the parameters in the dictionary (as here where you can store the values you want to add).

Thanks, this is all very educational. – Sindyr Aug 16 '15 at 14:47 — Sindyr, Aug 16 '15 at 14:47

Storing code in a list or dictionary?

2 Answers2