Python dict使用真值表的逻辑输入_Python_Dictionary_Logic_Logical Operators

Python dict使用真值表的逻辑输入

python dictionary logic

Python dict使用真值表的逻辑输入,python,dictionary,logic,logical-operators,Python,Dictionary,Logic,Logical Operators,好了，孩子们，我们开始了。首先，我有几个问题。由于我的课程规模很大，我将分阶段提问，这个问题是第一个问题。我正在创建一个为后缀逻辑表达式生成真值表的程序。以下是允许的运算符及其逻辑等价物： Operators: = Logical Equivalence (≡ or ↔) `->` or `<=` Logical Implication (→) + Disjunction (∨), AKA “or” *

好了，孩子们，我们开始了。首先，我有几个问题。由于我的课程规模很大，我将分阶段提问，这个问题是第一个问题。我正在创建一个为后缀逻辑表达式生成真值表的程序。以下是允许的运算符及其逻辑等价物：

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

好吧，我真的不知道从哪里开始，但我不是要求任何人为我写这个程序。我知道我需要使用Python dict编写代码，该dict将键与相应的命题相匹配。但我怎么知道哪些是键，哪些是值呢？此外，在以下情况下：

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

如何分配两个不同的输入，以便能够在python dict中使用？我希望这不会太令人困惑，我对python非常在行，非常感谢您的帮助。谢谢大家!

更新好的，这是我现在的代码：

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:

我相信我成功地反转了字符串并删除了所有空格，但在遍历它时我仍然有点困惑

第二个更新是我的代码：

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

您必须按照从外部到内部的解决顺序构建您的DICT：

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

这些数字表示运算符的操作数

要解析输入，请从右向左读取

使用递归函数，该函数使用右侧的一个令牌

（1）如果令牌是运算符（即词典中的键），则从主dict中检索相应的值

首先存储的数字是运算符接受的参数数。因此，函数现在必须在有参数的情况下多次调用自身。确保跟踪哪些令牌已经被读取。一种简洁的方法是使用一个列表迭代器，它会精确地吐出每个元素一次，这样就不会使索引出错。获得所有参数后，应用刚检索到的真值表，读取结果并返回

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)

（2）如果令牌不是运算符，则函数必须返回它

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)