web-dev-qa-db-ja.com

単純な文法を解析するのに最適な方法は？

わかりましたので、このプロジェクトについてたくさんの小さな質問をしましたが、まだ自分が考えているデザインにあまり自信がないので、より広い規模で質問します。

コースカタログの前提条件の説明を解析しています。ほとんどの場合、説明は特定の形式に従っているため、ほとんどの部分を解析できると思います。

テキストから、もちろん前提条件関係のグラフを作成したいと思います。 （この部分は、データを解析した後で簡単になります。）

入力と出力の例：

_"CS 2110" => ("CS", 2110) # 0

"CS 2110 and INFO 3300" => [("CS", 2110), ("INFO", 3300)] # 1
"CS 2110, INFO 3300" => [("CS", 2110), ("INFO", 3300)] # 1
"CS 2110, 3300, 3140" => [("CS", 2110), ("CS", 3300), ("CS", 3140)] # 1

"CS 2110 or INFO 3300" => [[("CS", 2110)], [("INFO", 3300)]] # 2

"MATH 2210, 2230, 2310, or 2940" => [[("MATH", 2210), ("MATH", 2230), ("MATH", 2310)], [("MATH", 2940)]] # 3  
_

  1. 説明全体が単なるコースの場合は、直接出力されます。

  2. コースが結合されている場合（ "and"）、それらはすべて同じリストに出力されます

  3. コースが切り離されている（「または」）場合、それらは別々のリストにあります

  4. ここには、「and」と「or」の両方があります。

簡単にするための1つの注意点：「and」/「or」句のネストは、例3に示すものより大きくなることはないようです。

これを行う最良の方法は何ですか？ PLYから始めましたが、削減/削減の競合を解決する方法がわかりませんでした。 PLYの利点は、各解析ルールが生成するものを簡単に操作できることです。

_def p_course(p):
 'course : DEPT_CODE COURSE_NUMBER'
 p[0] = (p[1], int(p[2]))
_

PyParseでは、parseString()の出力を変更する方法はそれほど明確ではありません。 @Alex Martelliのオブジェクトの状態を保持し、そこからの出力を構築するという考えに基づいて構築することを検討していましたが、それがどのように最良に行われるのか正確にはわかりません。

_ def addCourse(self, str, location, tokens):
  self.result.append((tokens[0][0], tokens[0][1]))

 def makeCourseList(self, str, location, tokens):

  dept = tokens[0][0]
  new_tokens = [(dept, tokens[0][1])]
  new_tokens.extend((dept, tok) for tok in tokens[1:])

  self.result.append(new_tokens)
_

たとえば、「または」のケースを処理するには：

_    def __init__(self):
            self.result = []
            # ...
  self.statement = (course_data + Optional(OR_CONJ + course_data)).setParseAction(self.disjunctionCourses)



 def disjunctionCourses(self, str, location, tokens):
  if len(tokens) == 1:
   return tokens

  print "disjunction tokens: %s" % tokens
_

disjunctionCourses()は、どの小さなフレーズを分離するかをどのようにして知るのですか取得するのはトークンだけですが、これまでに解析されたものはresultに格納されているので、関数はresultのどのデータがtokenのどの要素に対応するかをどのようにして知ることができますか？トークンを検索して、同じデータを持つresultの要素を見つけることができると思いますが、それは複雑です...

また、次のようなその他のテキストを含む多くの説明があります。

_"CS 2110 or permission of instructor"
"INFO 3140 or equivalent experience"
"PYSCH 2210 and sophomore standing"
_

しかし、そのテキストを解析することは重要ではありません。

この問題に取り組むためのより良い方法は何ですか？

pythonparsingnlppyparsingply
27
Nick Heiner
def parse(astr):
    astr=astr.replace(',','')
    astr=astr.replace('and','')    
    tokens=astr.split()
    dept=None
    number=None
    result=[]
    option=[]
    for tok in tokens:
        if tok=='or':
            result.append(option)
            option=[]
            continue
        if tok.isalpha():
            dept=tok
            number=None
        else:
            number=int(tok)
        if dept and number:
            option.append((dept,number))
    else:
        if option:
            result.append(option)
    return result

if __name__=='__main__':
    tests=[ ("CS 2110" , [[("CS", 2110)]]),
            ("CS 2110 and INFO 3300" , [[("CS", 2110), ("INFO", 3300)]]),
            ("CS 2110, INFO 3300" , [[("CS", 2110), ("INFO", 3300)]]),
            ("CS 2110, 3300, 3140", [[("CS", 2110), ("CS", 3300), ("CS", 3140)]]),
            ("CS 2110 or INFO 3300", [[("CS", 2110)], [("INFO", 3300)]]),
            ("MATH 2210, 2230, 2310, or 2940", [[("MATH", 2210), ("MATH", 2230), ("MATH", 2310)], [("MATH", 2940)]])]

    for test,answer in tests:
        result=parse(test)
        if result==answer:
            print('GOOD: {0} => {1}'.format(test,answer))
        else:
            print('ERROR: {0} => {1} != {2}'.format(test,result,answer))
            break

