需求
 

需要从文本文件中提取中时间及日期
 
代码
 
“`java 
 /** 
 * 从文本内容中提取日期时间 
 * @param text 包含日期时间的文本（格式：yyyy年MM月dd日HH:mm） 
 * @return 日期时间字符串（yyyy-MM-dd HH:mm） 
 */ 
 public static String getDateTimeFromText(String text){ 
 if (null == text){ 
 return “”; 
 }
 
    Pattern p = Pattern.compile("(\\d{4})年(\\d{2})月(\\d{2})日(\\d{2}:\\d{2})");
    Matcher m = p.matcher(text);

    if (m.find() && 4 == m.groupCount()){
        return m.group(1) + "-" + m.group(2) + "-" + m.group(3) + " " + m.group(4); 
    } else {
        return "";
    }
}
 
“`java

  在我们的日常生活和工作中，从文本中提取时间是一项非常基础却重要的工作，因此，本文将介绍如何从文本中有效地提取时间。
   举个简单的例子，我们需要从下面的文本中提取时间：
 
 
 
6月28日，杭州市统计局权威公布《2019年5月月报》，杭州市医保参保人数达到1006万，相比于2月份的989万，三个月暴涨16万人参保，傲视新一线城市。
 
 
我们可以从文本有提取6月28日，2019年5月， 2月份这三个有效时间。
   通常情况下，较好的解决思路是利用深度学习模型来识别文本中的时间，通过一定数量的标记文本和合适的模型。本文尝试利用现有的NLP工具来解决如何从文本中提取时间。
   本文使用的工具为哈工大的pyltp，可以在Python的第三方模块中找到，实现下载好分词模型cws.model和词性标注pos.model这两个模型文件。
   话不多说，我们直接上Python代码，如下：
 
# -*- coding: utf-8 -*-

import os
from pyltp import Segmentor
from pyltp import Postagger

class LTP(object):
    def __init__(self):
        cws_model_path = os.path.join(os.path.dirname(__file__), 'cws.model')  # 分词模型路径，模型名称为`cws.model`
        pos_model_path = os.path.join(os.path.dirname(__file__), 'pos.model')  # 词性标注模型路径，模型名称为`pos.model`
        self.segmentor = Segmentor()  # 初始化实例
        self.segmentor.load(cws_model_path) # 加载模型
        self.postagger = Postagger()  # 初始化实例
        self.postagger.load(pos_model_path)  # 加载模型

    # 分词
    def segment(self, text):
        words = list(self.segmentor.segment(text))
        return words

    # 词性标注
    def postag(self, words):
        postags = list(self.postagger.postag(words))
        return postags

    # 获取文本中的时间
    def get_time(self, text):

        # 开始分词及词性标注
        words = self.segment(text)
        postags = self.postag(words)

        time_lst = []

        i = 0
        for tag, word in zip(postags, words):
            if tag == 'nt':
                j = i
                while postags[j] == 'nt' or words[j] in ['至', '到']:
                    j += 1
                time_lst.append(''.join(words[i:j]))
            i += 1

        # 去重子字符串的情形
        remove_lst = []
        for i in time_lst:
            for j in time_lst:
                if i != j and i in j:
                    remove_lst.append(i)

        text_time_lst = []
        for item in time_lst:
            if item not in remove_lst:
                text_time_lst.append(item)

        # print(text_time_lst)
        return text_time_lst

    # 释放模型
    def free_ltp(self):
        self.segmentor.release()
        self.postagger.release()

if __name__ == '__main__':
    ltp = LTP()

    # 输入文本
    sent = '6月28日，杭州市统计局权威公布《2019年5月月报》，杭州市医保参保人数达到1006万，相比于2月份的989万，三个月暴涨16万人参保，傲视新一线城市。'
    time_lst = ltp.get_time(sent)
    ltp.free_ltp()

    # 输出文本中提取的时间
    print('提取时间： %s' % str(time_lst))
 
  接着，我们测试几个例子。
 
输入文本为：
 
 
 
今天，央行举行了2019年6月份金融统计数据解读吹风会，发布了2019年6月份金融统计数据并就当前的一些热点问题进行了解读和回应。
 
 
文本中提取的时间为：
 
提取时间： ['今天', '2019年6月份', '2019年6月份', '当前']
 
输入文本为：
 
 
 
2006年，上海的国内生产总值达到10296.97亿元，是中国内地第一个GDP突破万亿元的城市。2008年，北京GDP破万亿。两年后，广州GDP超过万亿。2011年，深圳、天津、苏州、重庆4城的GDP也进入了万亿行列。武汉、成都在2014年跻身“万亿俱乐部”，杭州、南京和青岛、无锡和长沙的GDP依次在2015年、2016年和2017年过万亿。宁波和郑州则成为2018年万亿俱乐部的新成员。
 
 
文本中提取的时间为：
 
提取时间： ['2006年', '2008年', '2011年', '2014年', '2015年', '2016年', '2018年']
 
输入文本为：
 
 
 
此后，6月28日、7月9日和7月11日下午，武威市政协、市人大、市政府分别召开坚决全面彻底肃清火荣贵流毒和影响专题民主生活会。
 
 
文本中提取的时间为：
 
提取时间： ['此后', '6月28日', '7月9日', '7月11日下午']
 
输入文本为：
 
 
 
姜保红出生于1974年4月，她于2016年11月至2018年9月任武威市副市长，履新时，武威市的一把手正是火荣贵。
 
 
文本中提取的时间为：
 
提取时间： ['1974年4月', '2016年11月至2018年9月']
 
  本次分享到此结束，欢迎大家批评指正。
 
 
 
注意：不妨了解下笔者的微信公众号： Python爬虫与算法（微信号为：easy_web_scrape）， 欢迎大家关注~
 

1. 如果你想按某个分割符号去把长长的一整列数据拆分成多列；
 
2. 如果你想导出拆分后数据，你希望勾选那一列就导出那一列数据，勾选多列就导出多列数据；
 
3. 如果你想让某列按日期范围导出数据，就能按某列的日期范围导出数据；
 
4. 如果你想按某列的数值大小范围导出数据，就能按某列的数值范围导出数据；
 
5. 如果你想按某列文本前缀包含什么内容，就能按设定的前缀条件导出数据；
 
6. 如果你想按某列文本后缀包含什么内容，就能按设定的后缀条件导出数据；
 
7. 如果你想按某列文本前缀包含什么内容，后缀同时必须包含什么内容 ，就能按设定的前缀和后缀条件导出数据；
 
8. 如果你想按某列文本前缀包含什么内容，中间偏后的部分包含什么内容 ，就能按设定的前缀和中间偏后的设定的条件导出数据；
 
9.如果你想按某列文本后缀包含什么内容，中间偏前的部分包含什么内容 ，就能按设定的后缀和中间偏前的设定的条件导出数据；
 
10. 如果你想按某列货币值的范围导出数据，就能按设定的货币范围导出数据；
 
11. 如果你想按某列等于或者不等于什么内容导出数据，就能按照你希望结果导出数据；
 
总结：我们可以每次导出一类数据，分多次导出，想想看，是不是就能实现从大数据里分类导出我想要的分类数据，
 
以上描述的功能这款 “大数据 - 文本文件数据提取工具” 都能帮你轻松完成！如果你想现在立刻就拥有它，赶快来联系我吧，
 
早一天拥有！你就早一天受益！请你先认真阅读一遍我的博客，看看是不是你一直在等待的大数据软件！
 
范例1 根据设置列数据的时间范围提取（导出）数据
 
支持的日期格式（包括时间格式）如下：
 
            "HH:mm",
            "HH:mm:ss",
            "yyyy/MM",
            "yyyy/MM/dd",
            "yyyy/MM/dd HH:mm",
            "yyyy/MM/dd HH:mm:ss",
            "yyyy-MM",
            "yyyy-MM-dd",
            "yyyy-MM-dd HH:mm",
            "yyyy-MM-dd HH:mm:ss",
            "yyyy.MM",
            "yyyy.MM.dd",
            "yyyy.MM.dd HH:mm",
            "yyyy.MM.dd HH:mm:ss",
            "yyyyMM",
            "yyyyMMdd",
            "yyyyMMddHHmm",
            "yyyyMMddHHmmss",
            "yyyy年MM月",
            "yyyy年MM月dd日",
            "yyyy年MM月dd日 HH时mm分",
            "yyyy年MM月dd日 HH时mm分ss秒"
 
 
 
 
