在这篇文章中，我们将带领您了解在Python中使用StanfordTregex的全貌，包括pythonstratifiedkfold的相关情况。同时，我们还将为您介绍有关Python中使用static

在这篇文章中，我们将带领您了解在Python中使用Stanford Tregex的全貌，包括python stratifiedkfold的相关情况。同时，我们还将为您介绍有关Python中使用static、class、abstract方法、Stanford NLP for Python、Stanford NLP 在 Python 环境中安装、介绍及使用、【NLP】Python3.6.5 中使用 Stanford NLP 工具包进行词性标注的知识，以帮助您更好地理解这个主题。

本文目录一览：

• 在Python中使用Stanford Tregex（python stratifiedkfold）
• Python中使用static、class、abstract方法
• Stanford NLP for Python
• Stanford NLP 在 Python 环境中安装、介绍及使用
• 【NLP】Python3.6.5 中使用 Stanford NLP 工具包进行词性标注

在Python中使用Stanford Tregex（python stratifiedkfold）

我是NLP和Python的新手。我正在尝试使用Tregex工具和Python子进程库从StanfordCoreNLP的已解析树中提取名词短语的子集。特别是，我试图查找和提取与以下模式匹配的名词短语：’（NP
[$ VP]> S）|（NP [$ VP]> S \ n）|（NP \ n [$ VP] > S）|（NP \ n [$ VP]> S \
n）’在Tregex语法中。

例如，下面是原始文本，保存在名为“ text”的字符串中：

text = (''Pusheen and Smitha walked along the beach. "I want to surf", said Smitha, the CEO of Tesla. However, she fell off the surfboard'')

使用Python包装器运行StanfordCoreNLP解析器后，我为这3个句子得到了以下3棵树：

output1[''sentences''][0][''parse'']Out[58]: ''(ROOT\n  (S\n    (NP (NNP Pusheen)\n      (CC and)\n      (NNP Smitha))\n    (VP (VBD walked)\n      (PP (IN along)\n        (NP (DT the) (NN beach))))\n    (. .)))''output1[''sentences''][1][''parse'']Out[59]: "(ROOT\n  (SINV (`` ``)\n    (S\n      (NP (PRP I))\n      (VP (VBP want)\n        (PP (TO to)\n          (NP (NN surf) ('''' '''')))))\n    (, ,)\n    (VP (VBD said))\n    (NP\n      (NP (NNP Smitha))\n      (, ,)\n      (NP\n        (NP (DT the) (NNP CEO))\n        (PP (IN of)\n          (NP (NNP Tesla)))))\n    (. .)))"output1[''sentences''][2][''parse'']Out[60]: ''(ROOT\n  (S\n    (ADVP (RB However))\n    (, ,)\n    (NP (PRP she))\n    (VP (VBD fell)\n      (PRT (RP off))\n      (NP (DT the) (NN surfboard)))))''

我想提取以下3个名词短语（每个句子一个）并将其另存为Python中的变量（或标记列表）：

• （NP（NNP Pusheen）\ n（CC和）\ n（NNP Smitha））
• （NP（PRP I））
• （NP（PRP她））

为了给您提供信息，我在命令行中使用了tregex，其代码如下：

cd stanford-tregex-2016-10-31java -cp ''stanford-tregex.jar:'' edu.stanford.nlp.trees.tregex.TregexPattern -f -s ''(NP[$VP]>S)|(NP[$VP]>S\n)|(NP\n[$VP]>S)|(NP\n[$VP]>S\n)'' /Users/AS/stanford-tregex-2016-10-31/exampletree.txt

输出为：

