弃用的答案

不建议使用以下答案，请针对NLTK v3.3及更高版本使用https://stackoverflow.com/a/51981566/610569上的解决方案。

---

已编辑

从当前的Stanford解析器（2015-04-20）开始， lexparser.sh的默认输出已更改，因此以下脚本将不起作用。

但是，此答案是出于遗留原因而保留的，尽管如此，它仍然适用于http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip 。

---

原始答案

我建议您不要惹Jython，JPype。让python做python东西，让Java做java东西，通过控制台获取Stanford Parser输出。

在主目录~/安装了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

弃用的答案

不建议使用以下答案，请针对NLTK v3.3及更高版本使用https://stackoverflow.com/a/51981566/610569上的解决方案。

---

已编辑

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

• NLTK版本> = 3.2.4
• Stanford Tools自2015-04-20以来编译
• Python 2.7、3.4和3.5（尚未正式支持Python 3.6）

由于这两种工具的更改都非常快，并且API可能会在3-6个月后看起来非常不同。请将以下答案视为暂时性解决方案，而不是永久解决方案。

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

---

TL; DR

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工具。

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

第三 ，斯坦福NLP工具的NLTK API包含了各个NLP工具，例如斯坦福POS标记器 ， 斯坦福NER Tagger ， 斯坦福解析器 。

对于POS和NER标记器，它不会环绕Stanford Core NLP软件包 。

对于Stanford Parser，这是一个特殊的情况，它同时包裹了Stanford Parser和Stanford Core NLP（就我个人而言，我没有使用NLTK使用后者，我宁愿遵循@dimazest在http：//www.eecs上的演示。 qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html ）

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

---

在更长的时间：

步骤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位二进制安装）：

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

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

---

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

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

或在命令行上：

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

确保您看到3.1作为输出。

要获得更多的偏执狂，请检查所有您喜欢的Stanford 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以使用Stanford Tools。）

---

第2步

现在，您已经检查了NLTK的正确版本，该版本包含必要的Stanford NLP工具界面。您需要下载并解压缩所有必要的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下载并解压缩FULL VERSION标记器
• 从http://nlp.stanford.edu/software/CRF-NER.shtml#Download下载并解压缩NER标记器

---

步骤3

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

• 将适当的Stanford 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变量，而不再使用LONGER 。在以下Stackoverflow问题中找到的代码段可能不起作用：

• 斯坦福依赖性解析器设置和NLTK
• 斯坦福解析器的nltk接口
• 将斯坦福pos标记器导入nltk时遇到麻烦
• Python Nltk中的Stanford实体识别器（无用）
• 如何使用Stanford NLP Tagger和NLTK提高速度
• 如何获得斯坦福NLTK python模块？
• 斯坦福解析器和NLTK窗口
• 斯坦福大学使用NLTK命名实体识别器（NER）功能
• 带有NLTK的斯坦福解析器产生空输出
• 使用NLTK中的Stanford NER Tagger提取人员和组织列表
• 在NLTK Python中使用Stanford POS Tagger时出错

适用于Ubuntu上STEP 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'])])])])])])]

---

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

如果在API更改其参数名称时使用以下方法BUT ，则无需设置环境变量，则需要进行相应的更改。 这就是为什么建议设置环境变量而不是修改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)

从NLTK v3.3开始，用户应避免使用nltk.tag的Stanford NER或POS标记nltk.tag ，并避免使用 nltk.tag Stanford标记程序/分段nltk.tokenize 。

而是使用新的nltk.parse.corenlp.CoreNLPParser API。

请参阅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 \
-preload tokenize,ssplit,pos,lemma,ner,parse,depparse \
-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 \
-serverProperties StanfordCoreNLP-chinese.properties \
-preload tokenize,ssplit,pos,lemma,ner,parse \
-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 \
-serverProperties StanfordCoreNLP-arabic.properties \
-preload tokenize,ssplit,pos,parse \
-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 \
-serverProperties StanfordCoreNLP-french.properties \
-preload tokenize,ssplit,pos,parse \
-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 \
-serverProperties StanfordCoreNLP-german.properties \
-preload tokenize,ssplit,pos,ner,parse \
-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 \
-serverProperties StanfordCoreNLP-spanish.properties \
-preload tokenize,ssplit,pos,ner,parse \
-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')]

请注意，此答案适用于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'，['Hello']）]]），Tree（'，'，['，']））， Tree（'NP'，[Tree（'PRP $'，['My']），Tree（'NN'，['name']）]）），Tree（'VP'，[Tree（'VBZ'，[ 'is']），Tree（'ADJP'，[Tree（'JJ'，['Melroy']）]）]），Tree（'。'，['。']）]）））），Tree（' ROOT'，[Tree（'SBARQ'，[Tree（'WHNP'，[Tree（'WP'，['What']））]）），Tree（'SQ'，[Tree（'VBZ'，['is' ]），Tree（'NP'，[Tree（'PRP $'，['your']），Tree（'NN'，['name']）]）））），Tree（'。'，['？ ']）]）]）]

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

笔记2：

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

注3：englishPCFG.ser.gz文件可以在models.jar文件（/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz） 内被发现。请使用Come Archive Manager来“解压缩” models.jar文件。

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

安装

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

   sudo python setup.py安装

2. 您可以使用NLTK下载器通过Python获取Stanford Parser：

    import nltk nltk.download() 

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

要么：

1. 与上面相同，下载并安装NLTK v3。

2. 从下载最新版本（ 当前版本文件名为stanford-parser-full-2015-01-29.zip）： http : //nlp.stanford.edu/software/lex-parser.shtml#Download

3. 提取standford-parser-full-20xx-xx-xx.zip。

4. 创建一个新文件夹（在我的示例中为“ jars”）。将提取的文件放入以下jar文件夹中：stanford-parser-3.xx-models.jar和stanford-parser.jar。

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

5. 使用存档管理器（7zip）打开stanford-parser-3.xx-models.jar。

6. 浏览jar文件； edu / stanford / nlp / models / lexparser。再次提取名为“ englishPCFG.ser.gz”的文件。记住解压缩此ser.gz文件的位置。

7. 创建StanfordParser实例时，可以提供模型路径作为参数。这是模型的完整路径，在我们的示例中是/location/of/englishPCFG.ser.gz。

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

Stanford Core NLP软件页面包含python包装器列表：

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

您可以使用Stanford Parsers输出在nltk（nltk.tree.Tree）中创建树。

假设斯坦福解析器为您提供了一个文件，其中每个句子恰好有一棵解析树。然后，此示例可以正常工作，尽管它看起来可能不太像pythonic：

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)

斯坦福解析器有python接口

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

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

这是在windoze上与nltk3.0.0一起使用的danger98代码的改编，可能还包括其他平台，请根据您的设置调整目录名称：

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中原位读取语法文件，但到目前为止未能做到这一点。

如果我没记错的话，斯坦福解析器是一个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不太了解，但是也许可以进行命令行调用。

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

请注意，此答案适用于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中运行代码的人。