NLTK封装¶

`nltk` 包裹¶

`collocations` 模块¶

在语料库中识别搭配的工具——通常连续出现的单词。它们也可用于查找单词出现之间的其他关联。参见Manning和Schutze第5章，网址为http://nlp.stanford.edu/fsnlp/promo/colloc.pdf，以及http://ngram.sourceforge.net上的文本：：nsp perl包。

寻找搭配需要首先计算单词的频率和它们在其他单词上下文中的出现。通常情况下，单词的集合将需要过滤以只保留有用的内容术语。然后，每个词的ngram都可以根据某种关联度量进行评分，以确定每个ngram作为搭配的相对可能性。

这个 BigramCollocationFinder 和 TrigramCollocationFinder 类提供这些功能，取决于提供的函数在给定适当的频率计数的情况下对NGRAM进行评分。在bigram_度量和trigram_度量中提供了许多标准关联度量。

class nltk.collocations.BigramCollocationFinder(word_fd, bigram_fd, window_size=2)[源代码]¶

基类：nltk.collocations.AbstractCollocationFinder

用于查找和排序bigram搭配或其他关联度量的工具。使用from_Words（）而不是直接构造实例通常很有用。

default_ws = 2¶

classmethod from_words(words, window_size=2)[源代码]¶: 为给定序列中的所有大图构造一个BigramCollocationInder。当窗口大小大于2时，以教堂样式和汉克斯（1990）的关联比率计算非连续的大括号。

score_ngram(score_fn, w1, w2)[源代码]¶: 使用给定的计分函数返回给定bigram的分数。在Church和Hanks（1990）之后，计数按1/（窗口大小-1）的系数进行缩放。

class nltk.collocations.QuadgramCollocationFinder(word_fd, quadgram_fd, ii, iii, ixi, ixxi, iixi, ixii)[源代码]¶

基类：nltk.collocations.AbstractCollocationFinder

用于查找和排序四图搭配或其他关联度量的工具。使用from_Words（）而不是直接构造实例通常很有用。

default_ws = 4¶

classmethod from_words(words, window_size=4)[源代码]¶

score_ngram(score_fn, w1, w2, w3, w4)[源代码]¶

class nltk.collocations.TrigramCollocationFinder(word_fd, bigram_fd, wildcard_fd, trigram_fd)[源代码]¶

基类：nltk.collocations.AbstractCollocationFinder

用于查找和排序三角搭配或其他关联度量的工具。使用from_Words（）而不是直接构造实例通常很有用。

bigram_finder()[源代码]¶: 使用该查找器中的bigram和unigram数据构造bigram并置查找器。请注意，这不包括应用于此查找器的任何筛选。

default_ws = 3¶

classmethod from_words(words, window_size=3)[源代码]¶: 为给定序列中的所有三元构造一个三元配置标识。

score_ngram(score_fn, w1, w2, w3)[源代码]¶: 使用给定的得分函数返回给定三角图的得分。

`data` 模块¶

函数来查找和加载NLTK资源文件，如语料库、语法和保存的处理对象。资源文件使用URL标识，例如 nltk:corpora/abc/rural.txt 或 http://nltk.org/sample/toy.cfg . 支持以下URL协议：

file:path ：指定路径为的文件 path . 可以使用相对路径和绝对路径。

http://host/path ：指定存储在Web服务器上的文件 host 在路径上 path .

nltk:path ：指定存储在NLTK数据包中的文件 path . NLTK将在指定的目录中搜索这些文件 nltk.data.path .

如果未指定协议，则默认协议 nltk: 将被使用。

此模块提供可用于访问资源文件的函数，给定其URL: load() 加载给定资源，并将其添加到资源缓存；以及 retrieve() 将给定资源复制到本地文件。

nltk.data.AUTO_FORMATS = {'cfg': 'cfg', 'fcfg': 'fcfg', 'fol': 'fol', 'json': 'json', 'logic': 'logic', 'pcfg': 'pcfg', 'pickle': 'pickle', 'text': 'text', 'txt': 'text', 'val': 'val', 'yaml': 'yaml'}¶: 从文件扩展名到格式名的字典映射，当format=“auto”决定给定资源URL的格式时，由load（）使用。

nltk.data.BufferedGzipFile(*args, **kwargs)¶

A GzipFile 子类以与旧的nltk版本兼容。

使用 GzipFile 因为它还可以在所有支持的Python版本中进行缓冲。

@不推荐：使用gzip.gzip文件相反，因为它也使用缓冲区。

nltk.data.FORMATS = {'cfg': 'A context free grammar.', 'fcfg': 'A feature CFG.', 'fol': 'A list of first order logic expressions, parsed with nltk.sem.logic.Expression.fromstring.', 'json': 'A serialized python object, stored using the json module.', 'logic': 'A list of first order logic expressions, parsed with nltk.sem.logic.LogicParser. Requires an additional logic_parser parameter', 'pcfg': 'A probabilistic CFG.', 'pickle': 'A serialized python object, stored using the pickle module.', 'raw': 'The raw (byte string) contents of a file.', 'text': 'The raw (unicode string) contents of a file. ', 'val': 'A semantic valuation, parsed by nltk.sem.Valuation.fromstring.', 'yaml': 'A serialized python object, stored using the yaml module.'}¶: 描述由nltk的load（）方法支持的格式的字典。键是格式名，值是格式描述。

class nltk.data.FileSystemPathPointer(_path)[源代码]¶

基类：nltk.data.PathPointer, str

一种路径指针，用于标识可通过给定的绝对路径直接访问的文件。

file_size()[源代码]¶

返回此路径指针指向的文件的大小（字节）。

引发: IOError -- 如果此指针指定的路径不包含可读文件。

join(fileid)[源代码]¶: 返回一个新的路径指针，该指针从由该指针标识的路径开始，然后按照 fileid . 的路径组件 fileid 应该用正斜杠分隔，而不管底层文件系统的路径分隔符是什么。

open(encoding=None)[源代码]¶

返回可查找的只读流，该流可用于读取此路径指针标识的文件的内容。

引发: IOError -- 如果此指针指定的路径不包含可读文件。

property path¶: 此路径指针标识的绝对路径。

class nltk.data.GzipFileSystemPathPointer(_path)[源代码]¶

基类：nltk.data.FileSystemPathPointer

一个子类 FileSystemPathPointer 它标识位于给定绝对路径的gzip压缩文件。 GzipFileSystemPathPointer 适用于大型gzip压缩pickle对象的高效加载。

open(encoding=None)[源代码]¶

返回可查找的只读流，该流可用于读取此路径指针标识的文件的内容。

引发: IOError -- 如果此指针指定的路径不包含可读文件。

class nltk.data.LazyLoader(_path)[源代码]¶: 基类：object

class nltk.data.OpenOnDemandZipFile(filename)[源代码]¶

基类：zipfile.ZipFile

一个子类 zipfile.ZipFile 它在不使用文件指针时关闭文件指针；当需要从zipfile读取数据时重新打开文件指针。这对于减少同时访问许多zip文件时打开的文件句柄的数量非常有用。 OpenOnDemandZipFile 必须使用文件名而不是类似文件的对象构造（以允许重新打开）。 OpenOnDemandZipFile 是只读的（即 write() 和 writestr() 已禁用。

read(name)[源代码]¶: 返回名称的文件字节。

write(*args, **kwargs)[源代码]¶

引发: NotImplementedError -- OpenOnDemandZipFile是只读的

writestr(*args, **kwargs)[源代码]¶

引发: NotImplementedError -- OpenOnDemandZipFile是只读的

class nltk.data.PathPointer[源代码]¶

基类：object

“path pointers”的抽象基类，由NLTK的数据包用于标识特定路径。存在两个子类： FileSystemPathPointer 标识可通过给定绝对路径直接访问的文件。 ZipFilePathPointer 标识包含在zipfile中的文件，可以通过读取该zipfile来访问该文件。

abstract file_size()[源代码]¶

返回此路径指针指向的文件的大小（字节）。

引发: IOError -- 如果此指针指定的路径不包含可读文件。

abstract join(fileid)[源代码]¶: 返回一个新的路径指针，该指针从由该指针标识的路径开始，然后按照 fileid . 的路径组件 fileid 应该用正斜杠分隔，而不管底层文件系统的路径分隔符是什么。

abstract open(encoding=None)[源代码]¶

返回可查找的只读流，该流可用于读取此路径指针标识的文件的内容。

引发: IOError -- 如果此指针指定的路径不包含可读文件。

class nltk.data.SeekableUnicodeStreamReader(stream, encoding, errors='strict')[源代码]¶

基类：object

将源字节流自动编码为Unicode（如 codecs.StreamReader ）但仍然支持 seek() 和 tell() 操作正确。这与 codecs.StreamReader 提供 破碎的 seek() 和 tell() 方法。

这门课的动机是 StreamBackedCorpusView ，广泛利用 seek() 和 tell() ，并且需要能够处理Unicode编码的文件。

注意：这个类需要无状态解码器。据我所知，这不会导致任何Python内置的Unicode编码出现问题。

DEBUG = True¶

bytebuffer¶: 使用已读取但尚未解码的字节的缓冲区。这仅在读取的最后字节不构成字符的完整编码时使用。

char_seek_forward(offset)[源代码]¶: 向前移动读取指针 offset 字符。

close()[源代码]¶: 关闭基础流。

property closed¶: 如果基础流已关闭，则为true。

decode¶: 用于将字节字符串解码为Unicode字符串的函数。

discard_line()[源代码]¶

encoding¶: 应用于对基础流进行编码的编码的名称。

errors¶: 从基础流解码数据时应使用的错误模式。可以是“strict”、“ignore”或“replace”。

linebuffer¶: 使用的缓冲区 readline() 保留已被读取但尚未被返回的字符 read() 或 readline() . 这个缓冲区由一个Unicode字符串列表组成，其中每个字符串对应一行。列表的最后一个元素可能是完整的行，也可能不是完整的行。注意，linebuffer的存在使得 tell() 操作更复杂，因为它必须回溯到缓冲区的开头，以确定底层字节流中的正确文件位置。

property mode¶: 基础流的模式。

property name¶: 基础流的名称。

next()[源代码]¶: 从基础流返回下一个解码行。

read(size=None)[源代码]¶

读到 size 字节，使用该读卡器的编码对其进行解码，并返回生成的Unicode字符串。

参数: size (int) -- 要读取的最大字节数。如果未指定，则读取尽可能多的字节。
返回类型: unicode

readline(size=None)[源代码]¶

读取一行文本，使用该读卡器的编码对其进行解码，然后返回生成的Unicode字符串。

参数: size (int) -- 要读取的最大字节数。如果之前没有遇到换行符 size 字节已被读取，则返回的值可能不是完整的文本行。

readlines(sizehint=None, keepends=True)[源代码]¶

读取此文件的内容，使用此读取器的编码对其进行解码，并将其作为Unicode行的列表返回。

返回类型

list(unicode)

参数

sizehint -- 忽略。
keepends -- 如果为false，则去掉换行符。

seek(offset, whence=0)[源代码]¶

将流移动到新的文件位置。如果读卡器正在维护任何缓冲区，那么它们将被清除。

参数

offset -- 字节计数偏移量。
whence -- 如果为0，则偏移量是从文件开始的偏移量（偏移量应为正），如果为1，则偏移量是从当前位置开始的偏移量（偏移量可以为正或负）；如果为2，则偏移量是从文件结束的偏移量（偏移量通常应为负）。

stream¶: 底层流。

tell()[源代码]¶: 返回基础字节流上的当前文件位置。如果此读卡器维护任何缓冲区，则返回的文件位置将是这些缓冲区开头的位置。

xreadlines()[源代码]¶: 回归自我

nltk.data.clear_cache()[源代码]¶: 从资源缓存中删除所有对象。参见：Load（）

nltk.data.find(resource_name, paths=None)[源代码]¶

通过搜索路径中的目录和zip文件来查找给定的资源，其中无或空字符串指定绝对路径。返回相应的路径名。如果找不到给定的资源，则引发 LookupError ，其消息提供指向NLTK下载程序安装说明的指针。

压缩文件处理：

如果 resource_name 包含具有 .zip 扩展名，然后假设它是一个zipfile；剩下的路径组件用于查看zipfile内部。

如果 nltk.data.path 有一个 .zip 扩展名，则假定为zipfile。

如果最初找不到不包含任何zipfile组件的给定资源名，则 find() 将再次尝试查找该资源，方法是替换每个组件 p 在道路上与 p.zip/p . 例如，这允许 find() 映射资源名称 corpora/chat80/cities.pl 指向zip文件路径指针 corpora/chat80.zip/chat80/cities.pl .

使用时 find() 要定位zipfile中包含的目录，资源名称必须以正斜杠字符结尾。否则， find() 将找不到目录。

参数: resource_name (str or unicode) -- 要搜索的资源的名称。资源名是POSIX样式的相对路径名，例如 corpora/brown . 目录名将自动转换为平台相应的路径分隔符。
返回类型: str

nltk.data.load(resource_url, format='auto', cache=True, verbose=False, logic_parser=None, fstruct_reader=None, encoding=None)[源代码]¶

从NLTK数据包加载给定的资源。当前支持以下资源格式：

pickle

json

yaml

cfg （上下文无关语法）

pcfg （概率CFG）

fcfg （基于特征的CFG）

fol （一阶逻辑公式）

logic （逻辑公式由给定的逻辑分析器解析）

val （一阶逻辑模型的估值）

text （文件内容为Unicode字符串）

raw （原始文件内容作为字节字符串）

如果未指定格式， load() 将尝试根据资源名的文件扩展名确定格式。如果失败了， load() 将提高 ValueError 例外。

对于所有文本格式（除 pickle ， json ， yaml 和 raw ，它尝试使用utf-8解码原始内容，如果这不起作用，它将尝试使用iso-8859-1（拉丁语-1），除非 encoding 指定。

参数

resource_url (str) -- 指定从何处加载资源的URL。默认协议是“nltk:”，它在nltk数据包中搜索文件。
cache (bool) -- 如果为true，请将此资源添加到缓存中。如果load（）在其缓存中找到资源，则它将从缓存中返回该资源，而不是加载它。
verbose (bool) -- 如果为真，则在加载资源时打印消息。从缓存中检索资源时不显示消息。
logic_parser (LogicParser) -- 将用于分析逻辑表达式的分析器。
fstruct_reader (FeatStructReader) -- 将用于分析FCFG的功能结构的分析器。
encoding (str) -- 输入的编码；仅用于文本格式。

nltk.data.path = ['/home/bk/nltk_data', '/tmp/vpy/nltk_data', '/tmp/vpy/share/nltk_data', '/tmp/vpy/lib/nltk_data', '/usr/share/nltk_data', '/usr/local/share/nltk_data', '/usr/lib/nltk_data', '/usr/local/lib/nltk_data']¶: NLTK数据包可能驻留的目录列表。在数据包中查找资源时，将按顺序检查这些目录。请注意，这允许用户在自己的资源版本中替换资源（例如，在其主目录的~/nltk_data下）。

nltk.data.retrieve(resource_url, filename=None, verbose=True)[源代码]¶

将给定的资源复制到本地文件。如果未指定文件名，则使用URL的文件名。如果已经有一个名为 filename 然后举起一个 ValueError .

参数: resource_url (str) -- 指定从何处加载资源的URL。默认协议是“nltk:”，它在nltk数据包中搜索文件。

nltk.data.show_cfg(resource_url, escape='##')[源代码]¶

写出语法文件，忽略转义和空行。

参数

resource_url (str) -- 指定从何处加载资源的URL。默认协议是“nltk:”，它在nltk数据包中搜索文件。
escape (str) -- 指示要忽略的行的预结束字符串

`downloader` 模块¶

`featstruct` 模块¶

用于表示特征结构以及对这些特征结构执行基本操作的基本数据类。特征结构是从特征标识符到特征值的映射，其中每个特征值要么是基本值（如字符串或整数），要么是嵌套的特征结构。有两种类型的特征结构，由以下两个子类实现 FeatStruct ：

功能字典，由实现 FeatDict ，类似于python字典。功能标识符可以是 Feature 班级。

功能列表，由实现 FeatList ，类似于python列表。功能标识符是整数。

特征结构通常用于表示对象的部分信息。未映射到值的功能标识符表示值未知的功能（ not 没有值的功能）。两个表示（可能重叠）同一对象信息的特征结构可以通过统一进行组合。当两个不一致的特征结构被统一时，统一就会失败，并且不会返回任何信息。

可以使用“功能路径”或功能标识符的元组指定功能，这些标识符指定通过嵌套的功能结构到值的路径。特征结构可以包含可重入的特征值。“可重入特征值”是可以通过多个特征路径访问的单个特征值。统一保留了两个统一特征结构所施加的再入关系。在统一产生的特征结构中，对可重入特征值的任何修改都将使用其任何特征路径可见。

功能结构变量使用 nltk.sem.Variable 班级。使用绑定字典跟踪变量的值，该字典将变量映射到其值。当两个功能结构统一时，将创建一个新的绑定字典来跟踪它们的值；在统一完成之前，所有绑定变量都将替换为它们的值。因此，绑定字典通常严格地位于统一过程的内部。但是，如果您选择跟踪变量的绑定，则可以通过向 unify() 功能。

当未绑定的变量彼此统一时，它们将变为别名。这是通过将一个变量绑定到另一个变量来编码的。

轻量级特征结构¶

许多函数由 nltk.featstruct 可以直接应用于简单的python字典和列表，而不是完全成熟的 FeatDict 和 FeatList 物体。换句话说，python dicts 和 lists 可作为“轻量”特征结构。

>>> from nltk.featstruct import unify
>>> unify(dict(x=1, y=dict()), dict(a='a', y=dict(b='b')))  
{'y': {'b': 'b'}, 'x': 1, 'a': 'a'}

但是，您应该记住以下注意事项：

当检查值之间是否相等时，python字典和列表将忽略重入。但是两个具有不同重入度的特征被认为是不相等的，即使它们的基值都是相等的。

Feathstruct可以很容易地冻结，允许它们用作哈希表中的键。python字典和列表不能。

Featstruct在其字符串表示形式中显示可重入性；而Python字典和列表则不显示可重入性。

特色建筑 not 与Python字典和列表混合（例如，在执行统一时）。

FeathStructs提供了许多有用的方法，例如 walk() 和 cyclic() 不适用于python dict和list。

一般来说，如果您的特性结构将包含任何重入，或者您计划将它们用作字典键，强烈建议您使用完全成熟的 FeatStruct 物体。

class nltk.featstruct.FeatDict(features=None, **morefeatures)[源代码]¶

基类：nltk.featstruct.FeatStruct, dict

类似于Python字典的功能结构。即，从特征标识符到特征值的映射，其中特征标识符可以是字符串或 Feature ；其中，特征值可以是基本值（如字符串或整数），也可以是嵌套的特征结构。的功能标识符 FeatDict 有时称为“功能名称”。

如果两个功能指令为所有功能分配相同的值，并且具有相同的重入，则认为它们是相等的。

看见: FeatStruct 有关特征路径、重入、循环特征结构、可变性、冻结和哈希的信息。

clear() → None. Remove all items from D.¶: 如果自身被冻结，则引发ValueError。

get(name_or_path, default=None)[源代码]¶: 如果具有给定名称或路径的功能存在，则返回其值；否则，返回 default .

has_key(name_or_path)[源代码]¶: 如果存在具有给定名称或路径的功能，则返回true。

pop(k[, d]) → v, remove specified key and return the corresponding value.¶: 如果找不到键，则返回d（如果给定），否则，如果自身被冻结，则引发keyError，则引发valueError。

popitem() → (k, v), remove and return some (key, value) pair as a¶: 2元组；但如果d为空，则引发keyror。如果自身被冻结，则引发ValueError。

setdefault(*args, **kwargs)¶

如果关键字不在字典中，则插入值为默认值的关键字。

如果key在字典中，则返回key的值，否则返回default。如果自身冻结，则引发值错误。

update([E, ]**F) → None. Update D from dict/iterable E and F.[源代码]¶: 如果e存在并且有.keys（）方法，那么对e:d中的k执行：操作 [k] = e [k] 如果e存在，并且缺少.keys（）方法，则为：对于k，e:d中的v [k] =v在任何一种情况下，后面跟着：对于f:d中的k [k] = f [k]

