摘要：问题描述：是否可以在 NLTK 中使用斯坦福解析器？（我不是在谈论斯坦福 POS。）解决方案 1：请注意，此答案适用于 NLTK v 3.0，而不适用于较新版本。当然，请尝试使用 Python 进行以下操作：import os from nltk.parse import stanford os.enviro...

问题描述：

是否可以在 NLTK 中使用斯坦福解析器？（我不是在谈论斯坦福 POS。）

解决方案 1：

请注意，此答案适用于 NLTK v 3.0，而不适用于较新版本。

当然，请尝试使用 Python 进行以下操作：

import os
from nltk.parse import stanford
os.environ['STANFORD_PARSER'] = '/path/to/standford/jars'
os.environ['STANFORD_MODELS'] = '/path/to/standford/jars'

parser = stanford.StanfordParser(model_path="/location/of/the/englishPCFG.ser.gz")
sentences = parser.raw_parse_sents(("Hello, My name is Melroy.", "What is your name?"))
print sentences

# GUI
for line in sentences:
    for sentence in line:
        sentence.draw()

输出：

[Tree('ROOT', [Tree('S', [Tree('INTJ', [Tree('UH', ['你好'])]), Tree(',', [',']), Tree('NP', [Tree('PRP$', ['我的']), Tree('NN', ['名字'])]), Tree('VP', [Tree('VBZ', ['是']), Tree('ADJP', [Tree('JJ', ['Melroy'])])]), Tree('.', ['.'])])]), Tree('ROOT', [Tree('SBARQ', [Tree('WHNP', [Tree('WP', ['什么'])]), Tree('SQ', [Tree('VBZ', ['是']), Tree('NP', [Tree('PRP$', ['你的']), Tree('NN', ['name'])])]), Tree('.', ['?'])])])]

注 1：
在此示例中，解析器和模型 jar 都位于同一个文件夹中。

注2：

斯坦福解析器的文件名是：stanford-parser.jar
斯坦福模型的文件名是：stanford-parser-xxx-models.jar

注 3： englishPCFG.ser.gz 文件可在models.jar 文件 (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz)中
找到。请使用存档管理器“解压缩”models.jar 文件。

注意 4：
确保您使用的是 Java JRE（运行时环境）1.8，也称为 Oracle JDK 8。否则，您将得到：不支持的 major.minor 版本 52.0。

安装

从https://github.com/nltk/nltk下载 NLTK v3 。并安装 NLTK：

sudo python setup.py 安装

您可以使用 NLTK 下载器获取 Stanford Parser，使用 Python：

import nltk
nltk.download()

试试我的例子！（不要忘记更改 jar 路径并将模型路径更改为 ser.gz 位置）

或者：

下载并安装 NLTK v3，与上述相同。
从以下网址下载最新版本（当前版本文件名为 stanford-parser-full-2015-01-29.zip）：
http ://nlp.stanford.edu/software/lex-parser.shtml#Download
解压缩 standford-parser-full-20xx-xx-xx.zip。
创建一个新文件夹（在我的示例中为“jars”）。将提取的文件放入此 jar 文件夹中：stanford-parser-3.xx-models.jar 和 stanford-parser.jar。

如上所示，您可以使用环境变量（STANFORD_PARSER 和 STANFORD_MODELS）指向此“jars”文件夹。我使用的是 Linux，因此如果您使用 Windows，请使用类似以下内容：C://folder//jars。

使用档案管理器 (7zip) 打开 stanford-parser-3.xx-models.jar。
浏览 jar 文件；edu/stanford/nlp/models/lexparser。再次提取名为“englishPCFG.ser.gz”的文件。记住提取此 ser.gz 文件的位置。
创建 StanfordParser 实例时，您可以提供模型路径作为参数。这是模型的完整路径，在我们的例子中是 /location/of/englishPCFG.ser.gz。
试试我的例子！（不要忘记更改 jar 路径并将模型路径更改为 ser.gz 位置）

解决方案 2：

弃用的答案

以下答案已被弃用，请使用https://stackoverflow.com/a/51981566/610569上针对 NLTK v3.3 及以上版本的解决方案。

已编辑

注意：以下答案仅适用于：

NLTK 版本 >=3.2.4
斯坦福工具自 2015-04-20 开始编制
Python 2.7、3.4 和 3.5（Python 3.6 尚未得到官方支持）

由于这两种工具变化都很快，API 可能在 3-6 个月后看起来大不相同。请将以下答案视为暂时的，而不是永久的修复。

请始终参考https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software以获取有关如何使用 NLTK 连接斯坦福 NLP 工具的最新说明！！

总结

cd $HOME

# Update / Install NLTK
pip install -U nltk

# Download the Stanford NLP tools
wget http://nlp.stanford.edu/software/stanford-ner-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-postagger-full-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-parser-full-2015-04-20.zip
# Extract the zip file.
unzip stanford-ner-2015-04-20.zip 
unzip stanford-parser-full-2015-04-20.zip 
unzip stanford-postagger-full-2015-04-20.zip


export STANFORDTOOLSDIR=$HOME

export CLASSPATH=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/stanford-postagger.jar:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/stanford-ner.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

export STANFORD_MODELS=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/models:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/classifiers

然后：

>>> from nltk.tag.stanford import StanfordPOSTagger
>>> st = StanfordPOSTagger('english-bidirectional-distsim.tagger')
>>> st.tag('What is the airspeed of an unladen swallow ?'.split())
[(u'What', u'WP'), (u'is', u'VBZ'), (u'the', u'DT'), (u'airspeed', u'NN'), (u'of', u'IN'), (u'an', u'DT'), (u'unladen', u'JJ'), (u'swallow', u'VB'), (u'?', u'.')]

>>> from nltk.tag import StanfordNERTagger
>>> st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz') 
>>> st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
[(u'Rami', u'PERSON'), (u'Eid', u'PERSON'), (u'is', u'O'), (u'studying', u'O'), (u'at', u'O'), (u'Stony', u'ORGANIZATION'), (u'Brook', u'ORGANIZATION'), (u'University', u'ORGANIZATION'), (u'in', u'O'), (u'NY', u'O')]


>>> from nltk.parse.stanford import StanfordParser
>>> parser=StanfordParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> list(parser.raw_parse("the quick brown fox jumps over the lazy dog"))
[Tree('ROOT', [Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['quick']), Tree('JJ', ['brown']), Tree('NN', ['fox'])]), Tree('NP', [Tree('NP', [Tree('NNS', ['jumps'])]), Tree('PP', [Tree('IN', ['over']), Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['lazy']), Tree('NN', ['dog'])])])])])])]

>>> from nltk.parse.stanford import StanfordDependencyParser
>>> dep_parser=StanfordDependencyParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> print [parse.tree() for parse in dep_parser.raw_parse("The quick brown fox jumps over the lazy dog.")]
[Tree('jumps', [Tree('fox', ['The', 'quick', 'brown']), Tree('dog', ['over', 'the', 'lazy'])])]

长话短说：

首先，必须注意的是，斯坦福 NLP 工具是用 Java 编写的，而NLTK 是用 Python 编写的。NLTK 与该工具交互的方式是通过命令行界面调用 Java 工具。

其次，NLTK自 3.1 版以来，斯坦福 NLP 工具的 API 发生了很大变化。因此建议将 NLTK 包更新到 v3.1。

第三，NLTK斯坦福 NLP 工具的 API 围绕各个 NLP 工具，例如斯坦福 POS 标记器、斯坦福 NER 标记器、斯坦福解析器。

对于 POS 和 NER 标记器，它不会环绕斯坦福核心 NLP 包。

对于斯坦福解析器来说，这是一个特殊情况，它同时包含斯坦福解析器和斯坦福核心 NLP（就我个人而言，我没有使用 NLTK 来使用后者，我宁愿遵循 @dimazest 在http://www.eecs.qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html上的演示）

请注意，从 NLTK v3.1 开始，STANFORD_JAR和STANFORD_PARSER变量已被弃用，不再使用

更长时间内：

步骤 1

假设您已经在操作系统上正确安装了 Java。

现在，安装/更新您的 NLTK 版本（请参阅http://www.nltk.org/install.html）：

使用 pip：sudo pip install -U nltk
Debian 发行版（使用 apt-get）：sudo apt-get install python-nltk

对于 Windows（使用 32 位二进制安装）：

安装 Python 3.4：http://www.python.org/downloads/（避免使用 64 位版本）
安装Numpy（可选）： http: //sourceforge.net/projects/numpy/files/NumPy/（指定pythnon3.4的版本）
安装 NLTK：http://pypi.python.org/pypi/nltk
测试安装：开始>Python34，然后输入 import nltk

（为什么不是 64 位？请参阅https://github.com/nltk/nltk/issues/1079）

然后出于偏执，重新检查nltkpython 中的版本：

from __future__ import print_function
import nltk
print(nltk.__version__)

或者在命令行上：

python3 -c "import nltk; print(nltk.__version__)"

确保您看到的3.1是输出。

如果更加担心，请检查你最喜欢的斯坦福 NLP 工具 API 是否可用：

from nltk.parse.stanford import StanfordParser
from nltk.parse.stanford import StanfordDependencyParser
from nltk.parse.stanford import StanfordNeuralDependencyParser
from nltk.tag.stanford import StanfordPOSTagger, StanfordNERTagger
from nltk.tokenize.stanford import StanfordTokenizer

（注意：上述导入仅确保您使用包含这些 API 的正确 NLTK 版本。导入时未看到错误并不意味着您已成功配置 NLTK API 以使用斯坦福工具）

步骤 2

现在您已确认拥有包含必要 Stanford NLP 工具接口的正确版本的 NLTK。您需要下载并提取所有必要的 Stanford NLP 工具。

TL;DR，在Unix中：

cd $HOME

# Download the Stanford NLP tools
wget http://nlp.stanford.edu/software/stanford-ner-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-postagger-full-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-parser-full-2015-04-20.zip
# Extract the zip file.
unzip stanford-ner-2015-04-20.zip 
unzip stanford-parser-full-2015-04-20.zip 
unzip stanford-postagger-full-2015-04-20.zip

在Windows / Mac中：

从http://nlp.stanford.edu/software/lex-parser.shtml#Download下载并解压解析器
从http://nlp.stanford.edu/software/tagger.shtml#Download下载并解压完整版标记器
从http://nlp.stanford.edu/software/CRF-NER.shtml#Download下载并解压 NER 标记器

步骤 3

设置环境变量，以便 NLTK 可以自动找到相关文件路径。您必须设置以下变量：

将适当的斯坦福 NLP.jar文件添加到 CLASSPATH环境变量中。

+ 例如对于 NER，它将是`stanford-ner-2015-04-20/stanford-ner.jar`
+ 例如对于 POS，它将是`stanford-postagger-full-2015-04-20/stanford-postagger.jar`
+ 例如对于解析器，它将是`stanford-parser-full-2015-04-20/stanford-parser.jar`解析器模型 jar 文件，`stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar`

将适当的模型目录添加到STANFORD_MODELS变量中（即可找到保存预先训练的模型的目录）

+ 例如对于 NER，它将在`stanford-ner-2015-04-20/classifiers/`
+ 例如对于 POS，它将位于`stanford-postagger-full-2015-04-20/models/`
+ 例如对于解析器，不会有模型目录。

在代码中，可以看到它STANFORD_MODELS在附加模型名称之前搜索目录。还可以看到，API 还会自动尝试在 OS 环境中搜索“CLASSPATH ”

请注意，从 NLTK v3.1 开始，STANFORD_JAR变量已弃用，不再使用。以下 Stackoverflow 问题中找到的代码片段可能不起作用：

斯坦福依赖解析器设置和 NLTK
nltk 接口到斯坦福解析器
将 stanford pos tagger 导入 nltk 时遇到问题
Python Nltk 中的斯坦福实体识别器（无大小写）
如何使用 Stanford NLP Tagger 和 NLTK 提高速度
我如何获取 stanford NLTK python 模块？
斯坦福解析器和 NLTK 窗口
斯坦福命名实体识别器 (NER) 与 NLTK 的功能
使用 NLTK 的斯坦福解析器产生空输出
使用 NLTK 中的 Stanford NER Tagger 提取人员和组织列表
在 NLTK Python 中使用 Stanford POS Tagger 时出错

Ubuntu 上步骤 3 的 TL;DR

export STANFORDTOOLSDIR=/home/path/to/stanford/tools/

export CLASSPATH=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/stanford-postagger.jar:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/stanford-ner.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

export STANFORD_MODELS=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/models:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/classifiers

（对于 Windows：有关设置环境变量的说明，请参阅https://stackoverflow.com/a/17176423/610569 ）

您必须在启动 python 之前设置上述变量，然后：

>>> from nltk.tag.stanford import StanfordPOSTagger
>>> st = StanfordPOSTagger('english-bidirectional-distsim.tagger')
>>> st.tag('What is the airspeed of an unladen swallow ?'.split())
[(u'What', u'WP'), (u'is', u'VBZ'), (u'the', u'DT'), (u'airspeed', u'NN'), (u'of', u'IN'), (u'an', u'DT'), (u'unladen', u'JJ'), (u'swallow', u'VB'), (u'?', u'.')]

>>> from nltk.tag import StanfordNERTagger
>>> st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz') 
>>> st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
[(u'Rami', u'PERSON'), (u'Eid', u'PERSON'), (u'is', u'O'), (u'studying', u'O'), (u'at', u'O'), (u'Stony', u'ORGANIZATION'), (u'Brook', u'ORGANIZATION'), (u'University', u'ORGANIZATION'), (u'in', u'O'), (u'NY', u'O')]


>>> from nltk.parse.stanford import StanfordParser
>>> parser=StanfordParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> list(parser.raw_parse("the quick brown fox jumps over the lazy dog"))
[Tree('ROOT', [Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['quick']), Tree('JJ', ['brown']), Tree('NN', ['fox'])]), Tree('NP', [Tree('NP', [Tree('NNS', ['jumps'])]), Tree('PP', [Tree('IN', ['over']), Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['lazy']), Tree('NN', ['dog'])])])])])])]

.jar或者，您可以尝试在 python 中添加环境变量，正如前面的答案所建议的那样，但您也可以直接告诉解析器/标记器初始化为您保存文件和模型的直接路径。

如果您使用以下方法，则无需设置环境变量，但是当 API 更改其参数名称时，您需要进行相应更改。这就是为什么设置环境变量比修改 Python 代码以适应 NLTK 版本更为可取的原因。

例如（不设置任何环境变量）：

# POS tagging:

from nltk.tag import StanfordPOSTagger

stanford_pos_dir = '/home/alvas/stanford-postagger-full-2015-04-20/'
eng_model_filename= stanford_pos_dir + 'models/english-left3words-distsim.tagger'
my_path_to_jar= stanford_pos_dir + 'stanford-postagger.jar'

st = StanfordPOSTagger(model_filename=eng_model_filename, path_to_jar=my_path_to_jar) 
st.tag('What is the airspeed of an unladen swallow ?'.split())


# NER Tagging:
from nltk.tag import StanfordNERTagger

stanford_ner_dir = '/home/alvas/stanford-ner/'
eng_model_filename= stanford_ner_dir + 'classifiers/english.all.3class.distsim.crf.ser.gz'
my_path_to_jar= stanford_ner_dir + 'stanford-ner.jar'

st = StanfordNERTagger(model_filename=eng_model_filename, path_to_jar=my_path_to_jar) 
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())

# Parsing:
from nltk.parse.stanford import StanfordParser

stanford_parser_dir = '/home/alvas/stanford-parser/'
eng_model_path = stanford_parser_dir  + "edu/stanford/nlp/models/lexparser/englishRNN.ser.gz"
my_path_to_models_jar = stanford_parser_dir  + "stanford-parser-3.5.2-models.jar"
my_path_to_jar = stanford_parser_dir  + "stanford-parser.jar"

parser=StanfordParser(model_path=eng_model_path, path_to_models_jar=my_path_to_models_jar, path_to_jar=my_path_to_jar)

解决方案 3：

从 NLTK v3.3 开始，用户应避免使用的斯坦福 NER 或 POS 标记器nltk.tag，并避免使用的斯坦福标记器/分割器nltk.tokenize。

而是使用新的nltk.parse.corenlp.CoreNLPParserAPI。

请参阅https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK

（为了避免只给出链接答案，我在下面粘贴了来自 NLTK github wiki 的文档）

首先，更新你的 NLTK

pip3 install -U nltk # Make sure is >=3.3

然后下载必要的 CoreNLP 包：

cd ~
wget http://nlp.stanford.edu/software/stanford-corenlp-full-2018-02-27.zip
unzip stanford-corenlp-full-2018-02-27.zip
cd stanford-corenlp-full-2018-02-27

# Get the Chinese model 
wget http://nlp.stanford.edu/software/stanford-chinese-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-chinese.properties 

# Get the Arabic model
wget http://nlp.stanford.edu/software/stanford-arabic-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-arabic.properties 

# Get the French model
wget http://nlp.stanford.edu/software/stanford-french-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-french.properties 

# Get the German model
wget http://nlp.stanford.edu/software/stanford-german-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-german.properties 


# Get the Spanish model
wget http://nlp.stanford.edu/software/stanford-spanish-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-spanish.properties

英语

仍然在stanford-corenlp-full-2018-02-27目录中，启动服务器：

java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \n-preload tokenize,ssplit,pos,lemma,ner,parse,depparse \n-status_port 9000 -port 9000 -timeout 15000 &

然后在 Python 中：

>>> from nltk.parse import CoreNLPParser

# Lexical Parser
>>> parser = CoreNLPParser(url='http://localhost:9000')

# Parse tokenized text.
>>> list(parser.parse('What is the airspeed of an unladen swallow ?'.split()))
[Tree('ROOT', [Tree('SBARQ', [Tree('WHNP', [Tree('WP', ['What'])]), Tree('SQ', [Tree('VBZ', ['is']), Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('NN', ['airspeed'])]), Tree('PP', [Tree('IN', ['of']), Tree('NP', [Tree('DT', ['an']), Tree('JJ', ['unladen'])])]), Tree('S', [Tree('VP', [Tree('VB', ['swallow'])])])])]), Tree('.', ['?'])])])]

# Parse raw string.
>>> list(parser.raw_parse('What is the airspeed of an unladen swallow ?'))
[Tree('ROOT', [Tree('SBARQ', [Tree('WHNP', [Tree('WP', ['What'])]), Tree('SQ', [Tree('VBZ', ['is']), Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('NN', ['airspeed'])]), Tree('PP', [Tree('IN', ['of']), Tree('NP', [Tree('DT', ['an']), Tree('JJ', ['unladen'])])]), Tree('S', [Tree('VP', [Tree('VB', ['swallow'])])])])]), Tree('.', ['?'])])])]

# Neural Dependency Parser
>>> from nltk.parse.corenlp import CoreNLPDependencyParser
>>> dep_parser = CoreNLPDependencyParser(url='http://localhost:9000')
>>> parses = dep_parser.parse('What is the airspeed of an unladen swallow ?'.split())
>>> [[(governor, dep, dependent) for governor, dep, dependent in parse.triples()] for parse in parses]
[[(('What', 'WP'), 'cop', ('is', 'VBZ')), (('What', 'WP'), 'nsubj', ('airspeed', 'NN')), (('airspeed', 'NN'), 'det', ('the', 'DT')), (('airspeed', 'NN'), 'nmod', ('swallow', 'VB')), (('swallow', 'VB'), 'case', ('of', 'IN')), (('swallow', 'VB'), 'det', ('an', 'DT')), (('swallow', 'VB'), 'amod', ('unladen', 'JJ')), (('What', 'WP'), 'punct', ('?', '.'))]]


# Tokenizer
>>> parser = CoreNLPParser(url='http://localhost:9000')
>>> list(parser.tokenize('What is the airspeed of an unladen swallow?'))
['What', 'is', 'the', 'airspeed', 'of', 'an', 'unladen', 'swallow', '?']

# POS Tagger
>>> pos_tagger = CoreNLPParser(url='http://localhost:9000', tagtype='pos')
>>> list(pos_tagger.tag('What is the airspeed of an unladen swallow ?'.split()))
[('What', 'WP'), ('is', 'VBZ'), ('the', 'DT'), ('airspeed', 'NN'), ('of', 'IN'), ('an', 'DT'), ('unladen', 'JJ'), ('swallow', 'VB'), ('?', '.')]

# NER Tagger
>>> ner_tagger = CoreNLPParser(url='http://localhost:9000', tagtype='ner')
>>> list(ner_tagger.tag(('Rami Eid is studying at Stony Brook University in NY'.split())))
[('Rami', 'PERSON'), ('Eid', 'PERSON'), ('is', 'O'), ('studying', 'O'), ('at', 'O'), ('Stony', 'ORGANIZATION'), ('Brook', 'ORGANIZATION'), ('University', 'ORGANIZATION'), ('in', 'O'), ('NY', 'STATE_OR_PROVINCE')]

中国人

