Question

我有一个函数可以检查3个不同的布尔标志，并且对8种组合中的每一种都有独特的结果。

Lemma not_eq_S2: forall m n, S m <> S n -> m <> n.

Proof. intros m n HS HC. 
  rewrite HC in HS. auto.
Qed.

自从我回来（退出循环）以来，我已经将很多""" a | b | c | out - + - + - + --- 0 | 0 | 0 | 0 0 | 0 | 1 | 1 0 | 1 | 0 | 2 0 | 1 | 1 | 3 1 | 0 | 0 | 4 1 | 0 | 1 | 5 1 | 1 | 0 | 6 1 | 1 | 1 | 7 """ def do_stuff(a, b, c): if a: if b: if c: return function7() # a, b, c return function6() # a, b, !c if c: return function5() # a, !b, c return function4() # a, !b, !c else: if b: if c: return function3() # !a, b, c return function2() # !a, b, !c if c: return function1() # !a, !b, c return function0() # !a, !b, !c语句缩减了。

是否有更干的方法来实现这一目标？我可以转换为二进制，并执行if / elif的单个深度级别，但我不想使用“魔术数字”。

另外，我意识到这只有16行代码用于8个结果，但是如果它是4个变量，有没有办法提高可读性/流量？

Answer 1

您需要从结果到函数以及从输入到结果的映射进行某种映射。您在顶部提供的漂亮表格，以及Python中的bool只是整数0和1这一事实为您提供了以下内容：

outcomeToFunc {
    0: function0,
    1: function1,
    2: function2,
    3: function3,
    4: function4
    # etc...
}

def inputToOutcome(a, b, c):
    return a << 2 | b << 1 | c

def do_stuff(a, b, c):
    outcome = inputToOutcome(a, b, c)
    return outcomeToFunc[outcome]()

如果您对拥有任意数量的布尔输入感兴趣，可以修改do_stuff和inputToOutcome以使用varargs：

outcomeToFunc {
    0: function0,
    1: function1,
    2: function2,
    3: function3,
    4: function4
    # etc...
}

def inputToOutcome(*args):
    outcome = 0
    n = len(args) - 1
    for ind, arg in enumerate(args):
        outcome |= bool(arg) << (n - ind)
    return outcome

def do_stuff(*args):
    outcome = inputToOutcome(*args)
    try:
        return outcomeToFunc[outcome]()
    except KeyError:
        raise ValueError('Outcome {} not supported'.format(outcome))

Answer 2

这是两个解决方案。由你来决定它们是否比你提出的更漂亮。

def do_stuff(a, b, c):
    flags = bool(a), bool(b), bool(c)
    if flags == (True, True, True):
        return function7()
    if flags == (True, True, False):
        return function6()
    if flags == (True, False, True):
        return function5()
    if flags == (True, False, False):
        return function4()
    if flags == (False, True, True):
        return function3()
    if flags == (False, True, False):
        return function2()
    if flags == (False, False, True):
        return function1()
    if flags == (False, False, False):
        return function0()

def do_stuff(a, b, c):
    control = {
        (True, True, True): function7,
        (True, True, False): function6,
        (True, False, True): function5,
        (True, False, False): function4,
        (False, True, True): function3,
        (False, True, False): function2,
        (False, False, True): function1,
        (False, False, False): function0,
    }
    return control[bool(a), bool(b), bool(c)]()

Answer 3

首先，您可以构建二进制到十进制转换器。获取新数字后，您可以通过eval函数在字符串中按函数名称调用方法：

def function0():
    print("function0")
def function1():
    return 1;
a = eval("function1()")
print(a)

请记住，除非使用当前的全局名称id，否则可以将全局变量传递给eval函数。

Python简化了多个布尔条件的检查

3 个答案: