Блог

Я получил выражение, проанализированное с помощью pyparsing, чтобы восстановить его как своего рода логическое дерево:

 expr = '(A and B) or C'
parsed -> OR_:[AND_:['A', 'B'] , 'C']
 

A, B и C-это ключи в дикте со строковыми значениями (без логических значений!)

OR_ (объединение) и AND_ (пересечение) являются только именами классов и ничего не делают rn, я подумываю о том, чтобы поместить оценщика в эти классы.

теперь мой вопрос в том, как мне превратить это проанализированное выражение в то, которое может оценить Python? Я пытаюсь либо взять какое-то строковое значение и посмотреть, соответствует ли оно условиям всего выражения, либо выполнить итерацию по каждому подвыражению и добавить его в список результатов.

Пример:

 dict: {'A': ['Hi', 'No', 'Yes'], 'B': ['Why', 'No', 'Okay'], 'C': ['Okay']}
expression = '(A and B) or C'
if value in expression:
 output.append(value)
output -> ['No', 'Okay']  #intersection of A and B, union of that with C
 

Это что-то в этом роде, но if value in expression именно это меня беспокоит, потому что я не могу придумать другого способа написать это.

Мы можем проанализировать и перевести наше выражение с помощью ast модуля. Сначала мы анализируем наш оператор , а затем определяем преобразователь узлов , который обменивается and amp; or именами переменных в функции, с | ними и переносит их в set функцию. Затем мы можем скомпилировать этот переведенный ast и оценить его в контексте нашего словаря.

 import ast
from typing import Dict, Hashable, List, NoReturn, TypeVar

A = TypeVar('A', bound=Hashable)


def evaluate_logic(expr: str, context: Dict[str, List[A]]) -> List[A]:
    tr = ast.parse(expr, mode='eval')
    new_tr = ast.fix_missing_locations(TranslateLogic().visit(tr))
    co = compile(new_tr, filename='', mode='eval')
    return list(eval(co, context))


class TranslateLogic(ast.NodeTransformer):
    def visit_BoolOp(self, node: ast.BoolOp) -> ast.BinOp:
        op = node.op
        new_op = ast.BitAnd() if isinstance(op, ast.And) else ast.BitOr()
        return nested_op(new_op, [self.visit(value) for value in node.values])

    def visit_Name(self, node: ast.Name) -> ast.Call:
        return call_set(node)

    def visit_Expression(self, node: ast.Expression) -> ast.Expression:
        return super().generic_visit(node)

    def generic_visit(self, node: ast.AST) -> NoReturn:
        raise ValueError(f"cannote visit node: {node}")


def nested_op(op, values: List[ast.AST]) -> ast.BinOp:
    if len(values) < 2:
        raise ValueError(f"tried to nest operator with fewer than two values")
    elif len(values) == 2:
        left, right = values
        return ast.BinOp(left=left, op=op, right=right)
    else:
        left, *rest = values
        return ast.BinOp(left=left, op=op, right=nested_op(op, rest))


def call_set(node: ast.Name) -> ast.Call:
    return ast.Call(func=ast.Name(id='set', ctx=node.ctx), args=[node], keywords=[])


if __name__ == '__main__':
    expr = '(A and B) or C'
    context = {'A': ['Hi', 'No', 'Yes'], 'B': ['Why', 'No', 'Okay'], 'C': ['Okay']}

    print(evaluate_logic(expr, context))
    # prints ['No', 'Okay']
 

Я бы сказал, что это демонстрирует сложность общего синтаксического анализа в Python, а затем применения пользовательской логики в Python даже при использовании существующих библиотек синтаксического анализа.

Несколько заметок. В конечном итоге мы оцениваем код, который предоставляет пользователь. Есть некоторая безопасность, потому что generic_visit должна возникнуть ошибка, если пользователь предоставит что-то более сложное, чем просто and s и or s, но я бы очень настороженно относился к этому коду в производственной ситуации.

Во-вторых, при переводе and на amp; (и or на ) возникает небольшая сложность | из-за того, как Python представляет цепочку and s по сравнению с цепочкой amp; s. Цепочка and s становится одним BoolOp узлом с несколькими значениями, в то время как цепочка amp; BinOp s становится вложенной, каждая из которых имеет левое и правое значение. Сравнить

 ast.dump(ast.parse('A and B and C', mode='eval'))
# "Expression(body=BoolOp(op=And(), values=[Name(id='A', ctx=Load()), Name(id='B', ctx=Load()), Name(id='C', ctx=Load())]))"
 

Для

 ast.dump(ast.parse('A amp; B amp; C', mode='eval'))
# "Expression(body=BinOp(left=BinOp(left=Name(id='A', ctx=Load()), op=BitAnd(), right=Name(id='B', ctx=Load())), op=BitAnd(), right=Name(id='C', ctx=Load())))"
 

Это объясняет, почему нам нужна nested_op вспомогательная функция.

Наконец, без дополнительной информации мы не сможем реализовать not . Причина в том, что мы не определили «вселенную дискурса». В частности, что следует not A оценить? Я вижу два возможных решения:

1. Добавьте дополнительный аргумент для определения универсума дискурса. Добавьте a visit_UnaryOp not A , чтобы перевести что-то вроде set(U) - set(A) «где U находится вселенная дискурса».
2. Рассматривайте not как двоичный оператор разности множеств. В этом случае, вероятно, было бы проще всего предварительно обработать выражение в виде строки для замены " not " " - " .

Учитывая все сказанное, вы, скорее всего, избавите себя от множества проблем, если просто заставите своих пользователей работать с более простым (для вас) интерфейсом. Что-то вроде

 from my_module import And, Or

expr = Or(And("A", "B"), "C")
context = {'A': ['Hi', 'No', 'Yes'], 'B': ['Why', 'No', 'Okay'], 'C': ['Okay']}

evaluate_logic(expr, context)
 

Вы заставляете своих пользователей предварительно анализировать выражение, которое они вам дают, но вы избавляете себя от множества беспокойств и проблем.

Вы можете использовать двоичные операторы, если преобразуете их в наборы:

 output = list(set(a) amp; set(b) | set(c))