范例2   根据货币值范围导出文本数据（支持全世界各国货币汇率换算）
 
 
 
范例3   根据百分比大小范围导出文本数据 
 
 
 
范例4   根据字符串前缀和后缀导出文本数据  
 
 
 

回答下列问题：
 
　　（１）如何能构建一个系统，以至从非结构化文本中提取结构化数据？
 
　　（２）有哪些稳健的方法识别一个文本描述的实体和关系？
 
　　（３）哪些语料库适合这项工作，如何使用它们来训练和评估模型？
 
一　信息提取
 
信息有很多种”形状“和”大小“，一个重要的形式是结构化数据：实体和关系的规范和可预测的组织。例如：我们可能对公司和地点之间的关系，可用关系数据库存储。
 
但如果我们尝试从文本中获得相似的信息，事情就比较麻烦了。如何从一段文字中发现一个实体和关系的表呢？
 
然后，利用强大的查询工具，如ＳＱＬ，这种从文本获取意义的方法被称为“信息提取”
 
信息提取有许多应用，包括商业智能、简历收获、媒体分析、情感检测、专利检索及电子邮件扫描。当前研究的一个特别重要的领域是提取出电子科学文献的结构化数据，特别是在生物学和医学领域。
 
＃信息提取结构
 

 
 
要执行前面３个任务，句子分割器、分词器和词性标注器
 

import nltk, re, pprint
def ie_preprocess(document):
    sentences = nltk.sent_tokenize(document)                      #句子分割
    sentences = [nltk.word_tokenize(sent) for sent in sentences]  #分词
    sentences = [nltk.pos_tag(sent) for sent in sentence]         #词性标注器
 
二　分块
 
 
用于实体识别的基本技术是分块(chunking)
 

 
 
小框显示词级标识符和词性标注，同时，大框显示较高级的程序分块
 
在本节上，我们将在较深的层面上探讨程序分块，以组块的定义和表示开始，我们将看到正则表达式和n-gram方法分块，使用CoNLL-2000分块语料库开发和评估分块器。
 
＃名词短语分块
 
NP-chunking（名词短语分块），寻找单独名词短语对应的块
 
NP－分块信息最有用的来源之一是词性标记。这是在信息提取系统中进行词性标注的动机之一。
 
为了创建NP－分块，首先定义分块语法，规定句子应如何分块。在本例中，使用一个正则表达式规则定义一个简单的语法。
 
这条规则是NP-分块有可选的且后面跟着任意数目形容词的限定词和名词组成。使用此语法，我们创建了组块分析器，测试我门的例句。结果得到树状图，可以输出或显示图形。
 

sentence = [("the","DT"),("little","JJ"),("yellow","JJ"),("dog","NN"),("barked","VBD"),("at","IN"),("the","DT"),("cat","NN")]
grammar = "NP: {<DT>?<JJ>*<NN>}"
cp = nltk.RegexpParser(grammar)
result = cp.parse(sentence)
print result
(S
  (NP the/DT little/JJ yellow/JJ dog/NN)
  barked/VBD
  at/IN
  (NP the/DT cat/NN))
result.draw()


 
 
＃标记模式
 
 
使用图形界面nltk.app.chunkparser()
 
 
＃用正则表达式分块
 

grammer = r"""
   NP: {<DT|PP\$>?<JJ>*<NN>}    #匹配一个可选的限定词或所有格代名词
       {<NNP>+}                 #匹配一个或多个专有名词
"""
cp = nltk.RegexpParser(grammer)
sentence = [("Rapunzel","NNP"),("let","VBD"),("down", "RP"),("her","PP$"),("long","JJ"),("golden","JJ"),("hair","NN")]
print cp.parse(sentence)
(S
  (NP Rapunzel/NNP)
  let/VBD
  down/RP
  (NP her/PP$ long/JJ golden/JJ hair/NN))
nouns = [("money","NN"),("market","NN"),("fund","NN")]
grammar = "NP: {<NN><NN>}"  #如果将匹配两个连续名词的文本的规则应用到包含３个连续名词的文本中，则只有前两个名词被分块
cp = nltk.RegexpParser(grammar)
print cp.parse(nouns)
(S (NP money/NN market/NN) fund/NN)
 