以稍有不同的方式启动服务器，仍然从`stanford-corenlp-full-2018-02-27 目录启动：

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \n-serverProperties StanfordCoreNLP-chinese.properties \n-preload tokenize,ssplit,pos,lemma,ner,parse \n-status_port 9001  -port 9001 -timeout 15000

在 Python 中：

>>> parser = CoreNLPParser('http://localhost:9001')
>>> list(parser.tokenize(u'我家没有电脑。'))
['我家', '没有', '电脑', '。']

>>> list(parser.parse(parser.tokenize(u'我家没有电脑。')))
[Tree('ROOT', [Tree('IP', [Tree('IP', [Tree('NP', [Tree('NN', ['我家'])]), Tree('VP', [Tree('VE', ['没有']), Tree('NP', [Tree('NN', ['电脑'])])])]), Tree('PU', ['。'])])])]

阿拉伯

启动服务器：

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \n-serverProperties StanfordCoreNLP-arabic.properties \n-preload tokenize,ssplit,pos,parse \n-status_port 9005  -port 9005 -timeout 15000

在 Python 中：

>>> from nltk.parse import CoreNLPParser
>>> parser = CoreNLPParser('http://localhost:9005')
>>> text = u'انا حامل'

# Parser.
>>> parser.raw_parse(text)
<list_iterator object at 0x7f0d894c9940>
>>> list(parser.raw_parse(text))
[Tree('ROOT', [Tree('S', [Tree('NP', [Tree('PRP', ['انا'])]), Tree('NP', [Tree('NN', ['حامل'])])])])]
>>> list(parser.parse(parser.tokenize(text)))
[Tree('ROOT', [Tree('S', [Tree('NP', [Tree('PRP', ['انا'])]), Tree('NP', [Tree('NN', ['حامل'])])])])]

# Tokenizer / Segmenter.
>>> list(parser.tokenize(text))
['انا', 'حامل']

# POS tagg
>>> pos_tagger = CoreNLPParser('http://localhost:9005', tagtype='pos')
>>> list(pos_tagger.tag(parser.tokenize(text)))
[('انا', 'PRP'), ('حامل', 'NN')]


# NER tag
>>> ner_tagger = CoreNLPParser('http://localhost:9005', tagtype='ner')
>>> list(ner_tagger.tag(parser.tokenize(text)))
[('انا', 'O'), ('حامل', 'O')]

法语

启动服务器：

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \n-serverProperties StanfordCoreNLP-french.properties \n-preload tokenize,ssplit,pos,parse \n-status_port 9004  -port 9004 -timeout 15000

在 Python 中：

>>> parser = CoreNLPParser('http://localhost:9004')
>>> list(parser.parse('Je suis enceinte'.split()))
[Tree('ROOT', [Tree('SENT', [Tree('NP', [Tree('PRON', ['Je']), Tree('VERB', ['suis']), Tree('AP', [Tree('ADJ', ['enceinte'])])])])])]
>>> pos_tagger = CoreNLPParser('http://localhost:9004', tagtype='pos')
>>> pos_tagger.tag('Je suis enceinte'.split())
[('Je', 'PRON'), ('suis', 'VERB'), ('enceinte', 'ADJ')]

德语

启动服务器：

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \n-serverProperties StanfordCoreNLP-german.properties \n-preload tokenize,ssplit,pos,ner,parse \n-status_port 9002  -port 9002 -timeout 15000

在 Python 中：

>>> parser = CoreNLPParser('http://localhost:9002')
>>> list(parser.raw_parse('Ich bin schwanger'))
[Tree('ROOT', [Tree('NUR', [Tree('S', [Tree('PPER', ['Ich']), Tree('VAFIN', ['bin']), Tree('AP', [Tree('ADJD', ['schwanger'])])])])])]
>>> list(parser.parse('Ich bin schwanger'.split()))
[Tree('ROOT', [Tree('NUR', [Tree('S', [Tree('PPER', ['Ich']), Tree('VAFIN', ['bin']), Tree('AP', [Tree('ADJD', ['schwanger'])])])])])]


>>> pos_tagger = CoreNLPParser('http://localhost:9002', tagtype='pos')
>>> pos_tagger.tag('Ich bin schwanger'.split())
[('Ich', 'PPER'), ('bin', 'VAFIN'), ('schwanger', 'ADJD')]

>>> pos_tagger = CoreNLPParser('http://localhost:9002', tagtype='pos')
>>> pos_tagger.tag('Ich bin schwanger'.split())
[('Ich', 'PPER'), ('bin', 'VAFIN'), ('schwanger', 'ADJD')]

>>> ner_tagger = CoreNLPParser('http://localhost:9002', tagtype='ner')
>>> ner_tagger.tag('Donald Trump besuchte Angela Merkel in Berlin.'.split())
[('Donald', 'PERSON'), ('Trump', 'PERSON'), ('besuchte', 'O'), ('Angela', 'PERSON'), ('Merkel', 'PERSON'), ('in', 'O'), ('Berlin', 'LOCATION'), ('.', 'O')]

西班牙语

启动服务器：

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \n-serverProperties StanfordCoreNLP-spanish.properties \n-preload tokenize,ssplit,pos,ner,parse \n-status_port 9003  -port 9003 -timeout 15000

在 Python 中：

>>> pos_tagger = CoreNLPParser('http://localhost:9003', tagtype='pos')
>>> pos_tagger.tag(u'Barack Obama salió con Michael Jackson .'.split())
[('Barack', 'PROPN'), ('Obama', 'PROPN'), ('salió', 'VERB'), ('con', 'ADP'), ('Michael', 'PROPN'), ('Jackson', 'PROPN'), ('.', 'PUNCT')]
>>> ner_tagger = CoreNLPParser('http://localhost:9003', tagtype='ner')
>>> ner_tagger.tag(u'Barack Obama salió con Michael Jackson .'.split())
[('Barack', 'PERSON'), ('Obama', 'PERSON'), ('salió', 'O'), ('con', 'O'), ('Michael', 'PERSON'), ('Jackson', 'PERSON'), ('.', 'O')]

解决方案 4：

弃用的答案

以下答案已被弃用，请使用https://stackoverflow.com/a/51981566/610569上针对 NLTK v3.3 及以上版本的解决方案。

已编辑

截至当前斯坦福解析器（2015-04-20），默认输出lexparser.sh已发生变化，因此下面的脚本将不起作用。

但这个答案是为了遗产而保留的，但它仍然可以与http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip一起使用。

原始答案

我建议你别再用 Jython、JPype 了。让 python 做 python 的事情，让 java 做 java 的事情，通过控制台获取 Stanford Parser 的输出。

在你的主目录中安装了斯坦福解析器~/之后，只需使用这个 Python 配方就可以获得平括号解析：

import os
sentence = "this is a foo bar i want to parse."

os.popen("echo '"+sentence+"' > ~/stanfordtemp.txt")
parser_out = os.popen("~/stanford-parser-2012-11-12/lexparser.sh ~/stanfordtemp.txt").readlines()

bracketed_parse = " ".join( [i.strip() for i in parser_out if i.strip()[0] == "("] )
print bracketed_parse

解决方案 5：

斯坦福解析器有 Python 接口

http://projects.csail.mit.edu/spatial/Stanford_Parser

解决方案 6：

斯坦福核心 NLP 软件页面有一个 Python 包装器列表：

http://nlp.stanford.edu/software/corenlp.shtml#Extensions

解决方案 7：

如果我没记错的话，斯坦福解析器是一个 Java 库，因此你的服务器/计算机上必须运行一个 Java 解释器。

我曾经在服务器上使用过它，并结合了 php 脚本。该脚本使用 php 的 exec() 函数对解析器进行命令行调用，如下所示：

<?php

exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );

?>

我不记得这个命令的所有细节，它基本上打开了 fileToParse，对其进行了解析，并将输出写入 resultFile。然后 PHP 将打开结果文件以供进一步使用。

命令的末尾将解析器的详细程度指示为 NULL，以防止不必要的命令行信息干扰脚本。

我不太了解 Python，但可能有一种方法可以进行命令行调用。

这可能不是您所期望的确切路线，但希望它能给您一些启发。祝您好运。

解决方案 8：

请注意，此答案适用于 NLTK v 3.0，而不适用于较新版本。

这是 danger98 代码的改编版，可与 windoze 上的 nltk3.0.0 配合使用，大概也适用于其他平台，请根据您的设置调整目录名称：

import os
from nltk.parse import stanford
os.environ['STANFORD_PARSER'] = 'd:/stanford-parser'
os.environ['STANFORD_MODELS'] = 'd:/stanford-parser'
os.environ['JAVAHOME'] = 'c:/Program Files/java/jre7/bin'

parser = stanford.StanfordParser(model_path="d:/stanford-grammars/englishPCFG.ser.gz")
sentences = parser.raw_parse_sents(("Hello, My name is Melroy.", "What is your name?"))
print sentences

请注意，解析命令已更改（请参阅 www.nltk.org/_modules/nltk/parse/stanford.html 上的源代码），并且您需要定义 JAVAHOME 变量。我尝试让它读取 jar 中的语法文件，但到目前为止还没有成功。

解决方案 9：

您可以使用斯坦福解析器输出在 nltk（nltk.tree.Tree）中创建一棵树。

假设斯坦福解析器给你一个文件，其中每个句子只有一个解析树。那么这个例子就可以正常工作，尽管它可能看起来不太符合 Python 风格：

f = open(sys.argv[1]+".output"+".30"+".stp", "r")
parse_trees_text=[]
tree = ""
for line in f:
  if line.isspace():
    parse_trees_text.append(tree)
tree = ""
  elif "(. ...))" in line:
#print "YES"
tree = tree+')'
parse_trees_text.append(tree)
tree = ""
  else:
tree = tree + line

parse_trees=[]
for t in parse_trees_text:
  tree = nltk.Tree(t)
  tree.__delitem__(len(tree)-1) #delete "(. .))" from tree (you don't need that)
  s = traverse(tree)
  parse_trees.append(tree)

解决方案 10：

请注意，此答案适用于 NLTK v 3.0，而不适用于较新版本。

由于没有人真正提及并且它在某种程度上困扰了我很多，这里是使用 Python 中的斯坦福解析器的另一种方法：

stanford_parser_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser.jar'
stanford_model_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar'    
parser = StanfordParser(path_to_jar=stanford_parser_jar, 
                        path_to_models_jar=stanford_model_jar)

这样，你就不需要再担心路径的问题了。

对于那些无法在 Ubuntu 上正确使用它或在 Eclipse 中运行代码的人。

解决方案 11：

我在 Windows 机器上，您可以像使用类似命令一样正常地运行解析器，但要在不同的目录中，因此您无需编辑 lexparser.bat 文件。只需输入完整路径即可。

cmd = r'java -cp Documentsstanford_nlpstanford-parser-full-2015-01-30 edu.stanford.nlp.parser.lexparser.LexicalizedParser -outputFormat "typedDependencies" Documentsstanford_nlpstanford-parser-full-2015-01-30stanford-parser-3.5.1-modelsedustanford
lpmodelslexparserenglishFactored.ser.gz stanfordtemp.txt'
parse_out = os.popen(cmd).readlines()

对我来说，棘手的部分是实现如何从不同的路径运行 Java 程序。一定有更好的方法，但这个方法有效。

解决方案 12：

请注意，此答案适用于 NLTK v 3.0，而不适用于较新版本。

danger89 关于在 NLTK 和 Python 中使用 Stanford Parser 的全面回答的轻微更新（或简单的替代）

使用 stanford-parser-full-2015-04-20、JRE 1.8 和 nltk 3.0.4（python 2.7.6），似乎不再需要从 stanford-parser-xxx-models.jar 中提取 englishPCFG.ser.gz 或设置任何 os.environ

from nltk.parse.stanford import StanfordParser

english_parser = StanfordParser('path/stanford-parser.jar', 'path/stanford-parser-3.5.2-models.jar')

s = "The real voyage of discovery consists not in seeking new landscapes, but in having new eyes."

sentences = english_parser.raw_parse_sents((s,))
print sentences #only print <listiterator object> for this version

#draw the tree
for line in sentences:
    for sentence in line:
        sentence.draw()

解决方案 13：

请注意，此答案适用于 NLTK v 3.0，而不适用于较新版本。

这是 alvas 答案的 windows 版本

sentences = ('. '.join(['this is sentence one without a period','this is another foo bar sentence '])+'.').encode('ascii',errors = 'ignore')
catpath =r"YOUR CURRENT FILE PATH"

f = open('stanfordtemp.txt','w')
f.write(sentences)
f.close()

parse_out = os.popen(catpath+r"
lp_toolsstanford-parser-2010-08-20lexparser.bat "+catpath+r"stanfordtemp.txt").readlines()

bracketed_parse = " ".join( [i.strip() for i in parse_out if i.strip() if i.strip()[0] == "("] )
bracketed_parse = "
(ROOT".join(bracketed_parse.split(" (ROOT")).split('
')
aa = map(lambda x :ParentedTree.fromstring(x),bracketed_parse)

笔记：

您lexparser.bat 需要将所有路径更改为绝对路径，以避免出现“找不到类”等 Java 错误
我强烈建议您在 Windows 下应用此方法，因为我尝试了页面上的几个答案，但所有方法都无法使 Python 与 Java 通信。
如果您在 Windows 上取得成功，我希望收到您的回复，并希望您能告诉我如何克服所有这些问题。
搜索 python wrapper for stanford coreNLP 以获取 python 版本

解决方案 14：

我花了很多时间，终于为 Windows 用户找到了一个简单的解决方案。基本上，它是 alvas现有答案的总结版本，但对于那些刚接触 stanford NLP 和 Windows 用户来说，它很容易理解（希望如此）。

1）下载您想要使用的模块，例如 NER、POS 等。就我而言，我想使用 NER，因此我从http://nlp.stanford.edu/software/stanford-ner-2015-04-20.zip下载了模块

2）解压缩文件。

3）从解压的文件夹中设置环境变量（classpath 和 stanford_modules）。

import os
os.environ['CLASSPATH'] = "C:/Users/Downloads/stanford-ner-2015-04-20/stanford-ner.jar"
os.environ['STANFORD_MODELS'] = "C:/Users/Downloads/stanford-ner-2015-04-20/classifiers/"

4）设置 JAVA 的环境变量，就像你安装 JAVA 的地方一样。对我来说它在下面

os.environ['JAVAHOME'] = "C:/Program Files/Java/jdk1.8.0_102/bin/java.exe"

5）导入你想要的模块

from nltk.tag import StanfordNERTagger

6）调用解压文件夹中分类器文件夹中的预训练模型。在文件扩展名末尾添加“.gz”。对我来说，我想要使用的模型是english.all.3class.distsim.crf.ser

st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz')

7）现在执行解析器！我们完成了！

st.tag('Rami Eid is studying at Stony Brook University in NY'.split())

解决方案 15：

弃用的答案

以下答案已被弃用，请使用https://stackoverflow.com/a/51981566/610569上针对 NLTK v3.3 及以上版本的解决方案。

已编辑

注意：以下答案仅适用于：

NLTK 版本 ==3.2.5
斯坦福工具自 2016-10-31 开始编制
Python 2.7、3.5 和 3.6

由于这两种工具变化都很快，API 可能在 3-6 个月后看起来大不相同。请将以下答案视为暂时的，而不是永久的修复。

请始终参考https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software以获取有关如何使用 NLTK 连接斯坦福 NLP 工具的最新说明！！

总结

以下代码来自https://github.com/nltk/nltk/pull/1735#issuecomment-306091826

在终端：

wget http://nlp.stanford.edu/software/stanford-corenlp-full-2016-10-31.zip
unzip stanford-corenlp-full-2016-10-31.zip && cd stanford-corenlp-full-2016-10-31

java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \n-preload tokenize,ssplit,pos,lemma,parse,depparse \n-status_port 9000 -port 9000 -timeout 15000

在 Python 中：

>>> from nltk.tag.stanford import CoreNLPPOSTagger, CoreNLPNERTagger
>>> from nltk.parse.corenlp import CoreNLPParser

>>> stpos, stner = CoreNLPPOSTagger(), CoreNLPNERTagger()

>>> stpos.tag('What is the airspeed of an unladen swallow ?'.split())
[(u'What', u'WP'), (u'is', u'VBZ'), (u'the', u'DT'), (u'airspeed', u'NN'), (u'of', u'IN'), (u'an', u'DT'), (u'unladen', u'JJ'), (u'swallow', u'VB'), (u'?', u'.')]

>>> stner.tag('Rami Eid is studying at Stony Brook University in NY'.split())
[(u'Rami', u'PERSON'), (u'Eid', u'PERSON'), (u'is', u'O'), (u'studying', u'O'), (u'at', u'O'), (u'Stony', u'ORGANIZATION'), (u'Brook', u'ORGANIZATION'), (u'University', u'ORGANIZATION'), (u'in', u'O'), (u'NY', u'O')]


>>> parser = CoreNLPParser(url='http://localhost:9000')

>>> next(
...     parser.raw_parse('The quick brown fox jumps over the lazy dog.')
... ).pretty_print()  # doctest: +NORMALIZE_WHITESPACE
                     ROOT
                      |
                      S
       _______________|__________________________
      |                         VP               |
      |                _________|___             |
      |               |             PP           |
      |               |     ________|___         |
      NP              |    |            NP       |
  ____|__________     |    |     _______|____    |
 DT   JJ    JJ   NN  VBZ   IN   DT      JJ   NN  .
 |    |     |    |    |    |    |       |    |   |
The quick brown fox jumps over the     lazy dog  .

>>> (parse_fox, ), (parse_wolf, ) = parser.raw_parse_sents(
...     [
...         'The quick brown fox jumps over the lazy dog.',
...         'The quick grey wolf jumps over the lazy fox.',
...     ]
... )

>>> parse_fox.pretty_print()  # doctest: +NORMALIZE_WHITESPACE
                     ROOT
                      |
                      S
       _______________|__________________________
      |                         VP               |
      |                _________|___             |
      |               |             PP           |
      |               |     ________|___         |
      NP              |    |            NP       |
  ____|__________     |    |     _______|____    |
 DT   JJ    JJ   NN  VBZ   IN   DT      JJ   NN  .
 |    |     |    |    |    |    |       |    |   |
The quick brown fox jumps over the     lazy dog  .

>>> parse_wolf.pretty_print()  # doctest: +NORMALIZE_WHITESPACE
                     ROOT
                      |
                      S
       _______________|__________________________
      |                         VP               |
      |                _________|___             |
      |               |             PP           |
      |               |     ________|___         |
      NP              |    |            NP       |
  ____|_________      |    |     _______|____    |
 DT   JJ   JJ   NN   VBZ   IN   DT      JJ   NN  .
 |    |    |    |     |    |    |       |    |   |
The quick grey wolf jumps over the     lazy fox  .

>>> (parse_dog, ), (parse_friends, ) = parser.parse_sents(
...     [
...         "I 'm a dog".split(),
...         "This is my friends ' cat ( the tabby )".split(),
...     ]
... )

>>> parse_dog.pretty_print()  # doctest: +NORMALIZE_WHITESPACE
        ROOT
         |
         S
  _______|____
 |            VP
 |    ________|___
 NP  |            NP
 |   |         ___|___
PRP VBP       DT      NN
 |   |        |       |
 I   'm       a      dog

请查看http://www.nltk.org/_modules/nltk/parse/corenlp.html 以获取有关斯坦福 API 的更多信息。查看文档字符串！

解决方案 16：

请注意，此答案适用于 NLTK v 3.0，而不适用于较新版本。

由于声誉问题，我无法将此作为评论留下，但由于我花费（浪费？）一些时间来解决这个问题，我宁愿分享我的问题/解决方案，以使这个解析器在 NLTK 中工作。

在alvas 的出色回答中提到：

例如对于解析器，不会有模型目录。

这让我错误地认为：

不关心我赋予的值STANFORD_MODELS （而只关心我的CLASSPATH）
保留../path/tostanford-parser-full-2015-2012-09/models directory几乎为空（或者使用名称与 nltk 正则表达式不匹配的 jar 文件）！

如果 OP 和我一样，只是想使用解析器，那么可能会感到困惑，当不下载任何其他东西（没有 POStagger，没有 NER，...）并遵循所有这些说明时，我们仍然会收到错误。

最终，对于任何CLASSPATH给定的（按照该线程的答案中的示例和解释）我仍然会收到错误：

NLTK 无法找到 stanford-parser-(\d+)(.(\d+))+-models.jar！请设置 CLASSPATH 环境变量。有关 stanford-parser-(\d+)(.(\d+))+-models.jar 的更多信息，

参见：
http ://nlp.stanford.edu/software/lex-parser.shtml

或者：

NLTK 无法找到 stanford-parser.jar！设置 CLASSPATH 环境变量。有关 stanford-parser.jar 的更多信息，请参阅：http ://nlp.stanford.edu/software/lex-parser.shtml

但重要的是，如果我调用该函数并且所有参数和路径都完全指定，我就能正确加载和使用解析器，如下所示：

stanford_parser_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser.jar'
stanford_model_jar = '../lib/stanford-parser-full-2015-04-20/stanfor-parser-3.5.2-models.jar'    
parser = StanfordParser(path_to_jar=stanford_parser_jar, 
                    path_to_models_jar=stanford_model_jar)

单独解析器的解决方案：

因此，错误来自哪里以及它如何使用提供的和环境变量NLTK来查找 jar 。为了解决这个问题，必须将具有正确格式（以匹配代码中的正则表达式，因此没有 -corenlp-....jar）的放在指定的文件夹中。STANFORD_MODELS`CLASSPATH*-models.jarNLTK`STANFORD_MODELS

即，我首先创建了：

mkdir stanford-parser-full-2015-12-09/models

然后添加.bashrc：

export STANFORD_MODELS=/path/to/stanford-parser-full-2015-12-09/models

最后，通过复制stanford-parser-3.6.0-models.jar（或相应版本）到：

path/to/stanford-parser-full-2015-12-09/models/

我可以使用指向的StanfordParserclassic 在 python 中顺利加载。实际上，这样，您可以不带参数调用，默认值就可以正常工作。CLASSPATH`stanford-parser.jar`StanfordParser

解决方案 17：

我正在使用 nltk 版本 3.2.4。以下代码对我有用。

from nltk.internals import find_jars_within_path
from nltk.tag import StanfordPOSTagger
from nltk import word_tokenize

# Alternatively to setting the CLASSPATH add the jar and model via their 
path:
jar = '/home/ubuntu/stanford-postagger-full-2017-06-09/stanford-postagger.jar'
model = '/home/ubuntu/stanford-postagger-full-2017-06-09/models/english-left3words-distsim.tagger'

pos_tagger = StanfordPOSTagger(model, jar)

# Add other jars from Stanford directory
stanford_dir = pos_tagger._stanford_jar.rpartition('/')[0]
stanford_jars = find_jars_within_path(stanford_dir)
pos_tagger._stanford_jar = ':'.join(stanford_jars)

text = pos_tagger.tag(word_tokenize("Open app and play movie"))
print(text)

输出：

[('Open', 'VB'), ('app', 'NN'), ('and', 'CC'), ('play', 'VB'), ('movie', 'NN')]

解决方案 18：

斯坦福解析器基于神经模型，使用 Tensorflow 进行训练，最近已开发出一种可用作 Python API 的解析器。该模型应该比基于 Java 的模型准确得多。您当然可以将其与 NLTK 管道集成。

链接到解析器。该存储库包含 53 种语言的预训练解析器模型。

问题描述：

解决方案 1：

安装

解决方案 2：

弃用的答案

已编辑

总结

长话短说：

更长时间内：

步骤 1

步骤 2

步骤 3

解决方案 3：

英语

中国人

阿拉伯

法语

德语

西班牙语

解决方案 4：

弃用的答案

已编辑

原始答案

解决方案 5：

解决方案 6：

解决方案 7：

解决方案 8：

解决方案 9：

解决方案 10：

解决方案 11：

解决方案 12：

解决方案 13：

解决方案 14：

解决方案 15：

弃用的答案

已编辑

总结

解决方案 16：

单独解析器的解决方案：

解决方案 17：

解决方案 18：

云端的项目管理软件