class nltk.featstruct.FeatList(features=None, **morefeatures)[源代码]¶

基类：nltk.featstruct.FeatStruct, list

功能值列表，其中每个功能值要么是基本值（如字符串或整数），要么是嵌套的功能结构。

功能列表可能包含可重入的功能值。“可重入特征值”是可以通过多个特征路径访问的单个特征值。功能列表也可以是循环的。

如果两个特性列表为所有特性指定相同的值，并且具有相同的重入，则认为它们是相等的。

看见: FeatStruct 有关特征路径、重入、循环特征结构、可变性、冻结和哈希的信息。

append(*args, **kwargs)¶: 将对象追加到列表末尾。如果自身冻结，则引发值错误。

extend(*args, **kwargs)¶: 通过附加iterable中的元素来扩展列表。如果自身冻结，则引发值错误。

insert(*args, **kwargs)¶: 在索引之前插入对象。如果自身冻结，则引发值错误。

pop(*args, **kwargs)¶

移除并返回索引处的项（默认最后一个）。

如果列表为空或索引超出范围，则引发IndexError。如果自身被冻结，则引发ValueError。

remove(*args, **kwargs)¶

删除第一次出现的值。

如果值不存在，则引发ValueError。如果自身被冻结，则引发ValueError。

reverse(*args, **kwargs)¶: 反向就位 . 如果自身冻结，则引发值错误。

sort(*args, **kwargs)¶: 稳定排序就位 . 如果自身冻结，则引发值错误。

class nltk.featstruct.FeatStruct(features=None, **morefeatures)[源代码]¶

基类：nltk.sem.logic.SubstituteBindingsI

从特征标识符到特征值的映射，其中每个特征值要么是基本值（如字符串或整数），要么是嵌套的特征结构。有两种类型的功能结构：

功能字典，由实现 FeatDict ，类似于python字典。功能标识符可以是 Feature 班级。

功能列表，由实现 FeatList ，类似于python列表。功能标识符是整数。

功能结构可以使用简单的功能标识符或“功能路径”进行索引。功能路径是代表相应索引操作序列的功能标识符序列。特别地， fstruct[(f1,f2,...,fn)] 等于 fstruct[f1][f2]...[fn] .

特征结构可以包含可重入特征结构。“可重入特征结构”是可以通过多个特征路径访问的单个特征结构对象。特征结构也可以是循环的。如果有从特征结构到自身的任何特征路径，则特征结构是“循环”的。

如果两个特征结构为所有特征指定相同的值，并且具有相同的重入度，则认为它们是相等的。

默认情况下，特征结构是可变的。它们可以用 freeze() 方法。一旦它们被冻结，就可以进行哈希运算，从而用作字典键。

copy(deep=True)[源代码]¶

返回的新副本 self . 新副本不会被冻结。

参数: deep -- 如果为真，则创建深度副本；如果为假，则创建浅副本。

cyclic()[源代码]¶: 如果此功能结构包含自身，则返回true。

equal_values(other, check_reentrance=False)[源代码]¶

如果返回真 self 和 other 为每个特征指定相同的值。尤其是，如果 self[p]==other[p] 对于每个功能路径 p 这样的话 self[p] 或 other[p] 是基值（即不是嵌套的功能结构）。

参数: check_reentrance -- 如果是真的，那么如果在 self 和 other .
笔记: 这个 == 等于 equal_values() 具有 check_reentrance=True .

freeze()[源代码]¶: 使此功能结构及其包含的任何功能结构不可变。注意：此方法不会尝试“冻结”任何不是 FeatStruct ；建议您只使用不可变的功能值。

frozen()[源代码]¶: 如果此功能结构不可变，则返回true。特征结构可以通过 freeze() 方法。不可变的特征结构不能再变，但可以使用 copy() 方法。

remove_variables()[源代码]¶

返回通过删除值为 Variable .

返回类型: FeatStruct

rename_variables(vars=None, used_vars=(), new_vars=None)[源代码]¶

看见: nltk.featstruct.rename_variables()

retract_bindings(bindings)[源代码]¶

看见: nltk.featstruct.retract_bindings()

substitute_bindings(bindings)[源代码]¶

看见: nltk.featstruct.substitute_bindings()

subsumes(other)[源代码]¶: 如果返回真 self 归类 other . 也就是说，如果统一，则返回true self 具有 other 将导致特征结构等于 other .

unify(other, bindings=None, trace=False, fail=None, rename_vars=True)[源代码]¶

variables()[源代码]¶

看见: nltk.featstruct.find_variables()

walk()[源代码]¶: 返回生成此功能结构的迭代器及其包含的每个功能结构。每个功能结构将只生成一次。

class nltk.featstruct.FeatStructReader(features=(*slash*, *type*), fdict_class=<class 'nltk.featstruct.FeatStruct'>, flist_class=<class 'nltk.featstruct.FeatList'>, logic_parser=None)[源代码]¶

基类：object

VALUE_HANDLERS = [('read_fstruct_value', re.compile('\\s*(?:\$(\\d+)\$\\s*)?(\\??[\\w-]+)?(\\[)')), ('read_var_value', re.compile('\\?[a-zA-Z_][a-zA-Z0-9_]*')), ('read_str_value', re.compile('[uU]?[rR]?([\'"])')), ('read_int_value', re.compile('-?\\d+')), ('read_sym_value', re.compile('[a-zA-Z_][a-zA-Z0-9_]*')), ('read_app_value', re.compile('<(app)\$(\\?[a-z][a-z]*)\\s*,\\s*(\\?[a-z][a-z]*)\$>')), ('read_logic_value', re.compile('<(.*?)(?<!-)>')), ('read_set_value', re.compile('{')), ('read_tuple_value', re.compile('\\('))]¶

指示应如何处理功能值的表。表中的每个条目都是一对（handler、regexp）。具有匹配regexp的第一个条目将调用其处理程序。处理程序应具有以下签名：：

def handler(s, position, reentrances, match): ...

并且应该返回一个元组（value，position），其中position是值结束的字符串位置。（注意：这里的秩序很重要！）

fromstring(s, fstruct=None)[源代码]¶

将特征结构的字符串表示形式（由repr显示）转换为 FeatStruct . 此过程对字符串表示形式施加以下限制：

