Question

好，

我正在研究一个语言证明者，我有一系列代表语句或表达式的元组。有时，我最终会得到一个嵌入式的“和”声明，而我正试图将其“冒泡”到表面。我想要一个看起来像这样的元组：

('pred', ('and', 'a', 'b'), 'x')

或者，更简单的例子：

( ('and', 'a', 'b'), 'x')

我希望将ands分成两个语句，使得前一个语句产生：

('and', ('pred', 'a', 'x',), ('pred', 'b', 'x') )

和底部的：

('and', ('a', 'x'), ('b', 'x') )

我已经尝试了很多东西，但它总是变得非常难看。如果有更多嵌套元组，我会遇到问题：

('not', ('p', ('and', 'a', 'b'), 'x') )

我想导致

('not', ('and', ('p', 'a', 'x',), ('p', 'b', 'x') ) )

基本上，问题是尝试用整个元组的值替换嵌套元组，但嵌套的元组被修改。这很难看。：（

我不是超级炙手可热的python，所以它变得非常复杂，有许多for循环，我知道不应该在那里。 :( 非常感谢任何帮助！

Answer 1

这种递归方法似乎有效。

def recursive_bubble_ands_up(expr):
    """ Bubble all 'and's in the expression up one level, no matter how nested.
    """
    # if the expression is just a single thing, like 'a', just return it. 
    if is_atomic(expr):
        return expr
    # if it has an 'and' in one of its subexpressions 
    #  (but the subexpression isn't just the 'and' operator itself)
    #  rewrite it to bubble the and up
    and_clauses = [('and' in subexpr and not is_atomic(subexpr)) 
                   for subexpr in expr]
    if any(and_clauses):
        first_and_clause = and_clauses.index(True)
        expr_before_and = expr[:first_and_clause]
        expr_after_and = expr[first_and_clause+1:]
        and_parts = expr[first_and_clause][1:]
        expr = ('and',) + tuple([expr_before_and + (and_part,) + expr_after_and 
                                 for and_part in and_parts])
    # apply recursive_bubble_ands_up to all the elements and return result
    return tuple([recursive_bubble_ands_up(subexpr) for subexpr in expr])

def is_atomic(expr):
    """ Return True if expr is an undividable component 
    (operator or value, like 'and' or 'a'). """
    # not sure how this should be implemented in the real case, 
    #  if you're not really just working on strings
    return isinstance(expr, str)

适用于所有示例：

>>> tmp.recursive_bubble_ands_up(('pred', ('and', 'a', 'b'), 'x'))
('and', ('pred', 'a', 'x'), ('pred', 'b', 'x'))
>>> tmp.recursive_bubble_ands_up(( ('and', 'a', 'b'), 'x'))
('and', ('a', 'x'), ('b', 'x'))
>>> tmp.recursive_bubble_ands_up(('not', ('p', ('and', 'a', 'b'), 'x') ))
('not', ('and', ('p', 'a', 'x'), ('p', 'b', 'x')))

请注意，这并不知道任何其他“特殊”操作符，例如not - 正如我在评论中所说的那样，我不确定它应该怎么做。但它应该给你一些东西。

编辑：哦，哎呀，我刚才意识到这只会执行一次“冒泡”操作，例如：

>>> tmp.recursive_bubble_ands_up(((('and', 'a', 'b'), 'x'), 'y' ))
(('and', ('a', 'x'), ('b', 'x')), 'y')
>>> tmp.recursive_bubble_ands_up((('and', ('a', 'x'), ('b', 'x')), 'y'))
('and', (('a', 'x'), 'y'), (('b', 'x'), 'y'))

所以你真正想要的可能是在while循环中应用它，直到输出与输入相同，如果你想让你的'和'从多个级别冒出来，如下所示：

def repeat_bubble_until_finished(expr):
    """ Repeat recursive_bubble_ands_up until there's no change 
    (i.e. until all possible bubbling has been done). 
    """
    while True:
        old_expr = expr
        expr = recursive_bubble_ands_up(old_expr)
        if expr == old_expr:
            break
    return expr

另一方面，这样做表明实际上我的程序打破了你的'不'的例子，因为它在'not'之前冒出了'和'，你说你想要独自留下：

>>> tmp.recursive_bubble_ands_up(('not', ('p', ('and', 'a', 'b'), 'x')))
('not', ('and', ('p', 'a', 'x'), ('p', 'b', 'x')))
>>> tmp.repeat_bubble_until_finished(('not', ('p', ('and', 'a', 'b'), 'x')))
('and', ('not', ('p', 'a', 'x')), ('not', ('p', 'b', 'x')))

所以我想你必须在recursive_bubble_ands_up中构建'not'的特殊情况，或者在运行我之前应用你的非处理函数，并在recursive_bubble_ands_up之前插入{ {1}}所以他们在交替中应用。

好吧，我现在应该睡觉了。

用整个元组替换嵌套元组中的值

1 个答案: