Dynamisch verschachtelte Funktionen auf Argumente basieren Aufruf

Question

Wenn ich die folgende Python-Klasse:

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

Ich möchte in der Lage sein, Folgendes zu tun:

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

Irgendwelche Vorschläge, wie kann ich gehst du darüber?

Answer 1

Ich würde wahrscheinlich etwas tun:

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 

Nun macht die Klasse ein dict, dessen Schlüssel Befehle zum Testen Mitgliedschaft. Alle Methoden und das Wörterbuch werden nur einmal erstellt.

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

Oder Ihre aktuelle Struktur zu halten:

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")]() 

Ich finde das Design ein wenig seltsam, aber. Warum sollte das Diktat auf Klassenebene über die lokalen Funktionen des Versands Bescheid wissen?