功能名称不能包含以下任何内容：空白、括号、引号、等号、短划线、逗号和方括号。功能名称不能以加号或减号开头。
只支持以下基本功能值：字符串、整数、变量、无和未加引号的字母数字字符串。
对于可重入值，第一次提及必须指定一个可重入标识符和一个值；随后提及的任何内容都必须使用箭头 ('->' ）引用重入标识符。

read_app_value(s, position, reentrances, match)[源代码]¶: 主要包括向后兼容。

read_fstruct_value(s, position, reentrances, match)[源代码]¶

read_int_value(s, position, reentrances, match)[源代码]¶

read_logic_value(s, position, reentrances, match)[源代码]¶

read_partial(s, position=0, reentrances=None, fstruct=None)[源代码]¶

在功能结构中读取的助手函数。

参数

s -- 要读取的字符串。
position -- 要开始分析的字符串中的位置。
reentrances -- 从重入ID到值的字典。默认为空字典。

返回

通过解析创建的特征结构的元组（val，pos）和解析的特征结构结束的位置。

返回类型

bool

read_set_value(s, position, reentrances, match)[源代码]¶

read_str_value(s, position, reentrances, match)[源代码]¶

read_sym_value(s, position, reentrances, match)[源代码]¶

read_tuple_value(s, position, reentrances, match)[源代码]¶

read_value(s, position, reentrances)[源代码]¶

read_var_value(s, position, reentrances, match)[源代码]¶

class nltk.featstruct.Feature(name, default=None, display=None)[源代码]¶

基类：object

专门用于放置附加约束、默认值等的功能标识符。

property default¶: 此功能的默认值。

property display¶: 自定义显示位置：可以是前缀或斜线。

property name¶: 此功能的名称。

read_value(s, position, reentrances, parser)[源代码]¶

unify_base_values(fval1, fval2, bindings)[源代码]¶: 如果可能，返回单个值。如果没有，返回值 UnificationFailure .

class nltk.featstruct.RangeFeature(name, default=None, display=None)[源代码]¶

基类：nltk.featstruct.Feature

RANGE_RE = re.compile('(-?\\d+):(-?\\d+)')¶

read_value(s, position, reentrances, parser)[源代码]¶

unify_base_values(fval1, fval2, bindings)[源代码]¶: 如果可能，返回单个值。如果没有，返回值 UnificationFailure .

class nltk.featstruct.SlashFeature(name, default=None, display=None)[源代码]¶

基类：nltk.featstruct.Feature

read_value(s, position, reentrances, parser)[源代码]¶

nltk.featstruct.conflicts(fstruct1, fstruct2, trace=0)[源代码]¶

返回分配了不兼容值的所有功能的功能路径列表 fstruct1 和 fstruct2 .

返回类型: list(tuple)

nltk.featstruct.subsumes(fstruct1, fstruct2)[源代码]¶

如果返回真 fstruct1 归类 fstruct2 . 也就是说，如果统一，则返回true fstruct1 具有 fstruct2 将导致特征结构等于 fstruct2.

返回类型: bool

nltk.featstruct.unify(fstruct1, fstruct2, bindings=None, trace=False, fail=None, rename_vars=True, fs_class='default')[源代码]¶

统一 fstruct1 具有 fstruct2 ，并返回生成的特征结构。这个统一的功能结构是最小的功能结构，它包含来自两个功能的所有功能值分配 fstruct1 和 fstruct2 这就保留了所有的再入。

如果不存在这样的功能结构（因为 fstruct1 和 fstruct2 为某些功能指定不兼容的值），然后统一失败，以及 unify 没有返回。

绑定变量被其值替换。别名变量替换为其代表变量（如果未绑定）或其代表变量（如果绑定）的值。即，如果变量 v 是在 bindings 然后 v 被替换 bindings[v] . 这将重复，直到变量被未绑定的变量或非变量值替换。

未绑定变量在与值统一时绑定；在与变量统一时别名。即，如果变量 v 不在 bindings ，并与变量或值统一 x 然后 bindings[v] 设置为 x .

如果 bindings 未指定，则假定所有变量都未绑定。即。， bindings 默认为空的dict。

>>> from nltk.featstruct import FeatStruct
>>> FeatStruct('[a=?x]').unify(FeatStruct('[b=?x]'))
[a=?x, b=?x2]

参数

bindings (dict(Variable -> any)) -- 在统一期间要使用和更新的一组变量绑定。
trace (bool) -- 如果为真，则生成跟踪输出。
rename_vars (bool) -- 如果为真，则重命名 fstruct2 也用于 fstruct1 ，以避免变量名冲突。

`grammar` 模块¶

用于表示上下文无关语法的基本数据类。“语法”指定哪些树可以表示给定文本的结构。这些树中的每一个都被称为文本的“解析树”（或者简单地称为“解析”）。在“上下文无关”语法中，一段文本的解析树集只能依赖于该段，而不能依赖于文本的其余部分（即该段的上下文）。上下文无关语法常被用来寻找句子可能的句法结构。在此上下文中，解析树的叶子是单词标记；节点值是短语类别，例如 NP 和 VP .

这个 CFG 类用于对上下文无关语法进行编码。各 CFG 由开始符号和一组产品组成。“开始符号”指定分析树的根节点值。例如，用于语法分析的起始符号通常是 S . 开始符号使用 Nonterminal 类，下面讨论。

语法的“产品”指定解析树可以包含哪些父子关系。每个产品都指定特定节点可以是特定子集合的父节点。例如，生产 <S> -> <NP> <VP> 指定一个 S 节点可以是 NP 节点与A VP 节点。

语法生成由 Production 班级。各 Production 由左侧和右侧组成。“左手边”是 Nonterminal 它指定潜在父级的节点类型；“右侧”是一个列表，指定该父级的允许子级。此列表包括 Nonterminals 和文本类型：每个 Nonterminal 指示相应的子级可以是 TreeToken 具有指定的节点类型；并且每个文本类型指示对应的子级可以是 Token 和那个类型的。

这个 Nonterminal 类用于区分节点值和叶值。这可以防止语法意外地使用叶值（如英语单词“a”）作为子树的节点。在一个 CFG ，所有节点值都包装在 Nonterminal 班级。但是请注意，语法指定的树 not 包括这些 Nonterminal 包装纸。

语法也可以得到更为程序化的解释。根据这种解释，语法指定任何树结构 tree 可通过以下程序产生：

将树设置为开始符号

重复，直到树不再包含非终端叶：

选择左手边的生产产品

lhs是树的非末梢叶子。

将非终端叶替换为子树，其节点

值是由非终端lhs包装的值，并且

他们的孩子是普罗德的右手边。

更换左侧的操作（ lhs ）右手边的产品（ rhs 在一棵树上（ tree ）被称为“扩张” lhs 到 rhs 在里面 tree .

class nltk.grammar.CFG(start, productions, calculate_leftcorners=True)[源代码]¶

基类：object

上下文无关的语法。语法由一个开始状态和一组产生组成。终端和非终端集由产品隐式指定。

如果需要对产品进行有效的基于键的访问，可以使用子类来实现它。

classmethod binarize(grammar, padding='@$@')[源代码]¶

通过引入新的令牌，将所有非二进制规则转换为二进制规则。示例：：原始：

A=>B C D

转换后：: A=>B A@$@B A@$@B=>C D

check_coverage(tokens)[源代码]¶

检查语法规则是否覆盖给定的令牌列表。如果没有，则引发异常。

chomsky_normal_form(new_token_padding='@$@', flexible=False)[源代码]¶: 返回Chomsky Normal中的新语法：param:new_token_padding

在二值化期间自定义新规则的形成

classmethod eliminate_start(grammar)[源代码]¶: 如果开始规则出现在rhs上，则取消该规则示例：s->s0 s1和s0->s1 s，然后添加另一个规则s0_sigma->s。

classmethod fromstring(input, encoding=None)[源代码]¶

返回与输入字符串对应的语法实例。

参数: input -- 一种文法，可以是字符串形式，也可以是字符串列表形式。

is_binarised()[源代码]¶: 如果所有生成最多为二进制，则返回true。请注意，仍然可以有空的和一元的产品。

is_chomsky_normal_form()[源代码]¶: 如果语法是Chomsky标准形式，即所有生成的形式都是a->b c或a->s，则返回true。

is_flexible_chomsky_normal_form()[源代码]¶: 如果所有产品的形式都是A->B C、A->B或A->S，则返回true。

is_leftcorner(cat, left)[源代码]¶

如果Left是cat的左角，则为true，其中Left可以是终端，也可以是非终端。

参数

cat (Nonterminal) -- 左角的父级
left (Terminal or Nonterminal) -- 建议的左角

返回类型

bool

is_lexical()[源代码]¶: 如果所有产品都是词典化的，则返回true。

is_nonempty()[源代码]¶: 如果没有空生产，则返回true。

is_nonlexical()[源代码]¶

如果所有词汇规则都是“preterminals”，即可以在预处理步骤中分隔的一元规则，则返回true。

这意味着所有的产品都是A->B1…bn（n>=0），或a->“s”。

注意：is_lexical（）和is_nonlexical（）不是对立词。有既不是的语法，也有既不是的语法。

leftcorner_parents(cat)[源代码]¶

返回给定类别为左角的所有非终端的集合。这是左角关系的倒数。

参数: cat (Nonterminal) -- 建议的左角
返回: 所有家长集合到左角
返回类型: set(Nonterminal)

leftcorners(cat)[源代码]¶

返回给定非终端可以开始的所有非终端的集合，包括其本身。

这是立即左角关系的反身传递闭包：（a>b）iff（a->b beta）

参数: cat (Nonterminal) -- 左角的父级
返回: 所有左角的集合
返回类型: set(Nonterminal)

max_len()[源代码]¶: 返回最长语法生成的右侧长度。

min_len()[源代码]¶: 返回最短语法生成的右侧长度。

productions(lhs=None, rhs=None, empty=False)[源代码]¶

返回语法产物，由左侧或右侧的第一项筛选。

参数

lhs -- 仅返回具有给定左侧的产品。
rhs -- 仅返回右手边具有给定第一项的生产。
empty -- 仅返回右侧为空的生产。

返回

与给定约束匹配的产品列表。

返回类型

list(Production)

classmethod remove_unitary_rules(grammar)[源代码]¶: 删除非词汇的单一规则并将其转换为词汇规则

start()[源代码]¶

返回语法的开始符号

返回类型: Nonterminal

class nltk.grammar.DependencyGrammar(productions)[源代码]¶

基类：object

依赖语法。DependencyGrammar由一组产品组成。每个产品都指定一对单词之间的标题/修饰词关系。

contains(head, mod)[源代码]¶

参数

head (str) -- 头头字
mod (str) -- 一个修饰词，作为“head”的修饰语进行测试。

返回

如果这是真的 DependencyGrammar 包含一个 DependencyProduction 将“head”映射到“mod”。

返回类型

bool

classmethod fromstring(input)[源代码]¶

class nltk.grammar.DependencyProduction(lhs, rhs)[源代码]¶

基类：nltk.grammar.Production

依赖语法生成。每个作品都将一个单词映射到一个或多个修饰词的无序列表中。

class nltk.grammar.Nonterminal(symbol)[源代码]¶

基类：object

上下文无关文法的非终端符号。 Nonterminal 是节点值的包装类；它由 Production 对象来区分节点值和叶值。由包装的节点值 Nonterminal 被称为“符号”。符号通常是表示短语类别的字符串（例如 "NP" 或 "VP" ）但是，有时会使用更复杂的符号类型（例如，用于词汇化语法）。因为符号是节点值，所以它们必须是不可变的和可哈希的。二 Nonterminals 如果符号相等，则视为相等。

看见: CFG, Production
变量: _symbol -- 与此对应的节点值 Nonterminal . 此值必须是不可变的和可哈希的。

symbol()[源代码]¶

返回与此对应的节点值 Nonterminal .

返回类型: (any)

class nltk.grammar.PCFG(start, productions, calculate_leftcorners=True)[源代码]¶

基类：nltk.grammar.CFG

概率上下文无关语法。PCFG由一个开始状态和一组具有概率的生产组成。终端和非终端集由产品隐式指定。

PCFG生产使用 ProbabilisticProduction 班级。 PCFGs 施加一个约束，即任何给定左手边的一组生产必须具有总和为1的概率（允许小误差）。

如果需要对产品进行有效的基于键的访问，可以使用子类来实现它。

变量: EPSILON -- 用于检查具有给定左侧的生产是否具有总和为1的概率的可接受误差范围。

EPSILON = 0.01¶

classmethod fromstring(input, encoding=None)[源代码]¶

返回与输入字符串相对应的概率上下文无关语法。

参数: input -- 一种语法，可以是字符串形式，也可以是字符串列表形式。

class nltk.grammar.ProbabilisticDependencyGrammar(productions, events, tags)[源代码]¶

基类：object

contains(head, mod)[源代码]¶

如果这个返回真 DependencyGrammar 包含一个 DependencyProduction 将“head”映射到“mod”。

参数

head (str) -- 头头字
mod (str) -- 一个修饰词，作为“head”的修饰语进行测试。

返回类型

bool

class nltk.grammar.ProbabilisticProduction(lhs, rhs, **prob)[源代码]¶

基类：nltk.grammar.Production, nltk.probability.ImmutableProbabilisticMixIn

概率上下文无关文法的产生。光子晶体光纤 ProbabilisticProduction 基本上只是一个 Production 这有一个相关的概率，它表示使用这种产品的可能性有多大。尤其是 ProbabilisticProduction 记录其右侧是其左侧的任何给定事件的正确实例化的可能性。

看见: Production

class nltk.grammar.Production(lhs, rhs)[源代码]¶

基类：object

语法作品。每个产品都将“左侧”上的一个符号映射到“右侧”上的一系列符号。（对于上下文无关的产品，左侧必须是 Nonterminal ，右侧是一系列端子和 Nonterminals ）“终端”可以是任何非 Nonterminal . 通常，终端是表示单词的字符串，例如 "dog" 或 "under" .

看见

CFG

看见

DependencyGrammar

看见

Nonterminal

变量

_lhs -- 生产的左侧。
_rhs -- 生产的右侧。

is_lexical()[源代码]¶

如果右侧至少包含一个终端标记，则返回true。

返回类型: bool

is_nonlexical()[源代码]¶

如果右侧仅包含 Nonterminals

返回类型: bool

lhs()[源代码]¶

返回此的左侧 Production .

返回类型: Nonterminal

rhs()[源代码]¶

把这个放回右边 Production .

返回类型: sequence(Nonterminal and terminal)

nltk.grammar.induce_pcfg(start, productions)[源代码]¶

从产品列表中归纳出PCFG语法。

PCFG中A->B C生产的概率为：

计数（A-＞B C）

p（b，c_a）=----------式中 * 有右手边的吗

计数（A-） * ）

参数

start (Nonterminal) -- 开始符号
productions (list(Production)) -- 定义语法的产品列表

nltk.grammar.nonterminals(symbols)[源代码]¶

给定包含符号名称列表的字符串，返回 Nonterminals 由这些符号构成。

参数: symbols (str) -- 符号名字符串。此字符串可以用空格或逗号分隔。
返回: 列表 Nonterminals 根据中给出的符号名称构造 symbols . 这个 Nonterminals 按与符号名称相同的顺序排序。
返回类型: list(Nonterminal)

nltk.grammar.read_grammar(input, nonterm_parser, probabilistic=False, encoding=None)[源代码]¶

返回一对由起始类别和 Productions .

参数

input -- 一种语法，可以是字符串形式，也可以是字符串列表形式。
nonterm_parser -- 用于分析非终端的函数。它应该需要一个 (string, position) 作为参数并返回 (nonterminal, position) 结果。
probabilistic (bool) -- 语法规则是概率的吗？
encoding (str) -- 语法的编码，如果它是二进制字符串

`help` 模块¶

`probability` 模块¶

用于表示和处理概率信息的类。

这个 FreqDist 类用于编码“频率分布”，它计算实验的每个结果发生的次数。

这个 ProbDistI 类为“概率分布”定义了一个标准接口，该接口对实验的每个结果的概率进行编码。概率分布有两种类型：

“导出概率分布”是根据频率分布创建的。他们试图模拟产生频率分布的概率分布。

“分析概率分布”直接由参数（如方差）创建。

这个 ConditionalFreqDist 类和 ConditionalProbDistI 接口用于对条件分布进行编码。条件概率分布可以推导或分析；但目前唯一的实现是 ConditionalProbDistI 接口是 ConditionalProbDist ，派生分布。

class nltk.probability.ConditionalFreqDist(cond_samples=None)[源代码]¶

基类：collections.defaultdict

在不同条件下运行的单个实验的频率分布集合。条件频率分布用于记录每个样本发生的次数，给定实验运行的条件。例如，条件频率分布可以用来记录文档中每个单词（类型）的频率（给定其长度）。形式上，条件频率分布可以定义为一个函数，在该条件下从每个条件映射到实验的频率分布。

条件频率分布通常是通过在各种条件下重复运行一个实验，并在适当条件下增加样本结果计数来构建的。例如，下面的代码将生成一个条件频率分布，该分布编码每种单词类型发生的频率（给定该单词类型的长度）：

>>> from nltk.probability import ConditionalFreqDist
>>> from nltk.tokenize import word_tokenize
>>> sent = "the the the dog dog some other words that we do not care about"
>>> cfdist = ConditionalFreqDist()
>>> for word in word_tokenize(sent):
...     condition = len(word)
...     cfdist[condition][word] += 1

这样做的等效方法是使用初始值设定项：

>>> cfdist = ConditionalFreqDist((len(word), word) for word in word_tokenize(sent))

使用索引运算符访问每个条件的频率分布：

>>> cfdist[3]
FreqDist({'the': 3, 'dog': 2, 'not': 1})
>>> cfdist[3].freq('the')
0.5
>>> cfdist[3]['dog']
2

当使用索引运算符访问以前未访问过的条件的频率分布时， ConditionalFreqDist 为该条件创建新的空freqdist。

N()[源代码]¶

返回此记录的样本结果总数 ConditionalFreqDist .

返回类型: int

conditions()[源代码]¶

返回为此访问的条件列表 ConditionalFreqDist . 使用索引运算符访问给定条件的频率分布。注意，某些条件下的频率分布可能包含零样本结果。

返回类型: list

plot(*args, **kwargs)[源代码]¶

根据条件频率分布绘制给定样本。对于累积图，指定cumulative=true。（需要安装Matplotlib。）

参数

samples (list) -- 要绘制的样本
title (str) -- 图表的标题
conditions (list) -- 要绘制的条件（默认为全部）

tabulate(*args, **kwargs)[源代码]¶

将条件频率分布中给定的样本制成表格。

参数

samples (list) -- 要绘制的样本
conditions (list) -- 要绘制的条件（默认为全部）
cumulative -- 用于指定频率是否累积的标志（默认值=假）

class nltk.probability.ConditionalProbDist(cfdist, probdist_factory, *factory_args, **factory_kw_args)[源代码]¶

基类：nltk.probability.ConditionalProbDistI

一个条件概率分布模型的实验，用来产生一个条件频率分布。ConditionalProbDist由 ConditionalFreqDist 和A ProbDist 工厂：

这个 ConditionalFreqDist 指定每个条件的频率分布。
这个 ProbDist 工厂是一个函数，它接受一个条件的频率分布，并返回其概率分布。一 ProbDist 类的名称（例如 MLEProbDist 或 HeldoutProbDist ）可用于指定该类的构造函数。

第一个论点 ProbDist factory是应该建模的频率分布；其余参数由 factory_args 参数 ConditionalProbDist 构造函数。例如，以下代码构造 ConditionalProbDist ，其中每个条件的概率分布是 ELEProbDist 有10个箱子：

>>> from nltk.corpus import brown
>>> from nltk.probability import ConditionalFreqDist
>>> from nltk.probability import ConditionalProbDist, ELEProbDist
>>> cfdist = ConditionalFreqDist(brown.tagged_words()[:5000])
>>> cpdist = ConditionalProbDist(cfdist, ELEProbDist, 10)
>>> cpdist['passed'].max()
'VBD'
>>> cpdist['passed'].prob('VBD')
0.423...

class nltk.probability.ConditionalProbDistI[源代码]¶

基类：dict

在不同条件下运行的单个实验的概率分布集合。条件概率分布是用来估计每一个样本的可能性，给定的条件下，实验运行。例如，根据单词类型的长度，可以使用条件概率分布来估计文档中每个单词类型的概率。形式上，条件概率分布可以定义为从每个条件映射到 ProbDist 在那种条件下的实验。

conditions()[源代码]¶

返回由此表示的条件列表 ConditionalProbDist . 使用索引运算符访问给定条件的概率分布。

返回类型: list

class nltk.probability.CrossValidationProbDist(freqdists, bins)[源代码]¶

基类：nltk.probability.ProbDistI

实验概率分布的交叉验证估计用于生成一组频率分布。样本概率的“交叉验证估计”是通过平均每对频率分布中样本的保留估计得出的。

SUM_TO_ONE = False¶: 如果此概率分布中样本的概率始终为1，则为真。

discount()[源代码]¶

返回计数平均折扣率：c*/c

返回类型: float

freqdists()[源代码]¶

返回频率分布列表， ProbDist 是基于。

返回类型: list(FreqDist)

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

class nltk.probability.DictionaryConditionalProbDist(probdist_dict)[源代码]¶

基类：nltk.probability.ConditionalProbDistI

另一种条件probdist，它只包装probdist的字典，而不是从freqdist创建这些字典。

class nltk.probability.DictionaryProbDist(prob_dict=None, log=False, normalize=False)[源代码]¶

基类：nltk.probability.ProbDistI

一种概率分布，其概率由给定的字典直接规定。给定的字典将样本映射到概率。

logprob(sample)[源代码]¶

返回给定样本概率的底2对数。

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

class nltk.probability.ELEProbDist(freqdist, bins=None)[源代码]¶

基类：nltk.probability.LidstoneProbDist

用于生成频率分布的实验概率分布的预期似然估计。“预期可能性估计”用计数来近似一个样本的概率。 c 从一个实验 N 结果与 B 箱作为 (c+0.5)/(N+B/2) . 这相当于在每个存储单元的计数中加上0.5，并对产生的频率分布进行最大似然估计。

class nltk.probability.FreqDist(samples=None)[源代码]¶

基类：collections.Counter

实验结果的频率分布。频率分布记录了每一个实验结果发生的次数。例如，频率分布可以用来记录文档中每种单词类型的频率。从形式上讲，频率分布可以定义为从每个样本到样本作为结果出现的次数的函数映射。

频率分布通常是通过运行一些实验来构建的，并且每次作为一个实验的结果时，增加一个样本的计数。例如，以下代码将生成一个频率分布，该频率分布编码文本中每个单词的出现频率：

>>> from nltk.tokenize import word_tokenize
>>> from nltk.probability import FreqDist
>>> sent = 'This is an example sentence'
>>> fdist = FreqDist()
>>> for word in word_tokenize(sent):
...    fdist[word.lower()] += 1

这样做的等效方法是使用初始值设定项：

>>> fdist = FreqDist(word.lower() for word in word_tokenize(sent))

B()[源代码]¶

返回计数大于零的样本值（或“bin”）的总数。对于记录的样本结果总数，使用 FreqDist.N() . （freqdist.b（）与len（freqdist）相同。）

返回类型: int

N()[源代码]¶

返回此freqdist记录的样本结果总数。对于计数大于零的唯一样本值（或箱）的数量，请使用 FreqDist.B() .

返回类型: int

Nr(r, bins=None)[源代码]¶

copy()[源代码]¶

创建此频率分布的副本。

返回类型: FreqDist

freq(sample)[源代码]¶

返回给定样本的频率。样本频率定义为该样本的计数除以该freqdist记录的样本结果总数。样本计数定义为此freqdist记录样本结果的次数。频率总是范围内的实数 [0, 1] .

参数: sample (any) -- 应返回其频率的样本。
返回类型: float

hapaxes()[源代码]¶

返回一次出现的所有样本的列表（hapax legomena）

返回类型: list

max()[源代码]¶

返回此频率分布中结果数量最多的样本。如果两个或多个样本具有相同数量的结果，则返回其中一个；返回的样本未定义。如果在这个频率分布中没有发生任何结果，则返回none。

返回: 在这个频率分布中具有最大结果数的样本。
返回类型: any or None

pformat(maxlen=10)[源代码]¶

返回此freqdist的字符串表示形式。

参数: maxlen (int) -- 要显示的最大项目数
返回类型: string

plot(*args, **kwargs)[源代码]¶

从频率分布中绘制样本，首先显示最频繁的样本。如果提供了一个整数参数，请在绘制了这么多样本后停止。对于累积图，指定cumulative=true。（需要安装Matplotlib。）

参数

title (bool) -- 图表的标题
cumulative -- 用于指定绘图是否累积的标志（默认值=假）

pprint(maxlen=10, stream=None)[源代码]¶

将此freqdist的字符串表示形式打印到“stream”

参数

maxlen (int) -- 要打印的最大项目数
stream -- 要打印到的流。默认为标准输出

r_Nr(bins=None)[源代码]¶

返回字典映射r到nr，即频率为r的样本数，其中nr>0。

参数: bins (int) -- 可能的样本结果数。 bins 用于计算nr（0）。特别是，nr（0）是 bins-self.B() . 如果 bins 未指定，默认为 self.B() （因此nr（0）将为0）。
返回类型: int

setdefault(key, val)[源代码]¶: 重写 Counter.setdefault() 使缓存的n无效

tabulate(*args, **kwargs)[源代码]¶

将频率分布（累积）中给定的样本制成表格，首先显示最频繁的样本。如果提供了一个整数参数，请在绘制了这么多样本后停止。

参数

samples (list) -- 要绘制的样本（默认为所有样本）
cumulative -- 用于指定频率是否累积的标志（默认值=假）

update(*args, **kwargs)[源代码]¶: 重写 Counter.update() 使缓存的n无效

class nltk.probability.HeldoutProbDist(base_fdist, heldout_fdist, bins=None)[源代码]¶

基类：nltk.probability.ProbDistI

实验概率分布的Heldout估计用于生成两个频率分布。这两种频率分布称为“Heldout频率分布”和“基频分布”。“Heldout估计”使用“Heldout频率分布”预测每个样本的概率，给定其在“基频分布”中的频率。

特别是，Heldout估计近似于样本发生的概率。 r 基本分布中的时间，作为所有样本Heldout分布中的平均频率 r 基本分布中的时间。

这个平均频率是 [Tr[r]/(Nr[r].N)] ，其中：

[Tr[R]] 是heldout分布中发生的所有样本的总数 r 基本分布中的时间。
[NR[R]] 是发生的样本数 r 基本分布中的时间。
N 是Heldout频率分布记录的结果数。

为了提高 prob 成员函数， [Tr[r]/(Nr[r].N)] 为每个值预计算 r 当 HeldoutProbDist 创建。

变量

_estimate -- 列表映射来自 r ，样本在基本分布中出现的次数，到该样本的概率估计。 _estimate[r] 计算方法是求出所有样本的Heldout分布的平均频率。 r 基本分布中的时间。特别地， _estimate[r] = [Tr[r]/(Nr[r].N)] .
_max_r -- 任何样本在基分布中出现的最大次数。 _max_r 用来决定有多大 _estimate 必须是。

SUM_TO_ONE = False¶: 如果此概率分布中样本的概率始终为1，则为真。

base_fdist()[源代码]¶

返回此概率分布所基于的基频分布。

返回类型: FreqDist

discount()[源代码]¶

返回计数平均折扣率：c*/c

返回类型: float

heldout_fdist()[源代码]¶

返回此概率分布所基于的Heldout频率分布。

返回类型: FreqDist

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

class nltk.probability.ImmutableProbabilisticMixIn(**kwargs)[源代码]¶

基类：nltk.probability.ProbabilisticMixIn

set_logprob(prob)[源代码]¶

将与此对象关联的日志概率设置为 logprob . 即，将与此对象关联的概率设置为 2**(logprob) .

参数: logprob (float) -- 新的对数概率

set_prob(prob)[源代码]¶

将与此对象关联的概率设置为 prob .

参数: prob (float) -- 新概率

class nltk.probability.KneserNeyProbDist(freqdist, bins=None, discount=0.75)[源代码]¶

基类：nltk.probability.ProbDistI

Kneser-Ney概率分布的估计。这是一个后退的版本，计算一个n-gram在训练中被看到的可能性。扩展probdist接口，需要在trigram freqdist实例上进行训练。或者，可以指定不同于默认折扣值的值。默认折扣设置为0.75。

discount()[源代码]¶

返回对计数进行折扣的值。默认设置为0.75。

返回类型: float

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(trigram)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

set_discount(discount)[源代码]¶

将计数的折扣值设置为折扣值。

参数: discount (float (preferred, but int possible)) -- 折扣的新值按
返回类型: None

class nltk.probability.LaplaceProbDist(freqdist, bins=None)[源代码]¶

基类：nltk.probability.LidstoneProbDist

拉普拉斯估计用于产生频率分布的实验的概率分布。“拉普拉斯估计”用计数近似一个样本的概率。 c 从一个实验 N 结果与 B 箱作为 (c+1)/(N+B) . 这相当于在每个存储单元的计数中添加一个，并对生成的频率分布进行最大似然估计。

class nltk.probability.LidstoneProbDist(freqdist, gamma, bins=None)[源代码]¶

基类：nltk.probability.ProbDistI

用于产生频率分布的实验概率分布的Lidstone估计。“Lidstone估计”由实数参数化。伽马，通常在0到1之间。Lidstone估计近似于具有计数的样本的概率。 c 从一个实验 N 结果与 B 箱作为 c+gamma)/(N+B*gamma) . 这相当于添加伽马对每个存储单元进行计数，并对得到的频率分布进行最大似然估计。