Pattern string:(NP[$VP]>S)|(NP[$VP]>S\n)|(NP\n[$VP]>S)|(NP\n[$VP]>S\n)Parsed representation:or   Root NP      and         $ VP         > S   Root NP      and         $ VP         > S\n   Root NP\n      and         $ VP         > S   Root NP\n      and         $ VP         > S\nReading trees from file(s) file path\# /Users/AS/stanford-tregex-2016-10-31/exampletree.txt(NP (NNP Pusheen) \n (CC and) \n (NNP Smitha))\# /Users/AS/stanford-tregex-2016-10-31/exampletree.txt(NP\n (NP (NNP Smitha)) \n (, ,) \n (NP\n (NP (DT the) (NN spokesperson)) \n   (PP (IN of) \n (NP (DT the) (NNP CIA)))) \n (, ,))\# /Users/AS/stanford-tregex-2016-10-31/exampletree.txt(NP (PRP They))There were 3 matches in total.

如何在Python中复制此结果？

供您参考，我通过Google找到了以下帖子，该帖子与我的问题有关，但已过时（https://mailman.stanford.edu/pipermail/parser-
user/2010-July/000606.html）：

[parser-user] Tregex的变量输入

Christopher Manning manning at stanford.edu WDT Jul 7 17:41:32 PDT 2010 Hi
Haiyang，

抱歉，回复缓慢，在学年结束时事情太忙了。

2010年6月1日，晚上8:56，海阳AI写道：

亲爱的大家，

我希望这是寻求帮助的正确地方。

是的，尽管我们只能在任何特定于Python的方面提供非常有限的帮助。

但这似乎很简单（我认为）。

如果您想要的是让模式在通过stdin输入的树上运行，则需要在参数列表中的“ NP”之前添加标志“ -filter”。

如果在模式之后未指定文件，并且未给出标志“ -filter”，则它将在固定的默认句子上运行模式。

克里斯。

我正在从事与Tregex相关的项目。我正在尝试从python调用Tregex，但是我不知道如何将数据提供给Tregex，而不是常规文件，而是变量。例如，我正在尝试使用以下代码计算给定变量（例如，文本，已经解析的树，使用Stanford
Parser）中“ NP”的数量，

def tregex（text）：
tregex_dir =“ / root / nlp / stanford-tregex-2009-08-30 /” op = Popen（[“
java”，“ -mx900m”，“ -cp”，“ stanford-tregex.jar ：“，”
edu.stanford.nlp.trees.tregex.TregexPattern“，” NP“]，cwd = tregex_dir，stdout
= PIPE，stdin = PIPE，stderr = STDOUT）res = op.communicate（input = text）[0
]返回res

结果如下。它没有从变量中搜索内容，而是以某种方式退回到了“使用默认树”。有人可以帮我吗？我在这里呆了很长时间。非常感谢您的时间和帮助。模式字符串：NP解析的表示形式：使用默认树的根NP（NP（NP（DT，此）（NN葡萄酒））（CC和）（NP（DT，这些）（NNS蜗牛））））

（NP（DT this）（NN酒））

（NP（DT这些）（NNS蜗牛））

总共有3场比赛。

-海阳AI博士 学生宾夕法尼亚州立大学应用语言学系

---

解析器用户邮件列表解析器用户位于list.stanford.edu
https://mailman.stanford.edu/mailman/listinfo/parser-
user

答案1

小编典典

为什么不使用Stanford CoreNLP服务器！

1.）启动服务器！

java -Xmx4g edu.stanford.nlp.pipeline.StanfordCoreNLPServer -port 9000 - timeout 15000

2.）发出python请求！

import requestsurl = "http://localhost:9000/tregex"request_params = {"pattern": "(NP[$VP]>S)|(NP[$VP]>S\\n)|(NP\\n[$VP]>S)|(NP\\n[$VP]>S\\n)"}text = "Pusheen and Smitha walked along the beach."r = requests.post(url, data=text, params=request_params)print r.json()

3.）结果如下！

{u''sentences'': [{u''0'': {u''namedNodes'': [], u''match'': u''(NP (NNP Pusheen)\n  (CC and)\n  (NNP Smitha))\n''}}]}

Python中使用static、class、abstract方法

方法在Python中是如何工作的

方法就是一个函数，它作为一个类属性而存在，你可以用如下方式来声明、访问一个函数：

