expressions dans un mappage dictionnaire

Question

I ont une série de conditionals de la forme:

if ':' in particle: 
    do something 
elif 'eq' in particle: 
    do something else 
elif 'lt' in particle: 
    do another thing 
elif 'le' in particle: 
    etc. 
elif 'gt' in particle: 
    etc., etc. 
elif 'ge' in particle: 
    etc., etc., etc. 
elif 'ne' in particle: 
    more etc. 

Je veux mettre en œuvre ce en utilisant un modèle de cartographie dictionnaire, mais ai des problèmes avec les clés.

J'ai essayé ceci:

def case_evaluator(particle): 
    switcher = { 
     ':' in particle: do something, 
     'eq' in particle: do something else, 
     'lt' in particle: do another thing, 
     ... 
    } 
    return switcher.get(particle, "nothing") 

Mais, je continué à obtenir "rien". Comment quelque chose peut-il ne rien donner?

Cela semble que cela devrait être simple, mais hélas ...

Answer 1

Vous souhaitez probablement avoir un dictionnaire qui mappe les caractères sur les fonctions.

char_function_dict = { 
    ':': colon_function, 
    'eq': eq_function, 
    'lt': lt_function 
    # ...and so on... 
} 

Ensuite, vous pouvez parcourir les paires valeur/clé de ce dictionnaire.

def apply_function(particle): 
    for char, function in char_function_dict.items(): 
     if char in particle: 
      function() 

Toutefois, notez que cette structure ne dictionnaires et n'utilise pas vraiment quoi que ce soit spécifique à préserver pas l'ordre que les caractères sont vérifiés. Il serait peut-être encore plus simple d'utiliser une liste de tuples à 2 éléments.

char_functions = [ 
    (':', colon_function), 
    ('eq', eq_function), 
    ('lt', lt_function) 
    # ...and so on... 
] 

def apply_function(particle): 
    for char, function in char_functions: 
     if char in particle: 
      function() 
      break # so successive functions are not run 

Mise en place l'une de ces structures pour permettre des arguments et/ou des arguments clés à transmettre aux fonctions est facile:

def apply_function(particle, *args, **kwargs): 
    for char, function in char_functions: 
     if char in particle: 
      function(*args, **kwargs) 
      break 

Answer 2

Vous êtes sur la bonne voie. C'est ce qu'on appelle la répartition des fonctions. Il doit ressembler à ceci:

def case_evaluator(particle): 
    switcher = { 
     ':': do_something, 
     'eq': do_something_else, 
     'lt': do_another_thing, 
     ... 
    } 
    return switcher.get(particle, lambda: "nothing")() 

où do_something, etc sont toutes les fonctions qui ne prennent pas d'arguments. Le lambda x: "nothing" est une fonction lambda qui retourne toujours "rien" - c'est la fonction par défaut à appeler si particle est introuvable dans switcher.keys().