Python 如何重新排列布尔逻辑以更快地短路？
我有一个问题，我有一堆需要很长时间才能执行的函数，每个函数都返回一个布尔真/假。我将一个巨大的布尔表达式应用于所有函数，以获得总体的真/假分数。目前我的代码不是基于函数的，所以所有函数都会执行，然后应用大型布尔表达式。我已经发现，让它们成为函数将允许使用子表达式，这些子表达式会缩短圈以防止某些函数调用。我现在需要的是一种对表达式重新排序的方法，这样我就有了最少的调用次数 考虑到下面的代码示例，您应该明白：Python 如何重新排列布尔逻辑以更快地短路？,python,boolean-logic,Python,Boolean Logic,我有一个问题，我有一堆需要很长时间才能执行的函数，每个函数都返回一个布尔真/假。我将一个巨大的布尔表达式应用于所有函数，以获得总体的真/假分数。目前我的代码不是基于函数的，所以所有函数都会执行，然后应用大型布尔表达式。我已经发现，让它们成为函数将允许使用子表达式，这些子表达式会缩短圈以防止某些函数调用。我现在需要的是一种对表达式重新排序的方法，这样我就有了最少的调用次数 考虑到下面的代码示例，您应该明白： def q(): print "q" return False def
def q():
print "q"
return False
def r():
print "r"
return False
def s():
print "s"
return False
def a():
print "a"
return False
def b():
print "b"
return False
def c():
print "c"
return False
def d():
print "d"
return False
def i():
print "i"
return False
def j():
print "j"
return False
(q() or r() or s()) and (a() and b() and c() and (i() or j()))
目前你还没有合并，你可以找到一些额外的有用的东西。尤其是如何将这些函数再次转换为CNF以及来自CNF的想法可能会对您有所帮助。要优化表达式，您需要知道两件事：每个函数的成本以及它短路的概率。一旦你有了它，你可以计算每个子表达式来产生相同的术语；尝试参数顺序的每个排列将显示哪种排列成本最低
def evaluate_or(argument_evaluation_list):
total_cost = 0.0
probability_of_reaching = 1.0
for cost, probability_of_true in argument_evaluation_list:
total_cost += probability_of_reaching * cost
probability_of_reaching *= 1.0 - probability_of_true
return total_cost, 1.0 - probability_of_reaching
def evaluate_and(argument_evaluation_list):
total_cost = 0.0
probability_of_reaching = 1.0
for cost, probability_of_true in argument_evaluation_list:
total_cost += probability_of_reaching * cost
probability_of_reaching *= probability_of_true
return total_cost, probability_of_reaching
def evaluate_not(argument_evaluation)
cost, probability_of_true = argument_evaluation
return cost, 1.0 - probability_of_true
要优化表达式，需要知道两件事：每个函数的成本和它短路的概率。一旦你有了它，你可以计算每个子表达式来产生相同的术语；尝试参数顺序的每个排列将显示哪种排列成本最低
def evaluate_or(argument_evaluation_list):
total_cost = 0.0
probability_of_reaching = 1.0
for cost, probability_of_true in argument_evaluation_list:
total_cost += probability_of_reaching * cost
probability_of_reaching *= 1.0 - probability_of_true
return total_cost, 1.0 - probability_of_reaching
def evaluate_and(argument_evaluation_list):
total_cost = 0.0
probability_of_reaching = 1.0
for cost, probability_of_true in argument_evaluation_list:
total_cost += probability_of_reaching * cost
probability_of_reaching *= probability_of_true
return total_cost, probability_of_reaching
def evaluate_not(argument_evaluation)
cost, probability_of_true = argument_evaluation
return cost, 1.0 - probability_of_true
可以将表达式转换为树结构，其中每个分支表示有序子级列表上的任意或所有进程。第一个为假时所有分支短路，第一个为真时任何分支短路 如果所有条件都具有相同的权重，则可以将简单条件的叶子放在第一位，然后再将分支按其单个复杂性度量的数量递归地增加其子级复杂性的总和排序 因此，在这种树结构中表示的条件如下所示：
ALL:
*--- ANY: q(), r(), q()
a()
b()
c()
*--- ANY: i(), j()
ALL:
3 *--- ANY: q(), r(), q()
1 a()
1 b()
1 c()
2 *--- ANY: i(), j()
---
8
ALL:
1 a()
1 b()
1 c()
2 *--- ANY: i(), j()
3 *--- ANY: q(), r(), q()
---
8
在这些额外的因素之间找到正确的平衡可能是一门艺术，并且将非常依赖于解决方案的域。您可以将表达式转换为树结构，其中每个分支表示有序子级列表上的任意或所有进程。第一个为假时所有分支短路，第一个为真时任何分支短路 如果所有条件都具有相同的权重，则可以将简单条件的叶子放在第一位，然后再将分支按其单个复杂性度量的数量递归地增加其子级复杂性的总和排序 因此，在这种树结构中表示的条件如下所示：
ALL:
*--- ANY: q(), r(), q()
a()
b()
c()
*--- ANY: i(), j()
ALL:
3 *--- ANY: q(), r(), q()
1 a()
1 b()
1 c()
2 *--- ANY: i(), j()
---
8
ALL:
1 a()
1 b()
1 c()
2 *--- ANY: i(), j()
3 *--- ANY: q(), r(), q()
---
8