Python

 

1 2 3 4 5 6 7 8

>>> class Pizza(object): ...     def __init__(self, size): ...         self.size = size ...     def get_size(self): ...         return self.size ... >>> Pizza.get_size <unbound method Pizza.get_size>

Python在告诉你，属性_get_size是类Pizza的一个未绑定方法。这是什么意思呢？很快我们就会知道答案：

Python

 

1 2 3 4

>>> Pizza.get_size() Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

我们不能这么调用，因为它还没有绑定到Pizza类的任何实例上，它需要一个实例作为第一个参数传递进去（Python2必须是该类的实例，Python3中可以是任何东西），尝试一下：

Python

 

1 2	>>> Pizza.get_size(Pizza(42)) 42

太棒了，现在用一个实例作为它的的第一个参数来调用，整个世界都清静了，如果我说这种调用方式还不是最方便的，你也会这么认为的；没错，现在每次调用这个方法的时候我们都不得不引用这个类，如果不知道哪个类是我们的对象，长期看来这种方式是行不通的。

那么Python为我们做了什么呢，它绑定了所有来自类_Pizza的方法以及该类的任何一个实例的方法。也就意味着现在属性get_size是Pizza的一个实例对象的绑定方法，这个方法的第一个参数就是该实例本身。

Python

 

1 2 3 4

>>> Pizza(42).get_size <bound method Pizza.get_size of <__main__.Pizza object at 0x7f3138827910>> >>> Pizza(42).get_size() 42

和我们预期的一样，现在不再需要提供任何参数给_get_size，因为它已经是绑定的，它的self参数会自动地设置给Pizza实例，下面代码是最好的证明：

Python

 

1 2 3

>>> m = Pizza(42).get_size >>> m() 42

更有甚者，你都没必要使用持有Pizza对象的引用了，因为该方法已经绑定到了这个对象，所以这个方法对它自己来说是已经足够了。

也许，如果你想知道这个绑定的方法是绑定在哪个对象上，下面这种手段就能得知：

Python

 

1 2 3 4 5 6 7

>>> m = Pizza(42).get_size >>> m.__self__ <__main__.Pizza object at 0x7f3138827910> >>> # You could guess, look at this: ... >>> m == m.__self__.get_size True

显然，该对象仍然有一个引用存在，只要你愿意你还是可以把它找回来。

在Python3中，依附在类上的函数不再当作是未绑定的方法，而是把它当作一个简单地函数，如果有必要它会绑定到一个对象身上去，原则依然和Python2保持一致，但是模块更简洁：

Python

 

1 2 3 4 5 6 7 8

>>> class Pizza(object): ...     def __init__(self, size): ...         self.size = size ...     def get_size(self): ...         return self.size ... >>> Pizza.get_size <function Pizza.get_size at 0x7f307f984dd0>

 

静态方法

静态方法是一类特殊的方法，有时你可能需要写一个属于这个类的方法，但是这些代码完全不会使用到实例对象本身，例如：

Python

 

1 2 3 4 5 6 7

class Pizza(object):     @staticmethod     def mix_ingredients(x, y):         return x + y       def cook(self):         return self.mix_ingredients(self.cheese, self.vegetables)

这个例子中，如果把_mix_ingredients作为非静态方法同样可以运行，但是它要提供self参数，而这个参数在方法中根本不会被使用到。这里的@staticmethod装饰器可以给我们带来一些好处：

• Python不再需要为Pizza对象实例初始化一个绑定方法，绑定方法同样是对象，但是创建他们需要成本，而静态方法就可以避免这些。

 

Python

 

1 2 3 4 5 6

>>> Pizza().cook is Pizza().cook False >>> Pizza().mix_ingredients is Pizza.mix_ingredients True >>> Pizza().mix_ingredients is Pizza().mix_ingredients True

 