＃探索文本语料库
 
 
使用分块器可以在已标注的语料库中提取匹配特定词性标记序列的短语
 

cp = nltk.RegexpParser('CHUNK: {<V.*> <TO> <V.*>}')
brown = nltk.corpus.brown
for sent in brown.tagged_sents():
    tree = cp.parse(sent)
    for subtree in tree.subtrees():
        if subtree.label() == 'CHUNK': 
            print subtree
(CHUNK combined/VBN to/TO achieve/VB)
(CHUNK continue/VB to/TO place/VB)
(CHUNK serve/VB to/TO protect/VB)
(CHUNK wanted/VBD to/TO wait/VB)
(CHUNK allowed/VBN to/TO place/VB)
......
 
＃缝隙
 
 
为不包括在大块中的标识符序列定义一个缝隙
 
加缝隙是从大块中去除标识符序列的过程
 

grammar = r"""
NP:
   {<.*>+}
   }<VBD|IN>+{"""
sentence = [("the","DT"),("little","JJ"),("yellow","JJ"),("dog","NN"),("barked","VBD"),("at","IN"),("the","DT"),("cat","NN")]
cp = nltk.RegexpParser(grammar)
print cp.parse(sentence)
(S
  (NP the/DT little/JJ yellow/JJ dog/NN)
  barked/VBD
  at/IN
  (NP the/DT cat/NN))
 
＃分块的表示：标记与树状图
 
 
作为标注和分析之间的中间状态，块结构可以使用标记或树状图来表示。使用最广泛的表示是IOB标记
 
在这个方案中，每个标识符被用３个特殊的块标签之一标注，Ｉ（inside，内部），Ｏ（outside，外部）或Ｂ（begin，开始）。
 
Ｂ标志着它是分块的开始。块内的标识符子序列被标志为Ｉ，其他为Ｏ
 
Ｂ和Ｉ标记是块类型的后缀，如B-NP, I-NP。
 
NLTK用树状图作为分块的内部表示，却提供这些树状图与IOB之间格式转换的方法
 
３　开发和评估分块器
 
如何评估分块器
 
＃读取IOB格式与CoNLL2000分块语料库
 
CoNLL2000分块语料库包含27万词的《华尔街日报文本》，分为“训练”和“测试”两部分，标注有词性标记和IOB格式分块标记。
 

from nltk.corpus import conll2000
print conll2000.chunked_sents('train.txt')[99]
(S
  (PP Over/IN)
  (NP a/DT cup/NN)
  (PP of/IN)
  (NP coffee/NN)
  ,/,
  (NP Mr./NNP Stone/NNP)
  (VP told/VBD)
  (NP his/PRP$ story/NN)
  ./.)
包含
３中分块类型：NP分块，VP分块，PP分块

 
print conll2000.chunked_sents('train.txt', chunk_types=['NP'])[99]  #只选择NP分块
 
＃简单评估和基准
 
 

cp = nltk.RegexpParser("")     #不分块
test_sents = conll2000.chunked_sents('test.txt',chunk_types=['NP'])
print cp.evaluate(test_sents)  #评估结果
ChunkParse score:
    IOB Accuracy:  43.4%%
    Precision:      0.0%%
    Recall:         0.0%%
    F-Measure:      0.0%%
grammar = r"NP: {<[CDJNP].*>+}"
cp = nltk.RegexpParser(grammar)     #初级的正则表达式分块器
test_sents = conll2000.chunked_sents('test.txt')
print cp.evaluate(test_sents)  #评估结果
ChunkParse score:
    IOB Accuracy:  62.5%%
    Precision:     70.6%%
    Recall:        38.5%%
    F-Measure:     49.8%%
使用unigram标注器对名词短语分块
 