収量

GOOD: CS 2110 => [[('CS', 2110)]]
GOOD: CS 2110 and INFO 3300 => [[('CS', 2110), ('INFO', 3300)]]
GOOD: CS 2110, INFO 3300 => [[('CS', 2110), ('INFO', 3300)]]
GOOD: CS 2110, 3300, 3140 => [[('CS', 2110), ('CS', 3300), ('CS', 3140)]]
GOOD: CS 2110 or INFO 3300 => [[('CS', 2110)], [('INFO', 3300)]]
GOOD: MATH 2210, 2230, 2310, or 2940 => [[('MATH', 2210), ('MATH', 2230), ('MATH', 2310)], [('MATH', 2940)]]
24
unutbu

単純な文法の場合、私は構文解析文法（PEG）が本当に好きです。これは、再帰降下パーサーを書くための規則正しく構造化された方法に相当します。 Pythonのような動的に型付けされた言語では、別個の「パーサージェネレーター」がなくても便利なことができます。つまり、reduce-reduce競合やLR構文解析の他のアルカナがあっても意味がありません。

少し検索を行ったところ、 pyPEG はPythonの素晴らしいライブラリのようです。

7
Norman Ramsey

この質問は約10年前のものであり、確かに今は答えられています。私は主にこの回答を投稿して、ついにPEGパーサーを理解したことを証明しました。ここでは、素晴らしい parsimonious module を使用しています。
とはいえ、構文解析の文法を思いついて、astを作成し、これにアクセスして目的の構造を取得することができます。

from parsimonious.nodes import NodeVisitor
from parsimonious.grammar import Grammar
from itertools import groupby

grammar = Grammar(
    r"""
    term            = course (operator course)*
    course          = coursename? ws coursenumber
    coursename      = ~"[A-Z]+"
    coursenumber    = ~"\d+"
    operator        = ws (and / or / comma) ws
    and             = "and"
    or              = (comma ws)? "or"
    comma           = ","
    ws              = ~"\s*"
    """
)

class CourseVisitor(NodeVisitor):
    def __init__(self):
        self.current = None
        self.courses = []
        self.listnum = 1

    def generic_visit(self, node, children):
        pass

    def visit_coursename(self, node, children):
        if node.text:
            self.current = node.text

    def visit_coursenumber(self, node, children):
        course = (self.current, int(node.text), self.listnum)
        self.courses.append(course)

    def visit_or(self, node, children):
        self.listnum += 1

courses = ["CS 2110", "CS 2110 and INFO 3300",
           "CS 2110, INFO 3300", "CS 2110, 3300, 3140",
           "CS 2110 or INFO 3300", "MATH 2210, 2230, 2310, or 2940"]

for course in courses:
    tree = grammar.parse(course)
    cv = CourseVisitor()
    cv.visit(tree)
    courses = [list(v) for _, v in groupby(cv.courses, lambda x: x[2])]
    print(courses)

ここでは、空白のようなレンガ、演算子or、andおよび,から始めて、下から上へと進みます。これらは、最終的にコースにつながり、最後にterm。訪問者クラスは、望ましい（まあ、一種、最後のタプル要素を取り除く必要がある）構造を構築します。

1
Jan

文法の解析についてはあまり知らないふりをしていませんが、あなたの場合は、unutbuによる解決策が必要です。しかし、私は最近の一連のブログ投稿で、エリックリッパートから解析についてかなり知識を得ました。

http://blogs.msdn.com/b/ericlippert/archive/2010/04/26/every-program-there-is-part-one.aspx

これは、文法の作成と解析を経て、文法を最適化して解析をより簡単に、より効率的に行う、7つのパートからなるシリーズです。彼は特定の文法のすべての組み合わせを生成するC＃コードを生成しますが、それをpythonに変換して独自のかなり簡単な文法を解析するのに、それほど長くはかかりません。

1
Josh Smeaton

削減/削減の競合が発生した場合は、「or」と「and」の優先順位を指定する必要があります。 「and」は最も緊密に結合すると思います。つまり、「CS 101とCS 102またはCS 201」は[[CS 101、CS 102] [CS 201]]を意味します。

両方の例を見つけることができる場合、文法はあいまいであり、運が悪いです。ただし、結果をどう処理するかに応じて、このあいまいさを未指定のままにすることができる場合があります。

PS、言語が規則的であるように見えますが、DFAを検討できます。

0
Johan Benum Evensberget