• 可读性更好的代码，看到@staticmethod我们就知道这个方法并不需要依赖对象本身的状态。
• 可以在子类中被覆盖，如果是把mix_ingredients作为模块的顶层函数，那么继承自Pizza的子类就没法改变pizza的mix_ingredients了如果不覆盖cook的话。

类方法

话虽如此，什么是类方法呢？类方法不是绑定到对象上，而是绑定在类上的方法。

Python

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

>>> class Pizza(object): ...     radius = 42 ...     @classmethod ...     def get_radius(cls): ...         return cls.radius ... >>> >>> Pizza.get_radius <bound method type.get_radius of <class ''__main__.Pizza''>> >>> Pizza().get_radius <bound method type.get_radius of <class ''__main__.Pizza''>> >>> Pizza.get_radius is Pizza().get_radius True >>> Pizza.get_radius() 42

无论你用哪种方式访问这个方法，它总是绑定到了这个类身上，它的第一个参数是这个类本身（记住：类也是对象）。

什么时候使用这种方法呢？类方法通常在以下两种场景是非常有用的：

• 工厂方法：它用于创建类的实例，例如一些预处理。如果使用@staticmethod代替，那我们不得不硬编码Pizza类名在函数中，这使得任何继承Pizza的类都不能使用我们这个工厂方法给它自己用。

 

Python

 

1 2 3 4 5 6 7

class Pizza(object):     def __init__(self, ingredients):         self.ingredients = ingredients       @classmethod     def from_fridge(cls, fridge):         return cls(fridge.get_cheese() + fridge.get_vegetables())

 

• 调用静态类：如果你把一个静态方法拆分成多个静态方法，除非你使用类方法，否则你还是得硬编码类名。使用这种方式声明方法，Pizza类名明永远都不会在被直接引用，继承和方法覆盖都可以完美的工作。

 

Python

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class Pizza(object):     def __init__(self, radius, height):         self.radius = radius         self.height = height       @staticmethod     def compute_area(radius):          return math.pi * (radius ** 2)       @classmethod     def compute_volume(cls, height, radius):          return height * cls.compute_area(radius)       def get_volume(self):         return self.compute_volume(self.height, self.radius)

 

抽象方法

抽象方法是定义在基类中的一种方法，它没有提供任何实现，类似于Java中接口(Interface)里面的方法。

在Python中实现抽象方法最简单地方式是：

Python

 

1 2 3

class Pizza(object):     def get_radius(self):         raise NotImplementedError

任何继承自_Pizza的类必须覆盖实现方法get_radius，否则会抛出异常。

这种抽象方法的实现有它的弊端，如果你写一个类继承Pizza，但是忘记实现get_radius，异常只有在你真正使用的时候才会抛出来。

Python

 

1 2 3 4 5 6 7

>>> Pizza() <__main__.Pizza object at 0x7fb747353d90> >>> Pizza().get_radius() Traceback (most recent call last):   File "<stdin>", line 1, in <module>   File "<stdin>", line 3, in get_radius NotImplementedError

还有一种方式可以让错误更早的触发，使用Python提供的abc模块，对象被初始化之后就可以抛出异常：

Python

 

1 2 3 4 5 6 7 8

import abc   class BasePizza(object):     __metaclass__  = abc.ABCMeta       @abc.abstractmethod     def get_radius(self):          """Method that should do something."""

使用abc后，当你尝试初始化BasePizza或者任何子类的时候立马就会得到一个TypeError，而无需等到真正调用get_radius的时候才发现异常。

Python

 

1 2 3 4

>>> BasePizza() Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: Can''t instantiate abstract class BasePizza with abstract methods get_radius

 

混合静态方法、类方法、抽象方法

当你开始构建类和继承结构时，混合使用这些装饰器的时候到了，所以这里列出了一些技巧。

记住，声明一个抽象的方法，不会固定方法的原型，这就意味着虽然你必须实现它，但是我可以用任何参数列表来实现：

Python

 

1 2 3 4 5 6 7 8 9 10 11 12 13

