On some basic level your event handling is going to have to mix in with game logic to some degree. But the idea is that your game relies on abstract events and event responses as opposed to hard coded object dependancies. So to add new functionality you just need to hook into your event handler and send out an appropriate event/response. Depending on the type of the response it would get sent to the appropriate function in the game logic. (Event parent class and KeyEvent, CollisionEvent, etc. subclasses)

The general idea looks something like this:

-A game object wants to listen for keyboard presses.
-It registers itself as a listener to the Input Handler
-The game object needs an event response function.(Game Logic)
-Input Handler records a key down.
-Input Handler send out an event message to its listeners


So in your case:

def main():
"""Main module"""
initGame()
while True:
catchGameEvents()
updateGameState()
drawGameState()
def catchEvents():

"""Here we dispatch the events to anyone who is listening"""
for event in pygame.event.get():
for eventListener in EventListenerArray
eventListener.Notify(event);




......"""In each individual game object handle that objects response to differing events"""

class Player implements EventListener
{

def onEvent(KeyUpEvent event)
{
""".....Object/game logic"""

if event.key == UP:
#player keyup

if event.key == DOWN:
#player keydown
}

def onEvent(CollisionEvent event)
{
if event.owner == ENEMY:
#player explodes
}

}


import sys, pygame, abc
from pygame.locals import *

RED = (255,0,0)
BLACK = (0,0,0)
UP = 1
DOWN = 2
LEFT = 3
RIGHT = 4

class Event(object):
"""We have events here"""
_metaclass__ = abc.ABCMeta
listeners = []

def __init__(self):
"""Creates an event"""
super(Event, self).__init__()

def post (self):
"""Posts the existence of this event to their own listeners"""
for l in Event.listeners:
self.notifyFromEvent(l)

@classmethod
def addSuscriptor (self, eventListener):
""" Add an eventListener """
Event.listeners.append(eventListener)

@classmethod
def removeSuscriptor (self, eventListener):
""" Removes an eventListener """
Event.listeners.remove(eventListener)

@abc.abstractmethod
def notifyFromEvent(self, listener):
"""Start the double-dispatching event-driven system"""
print "Shouldn't execute this. Must be redefined by derivated class"

class MoveEvent(Event):
"""Move event"""
def __init__(self, keyStroked):
super(MoveEvent, self).__init__()
self.msg = "I'm a move event"
self.keyStroked = keyStroked

def notifyFromEvent(self, listener):
"""Implementig Event method."""
listener.notifyFromMoveEvent(self)

########################################################################

#interface
class EventListener(object):
""" This pseudo-interface has methods triggered from specific
events ("event-notifiers"). The model object overrides those
"event-notifiers" will handle """

def __init__ (self):
""" Class initialiser """
super(EventListener, self).__init__()

def suscribeTo (self, EventClass):
""" An object suscribes to an Event class to receive notifications
from them """
EventClass.addSuscriptor(self)

def unsuscribeTo (self, EventClass):
""" Stop receiving notifications from EventClass """
EventClass.removeSuscriptor(self)

def notifyFromMoveEvent(self, moveEvent):
"""Handles MoveEvent"""
pass

########################################################################

class Game(object):
"""The main class. It manages everything; maybe its function is
to be a central controller"""

def __init__(self, gameSprites):
super(Game, self).__init__()
self.gameSprites = gameSprites
self.eventList = []
pygame.init()
self.screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption('Prueba 1')

def catchUserInput(self):
"""Catch user inputs (from keyboard) and creates custom Events"""

ev = None
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit() #FIXIT: It's part of game logic
elif event.type == KEYDOWN:
if event.key == K_UP:
ev = MoveEvent(UP)
elif event.key == K_DOWN:
ev = MoveEvent(DOWN)
elif event.key == K_LEFT:
ev = MoveEvent(LEFT)
elif event.key == K_RIGHT:
ev = MoveEvent(RIGHT)
else:
pass
else:
pass

if ev:
self.eventList.append(ev)

def updateState(self):
"""Updates all game entities states posting all events stored"""
for ev in self.eventList:
ev.post()
self.eventList.remove(ev)

def drawState(self):
"""Draws all game entities states"""
self.screen.fill(BLACK)
for gs in self.gameSprites:
self.screen.blit(gs.image, gs.model.pos)
pygame.display.update()

########################################################################

class BallSprite(pygame.sprite.Sprite):
"""A ball sprite """

def __init__(self, color, ballModel):
super(BallSprite, self).__init__()
self.model = ballModel
#Create the proper sprite
self.image = pygame.Surface((15,15))
self.image.fill(color)
# Make our top-left corner the passed-in location.
self.rect = self.image.get_rect()
self.rect.topleft = ballModel.pos

def update(self):
"""Updates the position of the ball sprites"""
pass

class Ball(EventListener):
"""Ball object from model"""
def __init__(self, initPos):
super(Ball, self).__init__()
self.pos = initPos

#//EventListener method response-events implementations

def notifyFromMoveEvent(self, moveEvent):
"""Move throught the map"""
if moveEvent.keyStroked == UP:
self.pos = (self.pos[0], self.pos[1] - 10)
if moveEvent.keyStroked == DOWN:
self.pos = (self.pos[0], self.pos[1] + 10)
if moveEvent.keyStroked == LEFT:
self.pos = (self.pos[0] - 10, self.pos[1])
if moveEvent.keyStroked == RIGHT:
self.pos = (self.pos[0] + 10, self.pos[1])

def main():
"""Main module"""

b = Ball((5,5))
b.suscribeTo(MoveEvent)
game = Game((BallSprite(RED,b),))
while True:
game.catchUserInput()
game.updateState()
game.drawState()

if __name__ == '__main__':
main()

Merged the two topics.