#使用训练语料找到对每个词性标记最有可能的块标记（Ｉ、Ｏ或Ｂ）
#可以用unigram标注器建立一个分块器，但不是要确定每个词的正确词性标记，而是给定每个词的词性标记，尝试确定正确的块标记
class UnigramChunker(nltk.ChunkParserI):
    def __init__(self, train_sents):
        train_data = [[(t,c) for w,t,c in nltk.chunk.tree2conlltags(sent)] for sent in train_sents]
        self.tagger = nltk.UnigramTagger(train_data)

    def parse(self, sentence):
        pos_tags = [pos for (word,pos) in sentence]
        tagged_pos_tags = self.tagger.tag(pos_tags)
        chunktags = [chunktag for (pos, chunktag) in tagged_pos_tags]
        #为词性标注IOB块标记
        conlltags = [(word, pos, chunktag) for ((word,pos),chunktag) in zip(sentence, chunktags)]
        return nltk.chunk.conlltags2tree(conlltags) #转换成分块树状图
#使用CoNLL2000分块语料库训练
test_sents = conll2000.chunked_sents('test.txt', chunk_types=['NP'])
train_sents = conll2000.chunked_sents('train.txt', chunk_types=['NP'])
unigram_chunker = UnigramChunker(train_sents)
print unigram_chunker.evaluate(test_sents)
ChunkParse score:
    IOB Accuracy:  92.9%%
    Precision:     79.9%%
    Recall:        86.8%%
    F-Measure:     83.2%%


postags = sorted(set(pos for sent in train_sents for (word,pos) in sent.leaves()))
print unigram_chunker.tagger.tag(postags)
[(u'#', u'B-NP'), (u'$', u'B-NP'), (u"''", u'O'), (u'(', u'O'), (u')', u'O'), (u',', u'O'), (u'.', u'O'), (u':', u'O'), (u'CC', u'O'), (u'CD', u'I-NP'), (u'DT', u'B-NP'), (u'EX', u'B-NP'), (u'FW', u'I-NP'), (u'IN', u'O'), (u'JJ', u'I-NP'), (u'JJR', u'B-NP'), (u'JJS', u'I-NP'), (u'MD', u'O'), (u'NN', u'I-NP'), (u'NNP', u'I-NP'), (u'NNPS', u'I-NP'), (u'NNS', u'I-NP'), (u'PDT', u'B-NP'), (u'POS', u'B-NP'), (u'PRP', u'B-NP'), (u'PRP$', u'B-NP'), (u'RB', u'O'), (u'RBR', u'O'), (u'RBS', u'B-NP'), (u'RP', u'O'), (u'SYM', u'O'), (u'TO', u'O'), (u'UH', u'O'), (u'VB', u'O'), (u'VBD', u'O'), (u'VBG', u'O'), (u'VBN', u'O'), (u'VBP', u'O'), (u'VBZ', u'O'), (u'WDT', u'B-NP'), (u'WP', u'B-NP'), (u'WP$', u'B-NP'), (u'WRB', u'O'), (u'``', u'O')]
#使用训练语料找到对每个词性标记最有可能的块标记（Ｉ、Ｏ或Ｂ）
#可以用bigram标注器建立一个分块器，但不是要确定每个词的正确词性标记，而是给定每个词的词性标记，尝试确定正确的块标记
class BigramChunker(nltk.ChunkParserI):
    def __init__(self, train_sents):
        train_data = [[(t,c) for w,t,c in nltk.chunk.tree2conlltags(sent)] for sent in train_sents]
        self.tagger = nltk.BigramTagger(train_data)

    def parse(self, sentence):
        pos_tags = [pos for (word,pos) in sentence]
        tagged_pos_tags = self.tagger.tag(pos_tags)
        chunktags = [chunktag for (pos, chunktag) in tagged_pos_tags]
        #为词性标注IOB块标记
        conlltags = [(word, pos, chunktag) for ((word,pos),chunktag) in zip(sentence, chunktags)]
        return nltk.chunk.conlltags2tree(conlltags) #转换成分块树状图
bigram_chunker = BigramChunker(train_sents)
print bigram_chunker.evaluate(test_sents)
ChunkParse score:
    IOB Accuracy:  93.3%%
    Precision:     82.3%%
    Recall:        86.8%%
    F-Measure:     84.5%%
＃训练基于分类器的分块器