import abc   class BasePizza(object):     __metaclass__  = abc.ABCMeta       @abc.abstractmethod     def get_ingredients(self):          """Returns the ingredient list."""   class Calzone(BasePizza):     def get_ingredients(self, with_egg=False):         egg = Egg() if with_egg else None         return self.ingredients + egg

这样是允许的，因为Calzone满足BasePizza对象所定义的接口需求。同样我们也可以用一个类方法或静态方法来实现：

Python

 

1 2 3 4 5 6 7 8 9 10 11 12 13

import abc   class BasePizza(object):     __metaclass__  = abc.ABCMeta       @abc.abstractmethod     def get_ingredients(self):          """Returns the ingredient list."""   class DietPizza(BasePizza):     @staticmethod     def get_ingredients():         return None

这同样是正确的,因为它遵循抽象类BasePizza设定的契约。事实上get_ingredients方法并不需要知道返回结果是什么，结果是实现细节，不是契约条件。

因此，你不能强制抽象方法的实现是一个常规方法、或者是类方法还是静态方法，也没什么可争论的。从Python3开始（在Python2中不能如你期待的运行，见issue5867），在abstractmethod方法上面使用@staticmethod和@classmethod装饰器成为可能。

Python

 

1 2 3 4 5 6 7 8 9 10 11 12

import abc   class BasePizza(object):     __metaclass__  = abc.ABCMeta       ingredient = [''cheese'']       @classmethod     @abc.abstractmethod     def get_ingredients(cls):          """Returns the ingredient list."""          return cls.ingredients

别误会了，如果你认为它会强制子类作为一个类方法来实现get_ingredients那你就错了，它仅仅表示你实现的get_ingredients在BasePizza中是一个类方法。

可以在抽象方法中做代码的实现？没错，Python与Java接口中的方法相反，你可以在抽象方法编写实现代码通过super()来调用它。（译注：在Java8中，接口也提供的默认方法，允许在接口中写方法的实现）

Python

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

import abc   class BasePizza(object):     __metaclass__  = abc.ABCMeta       default_ingredients = [''cheese'']       @classmethod     @abc.abstractmethod     def get_ingredients(cls):          """Returns the ingredient list."""          return cls.default_ingredients   class DietPizza(BasePizza):     def get_ingredients(self):         return [''egg''] + super(DietPizza, self).get_ingredients()

这个例子中，你构建的每个pizza都通过继承BasePizza的方式，你不得不覆盖get_ingredients方法，但是能够使用默认机制通过super()来获取ingredient列表。

Stanford NLP for Python

我要做的就是找到任何给定字符串的情绪（正/负/中性）。在研究中，我遇到了斯坦福大学NLP。但是可悲的是它在Java中。关于如何使它适用于python的任何想法？

答案1

小编典典

采用 py-corenlp

下载Stanford CoreNLP

目前（2020-05-25）的最新版本是4.0.0：

wget https://nlp.stanford.edu/software/stanford-corenlp-4.0.0.zip https://nlp.stanford.edu/software/stanford-corenlp-4.0.0-models-english.jar

如果您没有wget，则可能有curl：

curl https://nlp.stanford.edu/software/stanford-corenlp-4.0.0.zip -O https://nlp.stanford.edu/software/stanford-corenlp-4.0.0-models-english.jar -O

如果其他所有方法均失败，请使用浏览器;-)

安装套件

unzip stanford-corenlp-4.0.0.zipmv stanford-corenlp-4.0.0-models-english.jar stanford-corenlp-4.0.0

启动服务器

cd stanford-corenlp-4.0.0java -mx5g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer -timeout 10000

笔记：

1. timeout以毫秒为单位，我将其设置为10秒以上。如果将大量Blob传递给服务器，则应增加它。
2. 还有更多选项，您可以使用列出它们--help。
3. -mx5g应该分配足够的内存，但是YMMV，并且如果您的盒子电源不足，则可能需要修改该选项。

安装python包

标准包装

pip install pycorenlp