SUM_TO_ONE = False¶: 如果此概率分布中样本的概率始终为1，则为真。

discount()[源代码]¶

返回计数平均折扣率：c*/c

返回类型: float

freqdist()[源代码]¶

返回此概率分布所基于的频率分布。

返回类型: FreqDist

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

class nltk.probability.MLEProbDist(freqdist, bins=None)[源代码]¶

基类：nltk.probability.ProbDistI

用于产生频率分布的实验概率分布的最大似然估计。“最大似然估计”将每个样本的概率近似为频率分布中该样本的频率。

freqdist()[源代码]¶

返回此概率分布所基于的频率分布。

返回类型: FreqDist

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

class nltk.probability.MutableProbDist(prob_dist, samples, store_logs=True)[源代码]¶

基类：nltk.probability.ProbDistI

一种可变的概率分布，其概率很容易被修改。这只需复制现有probdist，将概率值存储在可变字典中，并提供更新方法。

logprob(sample)[源代码]¶

返回给定样本概率的底2对数。

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

update(sample, prob, log=True)[源代码]¶

更新给定样本的概率。这可能导致对象不再是有效的概率分布-用户必须确保更新样本概率，使所有样本的概率都在0和1之间，并且所有概率总和为1。

参数

sample (any) -- 更新概率的样本
prob (float) -- 新概率
log (bool) -- 概率已经记录了吗