有时词性标记不足以确定一个句子应如何分块
安装ocaml   
安装maxnet     最大熵
class ConsecutiveNPChunkTagger(nltk.TaggerI):
    def __init__(self, train_sents):
        train_set = []
        for tagged_sent in train_sents:
            untagged_sent = nltk.tag.untag(tagged_sent)
            history = []
            for i, (word,tag) in enumerate(tagged_sent):
                featureset = npchunk_features(untagged_sent, i, history)
                train_set.append( (featureset, tag) )
                history.append(tag)
        self.classifier = nltk.MaxentClassifier.train(train_set, algorithm='megam', trace=0)　#最大熵
    def tag(self, sentence):
        history = []
        for i, word in enumerate(sentence):
            featureset = npchunk_features(sentence, i, history)
            tag = self.classifier.classify(featureset)
            history.append(tag)
        return zip(sentence, history)
    
class ConsecutiveNPChunker(nltk.ChunkParserI):
    def __init__(self, train_sents):
        tagged_sents = [[((w,t),c) for (w,t,c) in nltk.chunk.tree2conlltags(sent)] for sent in train_sents]
        self.tagger = ConsecutiveNPChunkTagger(tagged_sents)
    def parse(self, sentence):
        tagged_sents = self.tagger.tag(sentence)
        conlltags = [(w,t,c) for ((w,t),c) in tagged_sents]
        return nltk.chunk.conlltags2tree(conlltags)
def npchunk_features(sentence, i, history):
    word, pos = sentence[i]    
    return {"pos": pos} #只提供当前标识符的词性标记

chunker = ConsecutiveNPChunker(train_sents)
print chunker.evaluate(test_sents)
ChunkParse score:
    IOB Accuracy:  92.9%%
    Precision:     79.9%%
    Recall:        86.7%%
    F-Measure:     83.2%%
def npchunk_features(sentence, i, history):
    word, pos = sentence[i]
    if i == 0: 
        prevword, prevpos = "<START>", "<START>"
    else:
        prevword, prevpos = sentence[i-1]  
   return {"pos": pos, "prevpos": prevpos} #模拟相邻标记之间的相互作用

chunker = ConsecutiveNPChunker(train_sents)
print chunker.evaluate(test_sents)
ChunkParse score:
    IOB Accuracy:  93.7%%
    Precision:     82.1%%
    Recall:        87.2%%
    F-Measure:     84.5%%
def npchunk_features(sentence, i, history):
    word, pos = sentence[i]
    if i == 0:
        prevword, prevpos = "<START>", "<START>"
    else:
        prevword, prevpos = sentence[i-1]
    return {"pos": pos, "word": word, "prevpos": prevpos}   #增加词的内容
chunker = ConsecutiveNPChunker(train_sents)
print chunker.evaluate(test_sents)
ChunkParse score:
    IOB Accuracy:  94.2%%
    Precision:     83.2%%
    Recall:        88.3%%
    F-Measure:     85.7%%



def npchunk_features(sentence, i, history):
    word, pos = sentence[i]
    if i == 0:
        prevword, prevpos = "<START>", "<START>"
    else:
        prevword, prevpos = sentence[i-1]
    if i == len(sentence)-1:
        nextword, nextpos = "<END>", "<END>"
    else:
        nextword, nextpos = sentence[i+1]
    return {"pos": pos,
            "word": word,
            "prevpos": prevpos,
            "nextpos": nextpos,
            "prevpos+pos": "%s+%s" % (prevpos, pos),
            "pos+nextpos": "%s+%s" % (pos, nextpos),
            "tags-since-dt": tags_since_dt(sentence, i)}  #预取特征、配对功能和复杂的语境特征
def tags_since_dt(sentence, i):
    tags = set()
    for word, pos in sentence[:i]:
        if pos == "DT":
            tags = set()
        else:
            tags.add(pos)
    return '+'.join(sorted(tags))
chunker = ConsecutiveNPChunker(train_sents)
print chunker.evaluate(test_sents)
ChunkParse score:
    IOB Accuracy:  96.0%%
    Precision:     88.8%%
    Recall:        91.1%%
    F-Measure:     89.9%%

