Python：在执行过程中分析复杂语句

Question

我想知道是否有任何方法可以获取有关执行期间 python 语句解释的一些元信息。

假设这是一个由一些与 or 连接的单个语句组成的复杂语句（A、B、...是布尔函数）

if A or B and ((C or D and E) or F) or G and H:

，我想知道语句的哪一部分导致语句计算为确实如此，我可以用这些知识做一些事情。在这个例子中，有 3 个可能的候选者：

A
B and ((C or D and E) or F)
G and H

在第二种情况下，我想知道评估的是 (C 或 D 和 E) 还是 F到 True 等等...

有没有办法不解析语句？我可以以某种方式连接到解释器或以我尚未找到的方式利用检查模块吗？我不想调试，这实际上是为了了解该或链的哪一部分在运行时触发了该语句。

编辑 - 更多信息：我想要使用它的应用程序类型是一种分类算法，它输入一个对象并根据其属性输出该对象的特定类别。我需要知道哪些属性对该类别具有决定性作用。
正如您可能猜到的，上面的复杂语句来自分类算法。该算法的代码是从正式的伪代码生成的，包含大约 3,000 个嵌套的 if-elif 语句，这些语句以分层方式确定类别，例如，

if obj.attr1 < 23 and (is_something(obj.attr10) or eats_spam_for_breakfast(obj)):
    return 'Category1'
elif obj.attr3 == 'Welcome Home' or count_something(obj) >= 2:
    return 'Category2a'
elif ...

除了类别本身之外，我还需要标记那些属性对于该类别具有决定性作用，因此，如果我删除所有其他属性，该对象仍会被分配给同一类别（由于语句中的或）。这些语句可能非常长，最多 1,000 个字符，并且嵌套很深。每个对象最多可以有 200 个属性。

非常感谢您的帮助！

编辑2：过去两周没有找到时间。感谢您提供这个解决方案，它有效！

Answer 1

您能否重新编码您的原始代码：

if A or B and ((C or D and E) or F) or G and H:

例如：

e = Evaluator()
if e('A or B and ((C or D and E) or F) or G and H'):

...？如果是这样，就有希望！-）。 Evaluator 类在 __call__ 后，将编译其字符串参数，然后使用（全局变量的空真实字典，以及）eval结果用于 locals 的伪dict，实际上将值查找委托给其调用者的局部变量和全局变量（只需要一点黑魔法，但是，还不错；-）还记下它查找的名称。考虑到 Python 的 and 和 or 的短路行为，您可以从实际查找的一组实际名称中推断出哪一个确定了表达式的真值（或每个子表达式）——在 X 或 Y 或 Z 中，第一个真值（如果有）将是最后一个查找的值，在 X 和 Y 和 Z 中/code>，第一个错误将会。

这有帮助吗？如果是，并且如果您需要编码方面的帮助，我很乐意对此进行扩展，但首先我想确认一下获取 Evaluator 的代码 确实正在解决您想要解决的任何问题！-)

编辑：所以这里是实现 Evaluator 的编码并举例说明其使用：

import inspect
import random

class TracingDict(object):

  def __init__(self, loc, glob):
    self.loc = loc
    self.glob = glob
    self.vars = []

  def __getitem__(self, name):
    try: v = self.loc[name]
    except KeyError: v = self.glob[name]
    self.vars.append((name, v))
    return v


class Evaluator(object):

  def __init__(self):
    f = inspect.currentframe()
    f = inspect.getouterframes(f)[1][0]
    self.d = TracingDict(f.f_locals, f.f_globals)

  def __call__(self, expr):
    return eval(expr, {}, self.d)


def f(A, B, C, D, E):
  e = Evaluator()
  res = e('A or B and ((C or D and E) or F) or G and H')
  print 'R=%r from %s' % (res, e.d.vars)

for x in range(20):
  A, B, C, D, E, F, G, H = [random.randrange(2) for x in range(8)]
  f(A, B, C, D, E)

这是示例运行的输出：

R=1 from [('A', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 0), ('B', 1), ('C', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 0), ('B', 0), ('G', 1), ('H', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 0), ('B', 1), ('C', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 0), ('B', 1), ('C', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 1)]
R=0 from [('A', 0), ('B', 0), ('G', 0)]
R=1 from [('A', 1)]
R=1 from [('A', 1)]
R=1 from [('A', 1)]
R=0 from [('A', 0), ('B', 0), ('G', 0)]
R=1 from [('A', 0), ('B', 1), ('C', 1)]

您经常可以看到（大约 50% 的时间）A 为真，这会使一切短路。当 A 为假时，B 进行计算——当 B 也为假时，接下来是 G，当 B 为真时，然后是 C。

Answer 2

据我记得，Python 本身不返回 True 或 False：

重要的例外：布尔值
操作 or 和 and 总是返回
它们的操作数之一。

Python 标准库 - 真值测试
因此，以下内容是有效的：

A = 1
B = 0
result = B or A # result == 1

Answer 3

Python 解释器不提供在运行时内省表达式求值的方法。 sys.settrace() 函数允许您注册一个为每一行源代码调用的回调，但这对于您想要执行的操作来说太粗粒度了。

也就是说，我尝试了一种疯狂的黑客方法，为执行的每个字节码调用该函数： Python字节码跟踪。

但即便如此，我也不知道如何找到执行状态，例如解释器堆栈上的值。

我认为获得你想要的唯一方法是通过算法修改代码。您可以转换源代码（尽管您说过不想解析代码），也可以转换编译后的字节码。这两项工作都不是一件简单的事，我确信如果你尝试的话，会有十几个困难的障碍需要克服。

抱歉让您失望了……

顺便说一句：这种技术有什么应用？

Answer 4

我会在大语句之前添加类似的内容（假设该语句在一个类中）：

for i in ("A","B","C","D","E","F","G","H"):
    print i,self.__dict__[i]

Answer 5

“”“我不想调试，这实际上是为了知道这个或链的哪一部分在运行时触发了语句。”“”：您可能需要解释“调试”和“知道哪个部分”之间的区别。

您的意思是观察者需要在运行时被告知发生了什么（为什么？）以便您可以做不同的事情，或者您的意思是代码需要“知道”以便它可以做不同的事情？

无论如何，假设你的 A、B、C 等没有副作用，为什么你不能简单地拆分你的 or 链并测试组件：

part1 = A
part2 = B and ((C or D and E) or F)
part3 = G and H
whodunit = "1" if part1 else "2" if part2 else "3" if part3 else "nobody"
print "Perp is", whodunit
if part1 or part2 or part3:
    do_something()

？

更新：

“调试和‘知道哪一部分’之间的区别是我需要为首先评估为 True（在运行时）的语句中使用的变量分配一个标志” ”

所以你是说，给定条件“A 或 B”，如果 A 为真且 B 为真，则 A 获得所有荣耀（或所有指责）？我发现很难相信您所描述的分类软件是基于“或”进行短路评估。您确定代码背后有“A 或 B”而不是“B 或 A”的意图吗？顺序可能是随机的，还是受到变量最初输入的顺序的影响？

无论如何，自动生成 Python 代码然后对其进行逆向工程似乎远远解决了这个问题。为什么不直接使用 part1 = yadda; 生成代码？第2部分=废话；等等性质？