¿Por qué almacenar una función dentro de un diccionario de python?

Usando un dict te permite traducir la clave en un llamable. Sin embargo, la clave no necesita estar codificada, como en su ejemplo.

Por lo general, esta es una forma de envío de la persona que llama, donde se usa el valor de una variable para conectarse a una función. Supongamos que un proceso de red le envía códigos de comando, una asignación de despacho le permite traducir los códigos de comando fácilmente en código ejecutable:

def do_ping(self, arg):
    return 'Pong, {0}!'.format(arg)

def do_ls(self, arg):
    return '\n'.join(os.listdir(arg))

dispatch = {
    'ping': do_ping,
    'ls': do_ls,
}

def process_network_command(command, arg):
    send(dispatch[command](arg))

Tenga en cuenta que la función a la que llamamos ahora depende completamente de cuál es el valor de command . La clave tampoco tiene que coincidir; ni siquiera tiene que ser una cadena, puede usar cualquier cosa que se pueda usar como clave y se adapte a su aplicación específica.

Utilizar un método de envío es más seguro que otras técnicas, como eval() , ya que limita los comandos permitidos a lo que definió de antemano. Ningún atacante va a pasar una inyección de ls)"; DROP TABLE Students; -- más allá de una tabla de despacho, por ejemplo.

@Martijn Pieters hizo un buen trabajo explicando la técnica, pero quería aclarar algo de su pregunta.

Lo importante que hay que saber es que NO está almacenando "el nombre de la función" en el diccionario. Está almacenando una referencia a la función en sí. Puedes ver esto usando un print en la función.

>>> def f():
...   print 1
... 
>>> print f
<function f at 0xb721c1b4>

f es solo una variable que hace referencia a la función que definió. El uso de un diccionario le permite agrupar cosas similares, pero no es diferente de asignar una función a una variable diferente.

>>> a = f
>>> a
<function f at 0xb721c3ac>
>>> a()
1

Del mismo modo, puedes pasar una función como argumento.

>>> def c(func):
...   func()
... 
>>> c(f)
1

Tenga en cuenta que la clase Python es en realidad solo una sintaxis de azúcar para el diccionario. Cuando lo hagas:

class Foo(object):
    def find_city(self, city):
        ...

cuando llamas

f = Foo()
f.find_city('bar')

es realmente lo mismo que:

getattr(f, 'find_city')('bar')

que, después de la resolución de nombres, es lo mismo que:

f.__class__.__dict__['find_city'](f, 'bar')

Una técnica útil es para asignar la entrada del usuario a las devoluciones de llamada. Por ejemplo:

def cb1(...): 
    ...
funcs = {
    'cb1': cb1,
    ...
}
while True:
    input = raw_input()
    funcs[input]()

Esto también puede escribirse en clase:

class Funcs(object):
    def cb1(self, a): 
        ...
funcs = Funcs()
while True:
    input = raw_input()
    getattr(funcs, input)()

la sintaxis de devolución de llamada que sea mejor depende de la aplicación particular y del gusto del programador. El primero es un estilo más funcional, el segundo está más orientado a objetos. El primero puede parecer más natural si necesita modificar las entradas en el diccionario de funciones dinámicamente (quizás en función de la entrada del usuario); este último podría sentirse más natural si tiene un conjunto de diferentes asignaciones de ajustes preestablecidos que se pueden elegir dinámicamente.

Hay 2 técnicas que me vienen a la mente a las que te puedes referir, ninguna de las cuales es Pythonic, ya que son más amplias que un solo idioma.

1. La técnica de ocultación / encapsulación y cohesión de la información (por lo general van de la mano, así que los estoy agrupando).

Tienes un objeto que tiene datos y estás adjuntando un método (comportamiento) que es altamente cohesivo con los datos. En caso de que necesite cambiar la función, ampliar la funcionalidad o realizar cualquier otro cambio, los llamantes no tendrán que cambiar (suponiendo que no es necesario transmitir datos adicionales).

2. Mesas de despacho

No es el caso clásico, porque solo hay una entrada con una función. Sin embargo, las tablas de despacho se utilizan para organizar diferentes comportamientos mediante una clave de manera que se pueden buscar y llamar de forma dinámica. No estoy seguro de si está pensando en esto, ya que no se está refiriendo a la función de forma dinámica, pero no obstante, sigue obteniendo una vinculación tardía efectiva (la llamada "indirecta").

Tradeoffs

Una cosa a tener en cuenta es que lo que haces funcionará bien con un espacio de nombres conocido de claves. Sin embargo, corre el riesgo de colisión entre los datos y las funciones con un espacio de nombre de teclas desconocido.

Publico esta solución que creo que es bastante genérica y puede ser útil, ya que se mantiene simple y se adapta a casos específicos:

def p(what):
    print 'playing', cmpsr

def l(what):
    print 'listening', cmpsr

actions = {'Play' : p, 'Listen' : l}

act = 'Listen'
cmpsr = 'Vivaldi'

actions[act].__call__(cmpsr)

también se puede definir una lista donde cada elemento es un objeto de función y utilizar el método integrado __call__ . Créditos a todos por la inspiración y cooperación.

"El gran artista es el simplificador", Henri Frederic Amiel