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'

仅分析形态

morphology()函数的工作方式与parse()非常相似。

>>> 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)))))