camxes 0.2

解析Lojban

函数parse()返回一个命名节点解析树。

>>> import camxes
>>> print camxes.parse("coi rodo")
text
 `- free
     +- CMAVO
     |   `- COI
     |       `- u'coi'
     `- sumti5
         +- CMAVO
         |   `- PA
         |       `- u'ro'
         `- CMAVO
             `- KOhA
                 `- u'do'

使用属性lojban将树转换回Lojban。

>>> camxes.parse("coi rodo!").lojban
u'coi ro do'

这会将叶子节点用空格连接起来，但您可以通过将spaces=True传递给parse()来保留空格和标点符号。

>>> camxes.parse("coi rodo!", spaces=True).lojban
u'coi rodo!'

可以通过名称作为属性访问子节点，得到一个这样的节点列表。如果没有带有该名称的子节点，则引发异常。

>>> print camxes.parse("coi rodo").free[0].sumti5[0].CMAVO[1]
CMAVO
 `- KOhA
     `- u'do'

您还可以不提供名称而按顺序位置访问节点。

>>> print camxes.parse("coi rodo")[0][1]
sumti5
 +- CMAVO
 |   `- PA
 |       `- u'ro'
 `- CMAVO
     `- KOhA
         `- u'do'

节点遍历其子节点。

>>> list(camxes.parse("coi rodo")[0][1])
[<CMAVO {ro}>, <CMAVO {do}>]

它们还知道自己的名称。

>>> camxes.parse("coi rodo")[0][1].name
u'sumti5'

验证语法有效性

parse() 能够通过处理尽可能多的语法正确的输入来解析一些不规则的输入。因此，它不适合检查某些文本的语法是否正确。为此，有一个 isgrammatical() 断言。

>>> camxes.isgrammatical("coi rodo")
True
>>> camxes.isgrammatical("mupli cu fliba")
False
>>> print camxes.parse("mupli cu fliba")
text
 `- BRIVLA
     `- gismu
         `- u'mupli'

将复合词分解为词缀

decompose() 可以给出复合词的词缀和连字符。

>>> camxes.decompose("genturfa'i")
(u'gen', u'tur', u"fa'i")

它会对不是单个、有效复合词的输入进行投诉。

>>> camxes.decompose("camxes")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid compound 'camxes'

仅解析形态

与 parse() 类似，morphology() 函数。

>>> print camxes.morphology("coi")
text
 `- CMAVO
     `- COI
         +- c
         |   `- u'c'
         +- o
         |   `- u'o'
         `- i
             `- u'i'

树遍历

使用 find() 方法搜索具有任意数量参数的节点，这些参数将与节点名称进行通配符匹配。此操作将递归地遍历每个分支，直到找到匹配项，但不会搜索匹配节点的子节点。

>>> camxes.parse("coi rodo").find('sumti*')
(<sumti5 {ro do}>,)

>>> camxes.parse("coi rodo").find('PA', 'KOhA')
(<PA {ro}>, <KOhA {do}>)

在节点上的键访问是查找第一次匹配的快捷方式。

>>> camxes.parse("la camxes genturfa'i fi la lojban")['cmene']
<cmene {camxes}>

leafs 属性是所有叶节点的元组，应该是Unicode词素。

>>> camxes.parse("coi rodo").leafs
(u'coi', u'ro', u'do')

branches() 方法找到叶节点与参数匹配的节点的父节点。这允许您搜索一个序列的词素所属的分支。

>>> camxes.parse("lo ninmu cu klama lo tcadu").branches("lo")
(<sumti6 {lo ninmu}>, <sumti6 {lo tcadu}>)
>>> camxes.parse("lo ninmu cu klama lo tcadu").branches("ninmu")
(<sumti6 {lo ninmu}>,)
>>> camxes.parse("lo ninmu cu klama lo tcadu").branches("klama", "lo", "tcadu")
(<sentence {lo ninmu cu klama lo tcadu}>,)

这些操作的泛化称为 filter()，它接受一个断言函数，该函数决定一个节点是否应被列出。由于 filter() 是一个生成器，所以我们在这里使用 list() 来查看结果。

>>> leafparent = lambda node: not isinstance(node[0], camxes.Node)
>>> list(camxes.parse("coi rodo").filter(leafparent))
[<COI {coi}>, <PA {ro}>, <KOhA {do}>]

树转换

您可以将节点递归地转换为一个字符串元组，其中第一个项目是节点的名称，其余的是子节点。这个属性被称为 primitive，如果您正在将解析树序列化到一个更“笨拙”的格式（如JSON）时，这可能很有用。

>>> from pprint import pprint
>>> pprint(camxes.parse("coi rodo").primitive)
(u'text',
 (u'free',
  (u'CMAVO', (u'COI', u'coi')),
  (u'sumti5', (u'CMAVO', (u'PA', u'ro')), (u'CMAVO', (u'KOhA', u'do')))))

>>> import json
>>> print json.dumps(camxes.parse("coi").primitive, indent=2)
[
  "text",
  [
    "CMAVO",
    [
      "COI",
      "coi"
    ]
  ]
]

primitive 的泛化称为 map()，它接受一个转换函数，该函数接受一个节点。然后递归地将转换映射到所有节点，并返回一个类似 primitive 的嵌套元组。

>>> camxes.parse("coi rodo").map(len)
(1, (2, (1, (1, 3)), (2, (1, (1, 2)), (1, (1, 2)))))