Dynamiquement appelant les fonctions imbriquées basées sur des arguments

Question

Si j'ai la classe Python suivante:

class Test(object): 
    funcs = { 
     "me" : "action", 
     "action": "action", 
     "say" : "say", 
     "shout" : "say" 
    } 

    def dispatch(self, cmd): 
     def say: 
      print "Nested Say" 

     def action: 
      print "Nested Action" 

     # The line below gets the function name as a string, 
     # How can I call the nested function based on the string? 
     Test.funcs.get(cmd, "say") 

Je voudrais être en mesure de faire ce qui suit:

>>> Test().dispatch("me") 
Nested Action 
>>> Test().dispatch("say") 
Nested Say 

Des suggestions quant à la façon dont je peux vas-y?

Answer 1

je ferais probablement quelque chose comme ceci:

def register(dict_, *names): 
    def dec(f): 
     m_name = f.__name__ 
     for name in names: 
      dict_[name] = m_name 
     return f 
    return dec 

class Test(object): 

    commands = {} 

    @register(commands, 'foo', 'fu', 'fOo') 
    def _handle_foo(self): 
     print 'foo' 

    @register(commands, 'bar', 'BaR', 'bAR') 
    def _do_bar(self): 
     print 'bar' 

    def dispatch(self, cmd): 
     try: 
      return getattr(self, self.commands[cmd])() 
     except (KeyError, AttributeError): 
      # Command doesn't exist. Handle it somehow if you want to 
      # The AttributeError should actually never occur unless a method gets 
      # deleted from the class 

Maintenant, la classe expose une dict dont les clés sont des commandes pour l'adhésion de test. Toutes les méthodes et le dictionnaire sont créés une seule fois.

t = Test() 

if 'foo' in t.commands: 
    t.dispatch('foo') 

for cmd in t.commands: 
    # Obviously this will call each method with multiple commands dispatched to it once 
    # for each command 
    t.dispatch(cmd) 

Etc.

Answer 2

class Test(object): 

    def dispatch(self): 
     def say(): 
      print "Nested Say" 

     def action(): 
      print "Nested Action" 

     funcs = { 
      "me" : action, 
      "action": action, 
      "say" : say, 
      "shout" : say 
     } 

     Test.funcs.get(cmd, say)() 

Ou, en gardant votre structure actuelle:

class Test(object): 

    funcs = { 
     "me" : "action", 
     "action": "action", 
     "say" : "say", 
     "shout" : "say" 
     } 

    def dispatch(self, cmd): 
     def say(): 
      print "Nested Say" 

     def action(): 
      print "Nested Action" 

     locals()[Test.funcs.get(cmd, "say")]() 

Je trouve cette conception un peu bizarre, cependant. Pourquoi le dict de classe devrait-il être au courant des fonctions locales de dispatch?