1

私はこの機能を持っています:

def req_splitter(req_string):
    req = {}
    if " AND " in req_string:
        cond = "AND"
        req_splitted = req_string.split(" AND ")
    elif " OR " in req_string:
        cond = "OR"
        req_splitted = req_string.split(" OR ")
    else:
        cond = "AND"
        req_splitted = [req_string]

    if len(req_splitted) > 1:
        for sub_req in req_splitted:
            sub_req_splitted = req_splitter(sub_req)
            req[cond] = list()#new_req
            req[cond].append(sub_req_splitted)
    else:
        req[cond] = req_splitted
    return req

次のような文字列を json-logic 条件に変換することを目的としています。

Barracks AND Tech Lab
Lair OR Hive
Hatchery OR Lair OR Hive
Cybernetics Core AND Gateway OR Warpgate
Forge AND Twilight Council AND Ground Armor 1
Spire OR Greater Spire AND Hive AND Flyer Flyer Carapace 2
Spire OR Greater Spire AND Lair OR Hive AND Flyer Attacks 1

json_logic 条件は次のようになります。

{
    "and": [
            {
            "or": [
                "Gateway",
                "Warpgate"
            ]
        },
        "Cybernetics Core"
    ]
}

上記の例のように、文字列を条件オブジェクトに分割するために、再帰関数はどのように機能する必要がありますか?

問題を理解するには、次のようにします。

json_logicは、上記の辞書のように条件をチェックし、比較内容に応じて結果を返すモジュールです。

条件の仕組み: Key-Value par は 1 つの論理ステートメントです。キーは論理条件を表します。リスト内の値はオペランドを表します。値自体がリストではなく辞書の場合、再帰します。

「ポーランド語表記」と比較できます

最後に、AND ステートメントは OR ステートメントよりも優先度が高く、OR ステートメントは常に一緒に使用されます。

4

1 に答える 1

6

単純なトップダウン パーサーを作成する必要があります。真似のできない effbot は、そのようなことについて素晴らしいチュートリアルを書きました。

r'\s+(OR|AND)\s+'トークン化は、正規表現を分割し、ORandANDを演算子として認識し、残りをリテラルとして認識します。およびトークンメソッドは、同じ型の直接ネストされた演算子を平坦化する可能性がANDあります。OR.led()

そこに記述されている内容を、(グローバルではなく) もう少し OOP を使用して実装し、Python 2 および 3 と互換性を持たせました。

import re
from functools import partial


class OpAndToken(object):
    lbp = 10
    op = 'and'
    def led(self, parser, left):
        right = parser.expression(self.lbp)
        operands = []
        for operand in left, right:
            # flatten out nested operands of the same type
            if isinstance(operand, dict) and self.op in operand:
                operands.extend(operand[self.op])
            else:
                operands.append(operand)
        return {self.op: operands}


class OpOrToken(OpAndToken):
    lbp = 20
    op = 'or'


class LiteralToken(object):
    def __init__(self, value):
        self.value = value
    def nud(self):
        return self.value


class EndToken(object):
    lbp = 0


class Parser(object):
    operators = {'AND': OpAndToken, 'OR': OpOrToken}
    token_pat = re.compile("\s+(AND|OR)\s+")

    def __init__(self, program):
        self.program = program
        self.tokens = self.tokenizer()
        self.token = next(self.tokens)

    def expression(self, rbp=0):
        t = self.token
        self.token = next(self.tokens)
        left = t.nud()
        while rbp < self.token.lbp:
            t = self.token
            self.token = next(self.tokens)
            left = t.led(self, left)
        return left

    def tokenizer(self):
        for tok in self.token_pat.split(self.program):
            if tok in self.operators:
                yield self.operators[tok]()
            else:
                yield LiteralToken(tok)
        yield EndToken()

    def parse(self):
        return self.expression()

これにより、フォーマットが期待される出力に解析されます。

>>> Parser('foo AND bar OR spam AND eggs').parse()
{'and': ['foo', {'or': ['bar', 'spam']}, 'eggs']}

入力行のデモ:

>>> from pprint import pprint
>>> tests = '''\
... Barracks AND Tech Lab
... Lair OR Hive
... Hatchery OR Lair OR Hive
... Cybernetics Core AND Gateway OR Warpgate
... Forge AND Twilight Council AND Ground Armor 1
... Spire OR Greater Spire AND Hive AND Flyer Flyer Carapace 2
... Spire OR Greater Spire AND Lair OR Hive AND Flyer Attacks 1
... '''.splitlines()
>>> for test in tests:
...     pprint(Parser(test).parse())
...
{'and': ['Barracks', 'Tech Lab']}
{'or': ['Lair', 'Hive']}
{'or': ['Hatchery', 'Lair', 'Hive']}
{'and': ['Cybernetics Core', {'or': ['Gateway', 'Warpgate']}]}
{'and': ['Forge', 'Twilight Council', 'Ground Armor 1']}
{'and': [{'or': ['Spire', 'Greater Spire']}, 'Hive', 'Flyer Flyer Carapace 2']}
{'and': [{'or': ['Spire', 'Greater Spire']},
         {'or': ['Lair', 'Hive']},
         'Flyer Attacks 1']}

OR行内の複数のorAND演算子の場合、オペランドが結合されることに注意してください。

括弧のサポートを(...)読者に追加することは残しておきます。チュートリアルでは、これを行う方法を示しています (advance()関数をParserクラスのメソッドにして、.nud()呼び出しにもパーサーを渡すか、トークン クラス インスタンスを作成するときにパーサーを渡すだけです)。

于 2016-08-25T19:49:53.330 に答える