Python dict en utilisant l'entrée logique pour les tables de vérité

Question

Très bien les garçons et les filles ici nous allons. Pour commencer, j'ai quelques questions à poser. Comme mon programme est vaste, je vais simplement poser des questions par étapes, cette question étant la première. Je crée un programme qui génère une table de vérité pour les expressions logiques postfixes. Voici les opérateurs autorisés et leurs équivalents logiques:

Operators: 
=    Logical Equivalence (≡ or ↔) 
`->` or `<=`  Logical Implication (→) 
+    Disjunction (∨), AKA “or” 
*    Conjunction (∧), AKA “and” 
`~` or `!`  Negation (¬), AKA “not” 

Voici quelques exemples d'entrée et de sortie:

input 
p True = 

output 
p  p True = 
False False 
True True 

input 
p ! 

output 
p  p ! 
False True 
True False 

input 
p q = 

output 
p  q  p q = 
False False True 
False True False 
True False False 
True True True 

Ok je ne vraiment pas savoir où commencer, mais je suis ne demandant à personne d'écrire ce programme pour moi. Je sais que je dois écrire du code en utilisant un dict Python, qui correspond aux clés de la proposition correspondante. Mais comment puis-je savoir lesquels mettre pour les clés et lesquels mettre pour les valeurs? En outre, dans le cas de:

`->` or `<=`  Logical Implication (→) 

et

`~` or `!`  Negation (¬), AKA “not” 

Comment attribuer 2 entrées différentes pour pouvoir être utilisé dans un dict python? J'espère que ce n'est pas trop confus, je suis très noob à python, toute aide est appréciée. Je vous remercie!

MISE À JOUR Ok voici le code que j'ai maintenant:

propositions = { 
    '=' : (2, {(True, True): True, 
       (True, False): False, 
       (False, True) : False, 
       (False, False): True, 
       }), 
    '->' : (2, {(True, True): True, 
       (True, False): False, 
       (False, True): True, 
       (False, False): True, 
       }), 
    '+' : (2, {(True, True): True, 
       (True, False): True, 
       (False, True): True, 
       (False, False): False, 
       }), 
    '*' : (2, {(True, True): True, 
       (True, False): False, 
       (False, True): False, 
       (False, False): False, 
       }), 
    '!' : (1, {True: False, 
       False: True})} 

prop = sys.stdin.readline() 
prop = prop.split() 
prop = prop[::-1] 
for x in prop: 

Je crois que je réussi à inverser la chaîne et enlevé tous les espaces blancs, mais je suis encore un peu confus sur itérer à travers elle.

MISE À JOUR DEUXIÈME Voici mon code:

propositions = { 
    '=' : (2, {(True, True): True, 
       (True, False): False, 
       (False, True) : False, 
       (False, False): True, 
       }), 
    '->' : (2, {(True, True): True, 
       (True, False): False, 
       (False, True): True, 
       (False, False): True, 
       }), 
    '+' : (2, {(True, True): True, 
       (True, False): True, 
       (False, True): True, 
       (False, False): False, 
       }), 
    '*' : (2, {(True, True): True, 
       (True, False): False, 
       (False, True): False, 
       (False, False): False, 
       }), 
    '!' : (1, {True: False, 
       False: True})} 

prop = sys.stdin.readline() 
prop = prop.strip().split() 
prop = reversed(prop) 
def evaluate(): 
    token = next(prop) 
    try: 
     nargs, table = propositions[token] 
    except KeyError: 
     if token.lower() in ('true', '1'): 
      return True 
     elif token.lower() in ('false', '0'): 
      return False 
     else: 
      return token 
    return table[tuple(evaluate() for i in range(nargs))] 

Answer 1

Vous devez construire votre dicts dans l'ordre de la résolution de l'extérieur vers intérieur:

master_dict = { 
    '=': (2, {(True, True): True, 
      (True, False): False, 
      ... 
      }), 
    ... 
    '!': (1, {True: False, 
      False: True})} 

Les chiffres indiquent le nombre opérandes l'opérateur prend .

Pour analyser une entrée, lisez-la de droite à gauche.

Utilisez une fonction récursive qui consomme un jeton à partir de la droite. (1) Si le jeton est un opérateur (c'est-à-dire une clé dans votre dictionnaire), récupérez la valeur correspondante dans votre dict principal.

Le numéro enregistré en premier est le nombre d'arguments pris par l'opérateur. Donc, votre fonction doit maintenant s'appeler autant de fois qu'il y a d'arguments. Assurez-vous de savoir quels jetons ont déjà été lus. Une bonne façon de procéder consiste à utiliser un itérateur de liste, qui crachera chaque élément une seule fois, de sorte que l'indexation ne sera pas correcte. Une fois que vous avez tous les arguments que vous appliquez la table de vérité que vous venez de récupérer, lisez le résultat et renvoyez-le. (2) Si le jeton n'est pas un oprateur, votre fonction doit simplement le renvoyer.

prop = sys.stdin.readline() 

def solve_no_var(prop): 
    rev_iter = reversed(prop) 
    def evaluate(): 
     token = next(rev_iter) 
     try: 
      nargs, table = propositions[token] 
     except KeyError: 
      if token.lower() in ('true', '1'): 
       return True 
      elif token.lower() in ('false', '0'): 
       return False 
      else: 
       return token 
     return table[tuple(evaluate() for i in range(nargs))] 
    return evaluate() 

def solve(prop): 
    prop = prop.strip().split() 
    variables = list(set(prop) - set(propositions) 
     - {'True', 'TRUE', 'true', '1', 'False', 'FALSE', 'false', '0'}) 
    lookup = {v: [j for j, p in enumerate(prop) if p == v] for v in variables} 
    N = len(variables) 
    print((N*" {:6} ").format(*variables), 'result') 
    for p in itertools.product(("True", "False"), repeat=N): 
     prop_nv = prop.copy() 
     for v, b in zip (variables, p): 
      for j in lookup[v]: 
       prop_nv[j] = b 
     res = solve_no_var(prop_nv) 
     print(((N+1)*" {:6} ").format(*(p + (res,)))) 

solve(prop)