Equivalent "Pythonic" pour la gestion des commutateurs et des comparaisons de chaînes multiples

Question

Très bien, donc mon titre a été aspiré. Un exemple fonctionne mieux:

input = 'check yahoo.com' 

Je veux analyser l'entrée, en utilisant le premier mot comme la « commande », et le reste de la chaîne en tant que paramètre. Voici la version simple de la façon dont mon esprit non-Pythonic est le coder:

if len(input) > 0: 
    a = input.split(' ') 
    if a[0] == 'check': 
     if len(a) > 1: 
      do_check(a[1]) 
    elif a[0] == 'search': 
     if len(a) > 1: 
      do_search(a[1]) 

J'aime Python parce qu'il rend les choses normalement compliquées en des choses assez simples. Je ne suis pas trop expérimenté avec ça, et je suis à peu près sûr qu'il y a une bien meilleure façon de faire ces choses ... d'une façon un peu plus pythonique. J'ai vu quelques exemples de personnes remplaçant des instructions switch avec des fonctions dicts et lambda, alors que d'autres personnes ont simplement recommandé if..else nests.

Answer 1

dispatch = { 
    'check': do_check, 
    'search': do_search, 
} 
cmd, _, arg = input.partition(' ') 
if cmd in dispatch: 
    dispatch[cmd](arg) 
else: 
    do_default(cmd, arg) 

Answer 2

Si vous êtes à la recherche d'une approche « pythonique » une doublure à ce que vous pouvez utiliser ceci:

def do_check(x): print 'checking for:', x 
def do_search(x): print 'searching for:', x 

input = 'check yahoo.com' 
{'check': do_check}.get(input.split()[0], do_search)(input.split()[1]) 
# checking for: yahoo.com 

input = 'search google.com' 
{'check': do_check}.get(input.split()[0], do_search)(input.split()[1]) 
# searching for: google.com 

input = 'foo bar.com' 
{'check': do_check}.get(input.split()[0], do_search)(input.split()[1]) 
# searching for: bar.com 

Answer 3

Cela vous permet d'éviter de donner le nom de chaque commande deux fois; Les noms de fonctions sont utilisés presque directement comme noms de commande.

class CommandFunctions: 
    def c_check(self, arg): 
     print "checking", arg 

    def c_search(self, arg): 
     print "searching for", arg 

    def c_compare(self, arg1, arg2): 
     print "comparing", arg1, "with", arg2 

    def execute(self, line): 
     words = line.split(' ') 
     fn = getattr(self, 'c_' + words[0], None) 
     if fn is None: 
      import sys 
      sys.stderr.write('error: no such command "%s"\n' % words[0]) 
      return 
     fn(*words[1:]) 

cf = CommandFunctions() 
import sys 
for line in sys.stdin: 
    cf.execute(line.strip()) 

Answer 4

Je suis assez sûr qu'il ya une meilleure façon de faire ces choses ... une façon plus pythonique.

Pas vraiment. Vous codez est simple, clair, évident et anglais.

j'ai vu quelques exemples de personnes qui remplacent leurs déclarations de commutation avec dicts et fonctions lambda,

Oui, vous les avez vus et ils ne sont pas claires, évidentes ou en anglais comme. Ils existent parce que certaines personnes aiment tordre leurs mains sur l'instruction de commutation.

alors que d'autres personnes ont simplement recommandé si..sose nids.

Correct. Ils travaillent. Ils sont simples, clairs, ...

Votre code est bon. Laisser seul. Passez.

Answer 5

Mépris, je viens de réaliser que ma réponse était semblable à celle des autres réponses - et apparemment il n'y a pas de clé de suppression :)

Answer 6

Variation sur @MizardX's answer:

from collections import defaultdict 

dispatch = defaultdict(do_default, check=do_check, search=do_search) 
cmd, _, arg = input.partition(' ') 
dispatch[cmd](arg)