class nltk.probability.ProbDistI[源代码]¶

基类：object

实验结果的概率分布。概率分布指定了一个实验有任何给定结果的可能性。例如，概率分布可用于预测文档中令牌具有给定类型的概率。形式上，概率分布可以定义为从样本到非负实数的函数映射，这样函数范围内每个数字的和为1.0。一 ProbDist 通常用来模拟实验的概率分布，用来产生频率分布。

SUM_TO_ONE = True¶: 如果此概率分布中样本的概率始终为1，则为真。

discount()[源代码]¶

返回计数平均折扣率：c*/c

返回类型: float

generate()[源代码]¶: 从这个概率分布中返回随机选择的样本。返回每个样本的概率 samp 等于 self.prob(samp) .

logprob(sample)[源代码]¶

返回给定样本概率的底2对数。

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

abstract max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

abstract prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

abstract samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

class nltk.probability.ProbabilisticMixIn(**kwargs)[源代码]¶

基类：object

将概率与其他类（树、规则等）关联在一起的类中的混合。使用 ProbabilisticMixIn 类，定义从现有类和ProbabilityMixin派生的新类。您需要为新类定义一个新的构造函数，它显式地调用两个父类的构造函数。例如：

>>> from nltk.probability import ProbabilisticMixIn
>>> class A:
...     def __init__(self, x, y): self.data = (x,y)
...
>>> class ProbabilisticA(A, ProbabilisticMixIn):
...     def __init__(self, x, y, **prob_kwarg):
...         A.__init__(self, x, y)
...         ProbabilisticMixIn.__init__(self, **prob_kwarg)

概率混合见文档 constructor<__init__> 有关它期望的参数的信息。

通常还应该重新定义字符串表示方法、比较方法和哈希方法。

logprob()[源代码]¶

返回 log(p) 在哪里 p 是与此对象关联的概率。

返回类型: float

prob()[源代码]¶

返回与此对象关联的概率。

返回类型: float

set_logprob(logprob)[源代码]¶

将与此对象关联的日志概率设置为 logprob . 即，将与此对象关联的概率设置为 2**(logprob) .

参数: logprob (float) -- 新的对数概率

set_prob(prob)[源代码]¶

将与此对象关联的概率设置为 prob .

参数: prob (float) -- 新概率

class nltk.probability.SimpleGoodTuringProbDist(freqdist, bins=None)[源代码]¶

基类：nltk.probability.ProbDistI

在对数空间下，用线性回归方法将频率与频率之间的单纯形probdist近似为一条直线。简单良好的图灵算法的详细信息可在以下位置找到：

良好的图灵平滑无泪”（盖尔和桑普森1995年），《定量语言学杂志》，第2卷，第217-237页。
“语音和语言处理（Jurafsky&Martin），第2版，第4.5章P103（Log（NC）=A+B*Log（C））”
http://www.grsampson.net/RGoodTur.html

给定一组对（Xi，Yi），其中XI表示频率，Yi表示频率的频率，我们希望最小化它们的平方变化。E（X）和E（Y）代表Xi和Yi的平均值。