四　语言结构中的递归
＃用级联分块器构建嵌套结构
只需创建一个包含递归规则的多级的分块语法，就可以建立任意深度的分块结构
例子展示名词短语、介词短语、动词短语和句子的模式
grammar = r"""
   NP: {<DT|JJ|NN.*>+}
   PP: {<IN><NP>}
   VP: {<VB.*><NP|PP|CLAUSE>+$}
   CLAUSE: {<NP><VP>}
"""
cp = nltk.RegexpParser(grammar)
sentence = [("Mary","NN"), ("saw","VBD"),("the","DT"),("cat","NN"),("sit","VB"),("on","IN"),("the","DT"),("mat","NN")]
print cp.parse(sentence)
(S
  (NP Mary/NN)
  saw/VBD   #无法识别VP
  (CLAUSE
    (NP the/DT cat/NN)
    (VP sit/VB (PP on/IN (NP the/DT mat/NN)))))
cp = nltk.RegexpParser(grammar, loop=2)  #添加循环
print cp.parse(sentence)
(S
  (CLAUSE
    (NP Mary/NN)
    (VP
      saw/VBD
      (CLAUSE
        (NP the/DT cat/NN)
        (VP sit/VB (PP on/IN (NP the/DT mat/NN)))))))

＃树状图

在NLTK中，创建树状图，方法是给节点添加标签和一个子链表
＃树遍历
使用递归函数来遍历树是标准的做法
五　命名实体识别



命名实体识别（NER）系统的目标是识别所有文字提及的命名实体。这可以分解成两个子任务：确定NE的边界和确定其类型。命名实体识别经常是信息提取中关系识别的前奏，也有助于其他任务。例如：在问答系统（QA）中，我们试图提高信息检索的精确度，不用返回整个页面而只是包含用户问题的答案的那部分。大多数QA系统利用标准信息检索返回的文件，然后尝试分离文档中包含答案的最小的文本分段。P303，例如问题：Who
 was the first President of the US？被检索的文档中包含答案，但我们想得到的答案应该是X was the first President of the US的形式，其中X不仅是一个名词短语也是一个PER类型的命名实体。

如何识别命名实体呢？一种方法是查找适当的名称列表，但问题是许多实体措辞有歧义，如May和North可能是日期和地点
因此我们需要能够识别多标识符序列的开头和结尾
NER是一个非常适合用于分类器类型的方法。
NLTK提供了一个已经训练好的可以识别命名实体的分类器，使用函数nltk.ne_chunk()访问。

sent = nltk.corpus.treebank.tagged_sents()[22]
print nltk.ne_chunk(sent, binary=True)    #如果设置参数binary=True，那么命名实体只被标注为NE
(S
  The/DT
  (NE U.S./NNP)
  is/VBZ
  one/CD
  of/IN
print nltk.ne_chunk(sent)    #PERSON, ORGANIZATION and GPE
(S
  The/DT
  (GPE U.S./NNP)
  is/VBZ
  ......
  (PERSON Brooke/NNP T./NNP Mossman/NNP)
  ,/,
  a/DT
  professor/NN
  of/IN
  pathlogy/NN
  at/IN
  the/DT
  (ORGANIZATION University/NNP)
  of/IN
  (PERSON Vermont/NNP College/NNP)
  of/IN
  (GPE Medicine/NNP)

六　关系抽取

只要文本中的命名实体被识别，我们就可以提取它们之间存在的关系。
方法之一是首先寻找所有(X, a, Y)形式的三元组，其中X和Y是指定类型的命名实体，a表示X和Y之间关系的字符串
IN = re.compile(r'.*\bin\b(?!\b.+ing)')
for doc in nltk.corpus.ieer.parsed_docs('NYT_19980315'):
    for rel in nltk.sem.extract_rels('ORG', 'LOC', doc, corpus='ieer', pattern=IN):
        print nltk.sem.relextract.rtuple(rel)
[ORG: u'WHYY'] u'in' [LOC: u'Philadelphia']
[ORG: u'McGlashan & Sarrail'] u'firm in' [LOC: u'San Mateo']
[ORG: u'Freedom Forum'] u'in' [LOC: u'Arlington']
[ORG: u'Brookings Institution'] u', the research group in' [LOC: u'Washington']
[ORG: u'Idealab'] u', a self-described business incubator based in' [LOC: u'Los Angeles']
[ORG: u'Open Text'] u', based in' [LOC: u'Waterloo']

七　深入阅读