Python генерирует правдоподобные выражения, содержащие числовые значения и компараторы

Question

Python генерирует правдоподобные выражения, содержащие числовые значения и компараторы

1

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

(10 <a) и (c == 5)

таблицы истинности выглядят как хороший подход, и генерация вывода может выглядеть так:

>  a,  c, result
> 11,  5,   True,
> 11,  4,  False,
>  9,  5,  False,
>  9,  4,  False

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

class Expr():

    def __init__(self, expr):
        self.tree = ast.parse(expr)
        self.expr=expr
        self.vars = self.allVariables().visit(self.tree)
        self.generateTruthTable()

    def generateTruthTable(self):
        NO_GLOBALS = {'__builtins__': {}}
        self.truthtable=dict()
        for i, vals in enumerate(product([True,False],repeat=len(self.vars))):
            self.truthtable[i] = dict()
            self.truthtable[i]['inputs'] = dict(zip(self.vars, vals))
            self.truthtable[i]['expectation'] = eval(self.expr, NO_GLOBALS, self.truthtable[i]['inputs'])

    class allVariables(ast.NodeVisitor):
        def visit_Module(self, node):
            self.names = set()
            self.generic_visit(node)
            return sorted(self.names)

        def visit_Name(self, node):
            self.names.add(node.id)

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

S. Pech 25 июль 2018, в 12:11

Источник

0

Знаете ли вы переменные в выражении, или вы должны сначала их найти? Кроме того, может ли выражение быть «доверенным», то есть вы могли бы просто eval его?
tobias_k 25 июль 2018, в 09:15
0

выражению можно доверять, а ожидаемый результат можно оценить с помощью eval. Я не знаю переменных с самого начала, поэтому я создал этот посетитель allVariables, чтобы получить их
S. Pech 25 июль 2018, в 09:35
0

Если вы не знаете переменных, откуда берутся значения? (Спросите, потому что в вашем примере они не одинаковы для каждой переменной, поэтому некоторые знания о переменных кажутся вероятными.)
tobias_k 25 июль 2018, в 10:57
0

В моем выходном примере я установил переменную в значения, которые привели бы к левой части операции and true или false, если a = 11, тогда 10 <a - True, если a = 9, 10 <a - False. Но это могло быть 100 и 0. Надеюсь, теперь стало понятнее
S. Pech 25 июль 2018, в 16:47

Показать ещё 2 комментария

Теги:

python

abstract-syntax-tree

truthtable

1 ответ

Ещё вопросы

Знаете ли вы переменные в выражении, или вы должны сначала их найти? Кроме того, может ли выражение быть «доверенным», то есть вы могли бы просто eval его?
выражению можно доверять, а ожидаемый результат можно оценить с помощью eval. Я не знаю переменных с самого начала, поэтому я создал этот посетитель allVariables, чтобы получить их
Если вы не знаете переменных, откуда берутся значения? (Спросите, потому что в вашем примере они не одинаковы для каждой переменной, поэтому некоторые знания о переменных кажутся вероятными.)
В моем выходном примере я установил переменную в значения, которые привели бы к левой части операции and true или false, если a = 11, тогда 10 <a - True, если a = 9, 10 <a - False. Но это могло быть 100 и 0. Надеюсь, теперь стало понятнее

S. Pech · Accepted Answer · 2018-07-26T06-59-00.000Z

Я нашел решение проблемы, мне просто пришлось сдерживать использование, чтобы это числовое значение не заканчивалось справа от операции, а также ограничивало возможность в терминах операторов.

import ast
import operator
from itertools import product

class OperatorError(Exception):
    pass