并 没有 与Python 3.9，所以你需要做的

pip install git+https://github.com/sam-s/py-corenlp.git

（另请参阅官方列表）。

用它

from pycorenlp import StanfordCoreNLPnlp = StanfordCoreNLP(''http://localhost:9000'')res = nlp.annotate("I love you. I hate him. You are nice. He is dumb",                   properties={                       ''annotators'': ''sentiment'',                       ''outputFormat'': ''json'',                       ''timeout'': 1000,                   })for s in res["sentences"]:    print("%d: ''%s'': %s %s" % (        s["index"],        " ".join([t["word"] for t in s["tokens"]]),        s["sentimentValue"], s["sentiment"]))

您将获得：

0: ''I love you .'': 3 Positive1: ''I hate him .'': 1 Negative2: ''You are nice .'': 3 Positive3: ''He is dumb'': 1 Negative

笔记

1. 您将整个文本传递到服务器，然后将其拆分为句子。它还将句子拆分为标记。
2. 情感归属于每个 句子 ，而不是 全文 。句子之间的均值 sentimentValue可以用来估计整个文本的情绪。
3. 句子的平均情绪在Neutral（2）和Negative（1）之间，范围从VeryNegative（0）到VeryPositive（4），这似乎非常少见。
4. 您可以通过在启动它的终端上键入或使用shell命令来停止服务器。是默认端口，您可以在启动服务器时使用该选项进行更改。Ctrl-C``kill $(lsof -ti tcp:9000)``9000``-port
5. timeout如果收到超时错误，则增加服务器或客户端的时间（以毫秒为单位）。
6. sentiment仅仅是 一个 注释器，还有更多注释器，您可以请求多个注释器，并用逗号分隔：''annotators'': ''sentiment,lemma''。
7. 请注意，情感模型在某种程度上是特质的（例如，结果是不同的，具体取决于您提到David还是Bill）。

PS 。我不敢相信我添加了 第9个
答案，但是我想我必须这样做，因为现有的答案都没有帮助我（以前的8个答案中的一些已被删除，另一些已转换为评论）。

Stanford NLP 在 Python 环境中安装、介绍及使用

Stanford NLP
Stanford NLP 提供了一系列自然语言分析工具。它能够给出基本的
词形，词性，不管是公司名还是人名等，格式化的日期，时间，量词，
并且能够标记句子的结构，语法形式和字词依赖，指明那些名字指向同
样的实体，指明情绪，提取发言中的开放关系等。
1. 一个集成的语言分析工具集；
2. 进行快速，可靠的任意文本分析；
3. 整体的高质量的文本分析；
4. 支持多种主流语言；
5. 多种编程语言的易用接口；
6. 方便的简单的部署 web 服务

Python 版本 stanford nlp 安装
・1）安装 stanford nlp 自然语言处理包： pip install stanfordcorenlp
・2）下载 Stanford CoreNLP 文件
https://stanfordnlp.github.io/CoreNLP/download.html
・3）下载中文模型 jar 包， http://nlp.stanford.edu/software/stanford-chinese corenlp-2018-02-27-models.jar，
・4）把解压后的 Stanford CoreNLP 文件夹和下载的 stanford-chinese-corenlp-
2018-02-27-models.jar 放在同一目录下
・5）在 Python 中引用模型：
• from stanfordcorenlp import StanfordCoreNLP
• nlp = StanfordCoreNLP(r‘path'', lang=''zh'')

【NLP】Python3.6.5 中使用 Stanford NLP 工具包进行词性标注

关于在Python中使用Stanford Tregex和python stratifiedkfold的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Python中使用static、class、abstract方法、Stanford NLP for Python、Stanford NLP 在 Python 环境中安装、介绍及使用、【NLP】Python3.6.5 中使用 Stanford NLP 工具包进行词性标注等相关内容，可以在本站寻找。

本文标签：

• Python
• Stanford_Tregex
• StratifiedKFold
• Machine_Learning