Perché memorizzare una funzione all'interno di un dizionario Python?

Usando un dict, traduciamo la chiave in un callable. La chiave non deve essere necessariamente codificata, come nel tuo esempio.

Di solito, questa è una forma di invio del chiamante, in cui si utilizza il valore di una variabile per connettersi a una funzione. Supponiamo che un processo di rete invii codici di comando, una mappatura di dispatch ti consente di tradurre facilmente i codici di comando in codice eseguibile:

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))

Nota che la funzione che chiamiamo ora dipende interamente dal valore di command . La chiave non deve corrispondere a nessuno dei due; non deve nemmeno essere una stringa, puoi usare qualsiasi cosa che possa essere usata come chiave e adatta alla tua specifica applicazione.

L'uso di un metodo di invio è più sicuro di altre tecniche, come eval() , poiché limita i comandi consentiti a ciò che hai definito in precedenza. Ad esempio, nessun hacker introdurrà un'iniezione ls)"; DROP TABLE Students; -- oltre una tabella di distribuzione.

@Martijn Pieters ha fatto un buon lavoro spiegando la tecnica, ma volevo chiarire qualcosa dalla tua domanda.

La cosa importante da sapere è che NON memorizza "il nome della funzione" nel dizionario. Stai memorizzando un riferimento alla funzione stessa. Puoi visualizzarlo utilizzando print sulla funzione.

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

f è solo una variabile che fa riferimento alla funzione che hai definito. L'uso di un dizionario ti consente di raggruppare cose simili, ma non è diverso dall'assegnare una funzione a una variabile diversa.

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

Allo stesso modo, puoi passare una funzione come argomento.

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

Si noti che la classe Python è in realtà solo uno zucchero di sintassi per il dizionario. Quando lo fai:

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

quando chiami

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

è proprio lo stesso di:

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

che, dopo la risoluzione del nome, è lo stesso di:

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

Una tecnica utile è per mappare l'input dell'utente ai callback. Ad esempio:

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

Questo può essere scritto in alternativa in classe:

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

qualsiasi sintassi di callback è migliore dipende dalla particolare applicazione e dal gusto del programmatore. Il primo è uno stile più funzionale, il secondo è più orientato agli oggetti. Il primo potrebbe sembrare più naturale se è necessario modificare dinamicamente le voci nel dizionario delle funzioni (magari in base all'input dell'utente); quest'ultimo potrebbe sembrare più naturale se si dispone di un insieme di mappature di preset differenti che possono essere scelti dinamicamente.

Ci sono 2 tecniche che mi vengono in mente a cui potresti riferirti, nessuna delle quali è Pythonic in quanto è più ampia di una lingua.

1. La tecnica di nascondere / incapsulare informazioni e coesione (di solito vanno di pari passo così li sto raggruppando insieme).

Hai un oggetto con dati e un metodo (comportamento) altamente coeso con i dati. Se è necessario modificare la funzione, estendere la funzionalità o apportare altre modifiche, non è necessario che i chiamanti cambino (supponendo che non sia necessario inoltrare dati aggiuntivi).

2. Tabelle di spedizione

Non è il caso classico, perché c'è una sola voce con una funzione. Tuttavia, le tabelle di invio vengono utilizzate per organizzare comportamenti diversi mediante una chiave in modo che possano essere consultati e richiamati dinamicamente. Non sono sicuro che tu pensi a questo dal momento che non ti riferisci alla funzione in modo dinamico, ma ciononostante ottieni comunque un'associazione tardiva efficace (la chiamata "indiretta").

Compromessi

Una cosa da notare è che ciò che farai funzionerà bene con uno spazio dei nomi noto delle chiavi. Tuttavia, si corre il rischio di collisione tra i dati e le funzioni con uno spazio dei nomi sconosciuto di chiavi.

Inserisco questa soluzione che ritengo abbastanza generica e può essere utile in quanto è semplice e facile da adattare a casi specifici:

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)

si può anche definire una lista in cui ogni elemento è un oggetto funzione e utilizzare il metodo __call__ incorporato. Crediti a tutti per l'ispirazione e la cooperazione.

"Il grande artista è il semplice", Henri Frederic Amiel