class Expr():

    BOOLOP_SYMBOLS = (
        ast.And,
        ast.Or
    )

    UNARYOP_SYMBOLS = (
        ast.Not
    )

    BINOP_SYMBOLS = (
        ast.BitAnd,
        ast.BitXor,
        ast.Pow
    )

    CMPOP_SYMBOLS = (
        ast.Eq,
        ast.Gt,
        ast.GtE,
        ast.Lt,
        ast.LtE,
        ast.NotEq
    )

    def __init__(self, expr):
        self.tree = ast.parse(expr)
        self.expr=expr
        self.vars = self.SyntaxChecker().visit(self.tree)
        self.tt = self.generateTruthTable()

    def generateTruthTable(self):
        NO_GLOBALS = {'__builtins__': {}}
        truthtable=dict()
        for i, vals in enumerate(product([True,False],repeat=len(self.vars.keys()))):
            truthtable[i] = dict()
            vals_convert=[]
            for j,k in enumerate(self.vars.iterkeys()):
                vals_convert.append(self.vars[k][vals[j]])
            truthtable[i]['inputs'] = dict(zip(self.vars.keys(), vals_convert))
            truthtable[i]['expectation'] = eval(self.expr, NO_GLOBALS, truthtable[i]['inputs'])
        return truthtable

    class SyntaxChecker(ast.NodeVisitor):

        def visit_Module(self, module):
            self.vars = dict()
            self.generic_visit(module)
            return self.vars

        def visit_Expr(self, expr):
            return self.visit(expr.value)

        def visit_BoolOp(self, boolop):
            if isinstance(boolop.op, Expr.BOOLOP_SYMBOLS):
                left,right = map(self.visit, boolop.values)
                return [left, right]
            else:
                raise OperatorError(Expr.BOOLOP_SYMBOLS[boolop.op] + ' is not supported.')

        def visit_BinOp(self, binop):
            if isinstance(binop.op, Expr.BINOP_SYMBOLS):
                left , right = map(self.visit, [binop.left, binop.right])
                if isinstance(binop.op, ast.BitAnd):
                    self.vars[left] = {True: right, False: 0}
                if isinstance(binop.op, ast.BitXor):
                    self.vars[left] = {True: 0, False: right}
                if isinstance(binop.op, ast.Pow):
                    return left ** right
            else:
                raise OperatorError(Expr.BINOP_SYMBOLS[binop.op] + ' is not supported.')

        def visit_Compare(self, cmpop):
            if isinstance(cmpop.ops[0], Expr.CMPOP_SYMBOLS):
                left = self.visit(cmpop.left)
                right = self.visit(cmpop.comparators[0])
                if isinstance(cmpop.ops[0], ast.Gt):
                    self.vars[left] = {True: right + 1, False: right - 1}
                elif isinstance(cmpop.ops[0], ast.GtE):
                    self.vars[left] = {True: right, False: right - 1}
                elif isinstance(cmpop.ops[0], ast.Lt):
                    self.vars[left] = {True: right-1, False: right + 1}
                elif isinstance(cmpop.ops[0], ast.LtE):
                    self.vars[left] = {True: right, False: right + 1}
                elif isinstance(cmpop.ops[0], ast.Eq):
                    self.vars[left] = {True: right, False: right + 1}
                elif isinstance(cmpop.ops[0], ast.NotEq):
                    self.vars[left] = {True: right + 1, False: right}
            else:
                raise OperatorError(Expr.CMPOP_SYMBOLS[cmpop.ops] + ' is not supported.')

        def visit_UnaryOp(self, unaryop):
            if isinstance(unaryop.op, Expr.UNARYOP_SYMBOLS):
                right= self.visit(unaryop.operand)
                self.vars[right] = {True: False, False: True}
            else:
                raise OperatorError(Expr.UNARYOP_SYMBOLS[unaryop.op] + ' is not supported.')

        def visit_Num(self, num):
            return num.n

        def visit_Name(self, node):
            self.vars[node.id] = {True: True, False: False}
            return node.id

с примером:

(a <10) и (c == 5)

Я могу сгенерировать следующий результат:

{0: {'input': {'a': 9, 'c': 5}, 'expectation': True}, 1: {'input': {'a': 9, 'c': 6}, 'Ожидание': False}, 2: {'input': {'a': 11, 'c': 5}, 'expectation': False}, 3: {'input': {'a': 11, ' c ': 6},' expectation ': False}}

не стесняйтесь предлагать какие-либо улучшения этого решения.