斜率：b=sigma（（xi-e（x）（yi-e（y）））/sigma（（xi-e（x））（xi-e（x）））
截距：a=e（y）-b.e（x）

SUM_TO_ONE = False¶: 如果此概率分布中样本的概率始终为1，则为真。

check()[源代码]¶

discount()[源代码]¶: 此函数返回从已看到样本到未看到样本的概率转移总质量。

find_best_fit(r, nr)[源代码]¶: 使用简单的线性回归来根据计数和nr（计数）调整日志空间中的参数self.u slope和self.u intercept（在日志空间中工作以避免浮点下溢）。

freqdist()[源代码]¶

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回样本的概率。

参数: sample (str) -- 活动样本
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

smoothedNr(r)[源代码]¶

返回计数为r的样本数。

参数: r (int) -- 频率的数量。
返回类型: float

class nltk.probability.UniformProbDist(samples)[源代码]¶

基类：nltk.probability.ProbDistI

一种概率分布，它给给定集合中的每个样本分配相等的概率；给所有其它样本分配零概率。

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

class nltk.probability.WittenBellProbDist(freqdist, bins=None)[源代码]¶

基类：nltk.probability.ProbDistI

概率分布的维特-贝尔估计。这个分布通过使用只看到一次的事件数，将统一的概率质量分配给尚未看到的事件。为未知事件保留的概率质量等于 T / (N + T) 在哪里？ T 是观察到的事件类型的数量，以及 N 是观察到的事件总数。这相当于新类型事件发生的最大可能性估计。剩余的概率质量被贴现，所有的概率估计总和为1，得出：

p = T / Z (N + T) ，如果计数＝0

p = c / (N + T) ，否则

discount()[源代码]¶

返回计数平均折扣率：c*/c

返回类型: float

freqdist()[源代码]¶

max()[源代码]¶

以最大的概率返回样本。如果两个或多个样本的概率相同，则返回其中一个；返回的样本未定义。

返回类型: any

prob(sample)[源代码]¶

返回给定样本的概率。概率总是范围内的实数。 [0, 1] .

参数: sample (any) -- 应返回其概率的样本。
返回类型: float

samples()[源代码]¶

返回具有非零概率的所有样本的列表。使用 prob 找出每个样本的概率。

返回类型: list

nltk.probability.add_logs(logx, logy)[源代码]¶: 给定两个数字 logx = 日志（X） 和 logy = 原木（Y） 返回 log（x+y） . 从概念上讲，这与返回相同 log(2**(logx)+2**(logy)) 但实际的实现避免了直接计算可能导致的溢出错误。

nltk.probability.entropy(pdist)[源代码]¶

nltk.probability.log_likelihood(test_pdist, actual_pdist)[源代码]¶

nltk.probability.sum_logs(logs)[源代码]¶

`text` 模块¶

`toolbox` 模块¶

`translate` 模块¶

`tree` 模块¶

`treetransforms` 模块¶

`util` 模块¶

class nltk.util.Index(pairs)[源代码]¶: 基类：collections.defaultdict

nltk.util.acyclic_branches_depth_first(tree, children=<built-in function iter>, depth=-1, cut_mark=None, traversed=None)[源代码]¶

以深度优先顺序遍历树的节点，丢弃同一分支中的最终循环，但在不同的分支中保留重复路径。如果周期被截断，则添加CUT_MARK(定义时)。

第一个参数应该是树根；子节点应该是一个以树节点为参数并返回该节点的子节点的迭代器的函数。

仅捕获同一分支内的周期，但保留来自不同分支的周期：

>>> import nltk
>>> from nltk.util import acyclic_branches_depth_first as tree
>>> wn=nltk.corpus.wordnet
>>> from pprint import pprint
>>> pprint(tree(wn.synset('certified.a.01'), lambda s:s.also_sees(), cut_mark='...', depth=4))
[Synset('certified.a.01'),
 [Synset('authorized.a.01'),
  [Synset('lawful.a.01'),
   [Synset('legal.a.01'),
    "Cycle(Synset('lawful.a.01'),0,...)",
    [Synset('legitimate.a.01'), '...']],
   [Synset('straight.a.06'),
    [Synset('honest.a.01'), '...'],
    "Cycle(Synset('lawful.a.01'),0,...)"]],
  [Synset('legitimate.a.01'),
   "Cycle(Synset('authorized.a.01'),1,...)",
   [Synset('legal.a.01'),
    [Synset('lawful.a.01'), '...'],
    "Cycle(Synset('legitimate.a.01'),0,...)"],
   [Synset('valid.a.01'),
    "Cycle(Synset('legitimate.a.01'),0,...)",
    [Synset('reasonable.a.01'), '...']]],
  [Synset('official.a.01'), "Cycle(Synset('authorized.a.01'),1,...)"]],
 [Synset('documented.a.01')]]

nltk.util.acyclic_breadth_first(tree, children=<built-in function iter>, maxdepth=-1)[源代码]¶

以广度优先顺序遍历树的节点，丢弃最终循环。

第一个参数应该是树根；子节点应该是一个以树节点为参数并返回该节点的子节点的迭代器的函数。

nltk.util.acyclic_depth_first(tree, children=<built-in function iter>, depth=-1, cut_mark=None, traversed=None)[源代码]¶

以深度优先的顺序遍历树的节点，丢弃任何分支中的最终循环，如果循环被截断，则添加CUT_MARK(如果指定)。

第一个参数应该是树根；子节点应该是一个以树节点为参数并返回该节点的子节点的迭代器的函数。

捕获所有周期：

>>> import nltk
>>> from nltk.util import acyclic_depth_first as acyclic_tree
>>> wn=nltk.corpus.wordnet
>>> from pprint import pprint
>>> pprint(acyclic_tree(wn.synset('dog.n.01'), lambda s:s.hypernyms(),cut_mark='...'))
[Synset('dog.n.01'),
 [Synset('canine.n.02'),
  [Synset('carnivore.n.01'),
   [Synset('placental.n.01'),
    [Synset('mammal.n.01'),
     [Synset('vertebrate.n.01'),
      [Synset('chordate.n.01'),
       [Synset('animal.n.01'),
        [Synset('organism.n.01'),
         [Synset('living_thing.n.01'),
          [Synset('whole.n.02'),
           [Synset('object.n.01'),
            [Synset('physical_entity.n.01'),
             [Synset('entity.n.01')]]]]]]]]]]]]],
 [Synset('domestic_animal.n.01'), "Cycle(Synset('animal.n.01'),-3,...)"]]

nltk.util.acyclic_dic2tree(node, dic)[源代码]¶: 将非循环字典‘dic’(其中键是节点，值是子级列表)转换为适合pprint()的输出树，从根‘node’开始，子树作为嵌套列表。

nltk.util.bigrams(sequence, **kwargs)[源代码]¶

以迭代器的形式返回从一系列项生成的大内存。例如：

>>> from nltk.util import bigrams
>>> list(bigrams([1,2,3,4,5]))
[(1, 2), (2, 3), (3, 4), (4, 5)]

将bigrams用于此函数的列表版本。

参数: sequence (sequence or iter) -- 要转换为bigrams的源数据
返回类型: iter(tuple)

nltk.util.binary_search_file(file, key, cache={}, cacheDepth=- 1)[源代码]¶

用第一个字键返回文件中的行。使用二进制搜索算法搜索已排序的文件。

参数

file (file) -- 要搜索的文件。
key (str) -- 我们正在搜索的标识符。

nltk.util.breadth_first(tree, children=<built-in function iter>, maxdepth=-1)[源代码]¶: 以广度优先顺序遍历树的节点。(不检查循环。)第一个参数应该是树根；子节点应该是一个以树节点为参数并返回该节点的子节点的迭代器的函数。

nltk.util.choose(n, k)[源代码]¶

这个函数是一种快速计算二项式系数的方法，通常称为nck，即一次取k的n个事物的组合数。（https://en.wikipedia.org/wiki/binomial_coefficient）。

这就是 scipy.special.comb（）。 对于长整数计算，但此近似值更快，请参阅https://github.com/nltk/nltk/issues/1181

>>> choose(4, 2)
6
>>> choose(6, 2)
15

参数

n (int) -- 事物的数量。
r (int) -- 一件事被带走的次数。

nltk.util.clean_html(html)[源代码]¶

nltk.util.clean_url(url)[源代码]¶

nltk.util.elementtree_indent(elem, level=0)[源代码]¶

用于缩进元素树的递归函数。用于漂亮打印的元素接口。在elem上运行indent，然后以正常方式输出。

参数

elem (ElementTree._ElementInterface) -- 要缩进的元素。将被修改。
level (nonnegative integer) -- 此元素的缩进级别

返回类型

ElementTree._ElementInterface

返回

缩进以反映其结构的元素的内容

nltk.util.everygrams(sequence, min_len=1, max_len=- 1, pad_left=False, pad_right=False, **kwargs)[源代码]¶

以迭代器的形式返回从一系列项生成的所有可能的ngrams。

>>> sent = 'a b c'.split()

新版本的输出为每个图形。

>>> list(everygrams(sent))
[('a',), ('a', 'b'), ('a', 'b', 'c'), ('b',), ('b', 'c'), ('c',)]

旧版本输出，适用于每个工作台。

>>> sorted(everygrams(sent), key=len)
[('a',), ('b',), ('c',), ('a', 'b'), ('b', 'c'), ('a', 'b', 'c')]

>>> list(everygrams(sent, max_len=2))
[('a',), ('a', 'b'), ('b',), ('b', 'c'), ('c',)]

参数

sequence (sequence or iter) -- 要转换为ngram的源数据。如果未提供max_len，则此序列将加载到内存中
min_len (int) -- NGRAMS的最小长度，aka。n-gram阶数/n gram阶数
max_len (int) -- NGRAMS的最大长度（默认设置为序列长度）
pad_left (bool) -- NGRAMS是否应留有衬垫
pad_right (bool) -- NGRAMS是否应正确填充

返回类型

iter(tuple)

nltk.util.filestring(f)[源代码]¶

nltk.util.flatten(*args)[源代码]¶

把清单弄平。

>>> from nltk.util import flatten
>>> flatten(1, 2, ['b', 'a' , ['c', 'd']], 3)
[1, 2, 'b', 'a', 'c', 'd', 3]

参数: args -- 将项目和列表合并为一个列表
返回类型: list

nltk.util.guess_encoding(data)[源代码]¶

给定一个字节字符串，尝试对其进行解码。尝试标准的“utf8”和“Latin-1”编码，以及从区域设置信息中收集到的一些编码。

呼叫程序 must 第一次呼叫：

locale.setlocale(locale.LC_ALL, '')

如果成功，它会返回 (decoded_unicode, successful_encoding) . 如果失败，它会引发 UnicodeError .

nltk.util.in_idle()[源代码]¶

如果此函数在空闲状态下运行，则返回true。在空闲状态下运行的tkinter程序不应调用 Tk.mainloop ；因此，应使用此函数将所有调用 Tk.mainloop .

警告: 此功能通过检查 sys.stdin . 如果用户已修改 sys.stdin ，则可能返回不正确的结果。
返回类型: bool

nltk.util.invert_dict(d)[源代码]¶

nltk.util.invert_graph(graph)[源代码]¶

反转有向图。

参数: graph (dict(set)) -- 用集合字典表示的图
返回: 倒转图
返回类型: dict(set)

nltk.util.ngrams(sequence, n, **kwargs)[源代码]¶

以迭代器的形式返回从一系列项生成的ngrams。例如：

>>> from nltk.util import ngrams
>>> list(ngrams([1,2,3,4,5], 3))
[(1, 2, 3), (2, 3, 4), (3, 4, 5)]

使用列表换行以获得此函数的列表版本。将Pad_Left或Pad_Right设置为真，以获得额外的Ngrams：

>>> list(ngrams([1,2,3,4,5], 2, pad_right=True))
[(1, 2), (2, 3), (3, 4), (4, 5), (5, None)]
>>> list(ngrams([1,2,3,4,5], 2, pad_right=True, right_pad_symbol='</s>'))
[(1, 2), (2, 3), (3, 4), (4, 5), (5, '</s>')]
>>> list(ngrams([1,2,3,4,5], 2, pad_left=True, left_pad_symbol='<s>'))
[('<s>', 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> list(ngrams([1,2,3,4,5], 2, pad_left=True, pad_right=True, left_pad_symbol='<s>', right_pad_symbol='</s>'))
[('<s>', 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, '</s>')]

参数

sequence (sequence or iter) -- 要转换为ngrams的源数据
n (int) -- NGRAMS的等级
pad_left (bool) -- NGRAMS是否应留有衬垫
pad_right (bool) -- NGRAMS是否应正确填充
left_pad_symbol (any) -- 用于左填充的符号（默认为无）
right_pad_symbol (any) -- 用于右填充的符号（默认为无）

返回类型

sequence or iter

nltk.util.pad_sequence(sequence, n, pad_left=False, pad_right=False, left_pad_symbol=None, right_pad_symbol=None)[源代码]¶

返回在提取ngram之前填充的项序列。

>>> list(pad_sequence([1,2,3,4,5], 2, pad_left=True, pad_right=True, left_pad_symbol='<s>', right_pad_symbol='</s>'))
['<s>', 1, 2, 3, 4, 5, '</s>']
>>> list(pad_sequence([1,2,3,4,5], 2, pad_left=True, left_pad_symbol='<s>'))
['<s>', 1, 2, 3, 4, 5]
>>> list(pad_sequence([1,2,3,4,5], 2, pad_right=True, right_pad_symbol='</s>'))
[1, 2, 3, 4, 5, '</s>']

参数

sequence (sequence or iter) -- 要填充的源数据
n (int) -- NGRAMS的等级
pad_left (bool) -- NGRAMS是否应留有衬垫
pad_right (bool) -- NGRAMS是否应正确填充
left_pad_symbol (any) -- 用于左填充的符号（默认为无）
right_pad_symbol (any) -- 用于右填充的符号（默认为无）

返回类型

sequence or iter

nltk.util.pairwise(iterable)[源代码]¶: s->（s0，s1），（s1，s2），（s2，s3）。。。

nltk.util.parallelize_preprocess(func, iterator, processes, progress_bar=False)[源代码]¶

nltk.util.pr(data, start=0, end=None)[源代码]¶

漂亮地打印一系列数据项

参数

data (sequence or iter) -- 要打印的数据流
start (int) -- 起始位置
end (int) -- 结束位置

nltk.util.print_string(s, width=70)[源代码]¶

漂亮地打印一个字符串，在空白处断行

参数

s (str) -- 要打印的字符串，由单词和空格组成
width (int) -- 显示宽度

nltk.util.re_show(regexp, string, left='{', right='}')[源代码]¶

返回一个字符串，其中标记围绕匹配的子字符串。搜索str以查找匹配的子字符串 regexp 用大括号把火柴包起来。这便于学习正则表达式。

参数

regexp (str) -- 正则表达式。
string (str) -- 正在匹配的字符串。
left (str) -- 左分隔符（打印在匹配的子字符串之前）
right (str) -- 右分隔符（在匹配的子字符串后打印）

返回类型

str

nltk.util.set_proxy(proxy, user=None, password='')[源代码]¶

为python设置HTTP代理以通过下载。

如果 proxy 如果为“无”，则尝试从环境或系统设置中设置代理。

参数

proxy -- 要使用的HTTP代理服务器。例如：“http://proxy.example.com:3128/”
user -- 要进行身份验证的用户名。使用“无”禁用身份验证。
password -- 要进行身份验证的密码。

nltk.util.skipgrams(sequence, n, k, **kwargs)[源代码]¶

以迭代器的形式返回从一系列项生成的所有可能的skipgrams。skipgrams是允许跳过令牌的ngrams。请参阅http://homepages.inf.ed.ac.uk/ballison/pdf/lrec_skipgrams.pdf

>>> sent = "Insurgents killed in ongoing fighting".split()
>>> list(skipgrams(sent, 2, 2))
[('Insurgents', 'killed'), ('Insurgents', 'in'), ('Insurgents', 'ongoing'), ('killed', 'in'), ('killed', 'ongoing'), ('killed', 'fighting'), ('in', 'ongoing'), ('in', 'fighting'), ('ongoing', 'fighting')]
>>> list(skipgrams(sent, 3, 2))
[('Insurgents', 'killed', 'in'), ('Insurgents', 'killed', 'ongoing'), ('Insurgents', 'killed', 'fighting'), ('Insurgents', 'in', 'ongoing'), ('Insurgents', 'in', 'fighting'), ('Insurgents', 'ongoing', 'fighting'), ('killed', 'in', 'ongoing'), ('killed', 'in', 'fighting'), ('killed', 'ongoing', 'fighting'), ('in', 'ongoing', 'fighting')]

参数

sequence (sequence or iter) -- 要转换为三角函数的源数据
n (int) -- NGRAMS的等级
k (int) -- 跳跃距离

返回类型

iter(tuple)

nltk.util.tokenwrap(tokens, separator=' ', width=70)[源代码]¶

漂亮地打印文本标记列表，在空白处断行

参数

tokens (list) -- 要打印的令牌
separator (str) -- 用于分隔标记的字符串
width (int) -- 显示宽度（默认值=70）

nltk.util.transitive_closure(graph, reflexive=False)[源代码]¶

计算有向图的传递闭包，可以选择自反传递闭包。

该算法是对ioannidis&ramakrishnan（1998）“高效传递闭包算法”的“标记算法”的一个微小修改。

参数

graph (dict(set)) -- 初始图，表示为集合字典
reflexive (bool) -- 如果设置，也使闭包具有反身性

返回类型

dict(set)

nltk.util.trigrams(sequence, **kwargs)[源代码]¶

以迭代器的形式返回从一系列项生成的三角图。例如：

>>> from nltk.util import trigrams
>>> list(trigrams([1,2,3,4,5]))
[(1, 2, 3), (2, 3, 4), (3, 4, 5)]

使用三角函数作为此函数的列表版本。

参数: sequence (sequence or iter) -- 要转换为三角函数的源数据
返回类型: iter(tuple)

nltk.util.unique_list(xs)[源代码]¶

nltk.util.unweighted_minimum_spanning_tree(tree, children=<built-in function iter>)[源代码]¶

通过按广度优先顺序遍历树的节点，丢弃最终循环，输出未加权图的最小生成树(MST)。

第一个参数应该是树根；子节点应该是一个以树节点为参数并返回该节点的子节点的迭代器的函数。

>>> import nltk
>>> from nltk.util import unweighted_minimum_spanning_tree as mst
>>> wn=nltk.corpus.wordnet
>>> from pprint import pprint
>>> pprint(mst(wn.synset('bound.a.01'), lambda s:s.also_sees()))
[Synset('bound.a.01'),
 [Synset('unfree.a.02'),
  [Synset('confined.a.02')],
  [Synset('dependent.a.01')],
  [Synset('restricted.a.01'), [Synset('classified.a.02')]]]]

nltk.util.usage(obj, selfname='self')[源代码]¶

NLTK封装¶

`nltk` 包裹¶

`collocations` 模块¶

`data` 模块¶

`downloader` 模块¶

`featstruct` 模块¶

轻量级特征结构¶

`grammar` 模块¶

`help` 模块¶

`probability` 模块¶

`text` 模块¶

`toolbox` 模块¶

`translate` 模块¶

`tree` 模块¶

`treetransforms` 模块¶

`util` 模块¶

`wsd` 模块¶

子包¶

Table of Contents

搜索

NLTK封装¶

nltk 包裹¶

collocations 模块¶

data 模块¶

downloader 模块¶

featstruct 模块¶

轻量级特征结构¶

grammar 模块¶

help 模块¶

probability 模块¶

text 模块¶

toolbox 模块¶

translate 模块¶

tree 模块¶

treetransforms 模块¶

util 模块¶

wsd 模块¶

子包¶

Table of Contents

搜索

`nltk` 包裹¶

`collocations` 模块¶

`data` 模块¶

`downloader` 模块¶

`featstruct` 模块¶

`grammar` 模块¶

`help` 模块¶

`probability` 模块¶

`text` 模块¶

`toolbox` 模块¶

`translate` 模块¶

`tree` 模块¶

`treetransforms` 模块¶

`util` 模块¶

`wsd` 模块¶