文章目录
TextRank算法是一种文本排序算法，由谷歌的网页重要性排序算法PageRank算法改进而来，它能够从一个给定的文本中提取出该文本的关键词、关键词组，并使用抽取式的自动文摘方法提取出该文本的关键句。其提出论文是： Mihalcea R, Tarau P. TextRank: Bringing order into texts[C]. Association for Computational Linguistics, 2004. 论文的百度学术下载地址为：点击打开链接。
TextRank算法的基本原理：顶点击这里
1. textrank4zh模块源码解读
textrank4zh模块是针对中文文本的TextRank算法的python算法实现，该模块的下载地址为：点击打开链接
对其源码解读如下：
util.py：textrank4zh模块的工具包，TextRank算法的核心思想在该文件中实现。
# -*- encoding:utf-8 -*-
"""
@author: letian
@homepage: http://www.letiantian.me
@github: https://github.com/someus/
"""
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import os
import math
import networkx as nx
import numpy as np
import sys
try:
reload(sys)
sys.setdefaultencoding('utf-8')
except:
pass
sentence_delimiters = ['?', '!', ';', '？', '！', '。', '；', '……', '…', '\n']
allow_speech_tags = ['an', 'i', 'j', 'l', 'n', 'nr', 'nrfg', 'ns', 'nt', 'nz', 't', 'v', 'vd', 'vn', 'eng']
PY2 = sys.version_info[0] == 2
if not PY2:
# Python 3.x and up
text_type = str
string_types = (str,)
xrange = range
def as_text(v): ## 生成unicode字符串
if v is None:
return None
elif isinstance(v, bytes):
return v.decode('utf-8', errors='ignore')
elif isinstance(v, str):
return v
else:
raise ValueError('Unknown type %r' % type(v))
def is_text(v):
return isinstance(v, text_type)
else:
# Python 2.x
text_type = unicode
string_types = (str, unicode)
xrange = xrange
def as_text(v):
if v is None:
return None
elif isinstance(v, unicode):
return v
elif isinstance(v, str):
return v.decode('utf-8', errors='ignore')
else:
raise ValueError('Invalid type %r' % type(v))
def is_text(v):
return isinstance(v, text_type)
__DEBUG = None
def debug(*args):
global __DEBUG
if __DEBUG is None:
try:
if os.environ['DEBUG'] == '1':
__DEBUG = True
else:
__DEBUG = False
except:
__DEBUG = False
if __DEBUG:
print(' '.join([str(arg) for arg in args]))
class AttrDict(dict):
"""Dict that can get attribute by dot"""
def __init__(self, *args, **kwargs):
super(AttrDict, self).__init__(*args, **kwargs)
self.__dict__ = self
def combine(word_list, window=2):
"""构造在window下的单词组合，用来构造单词之间的边。
Keyword arguments:
word_list -- list of str, 由单词组成的列表。
windows -- int, 窗口大小。
"""
if window < 2: window = 2
for x in xrange(1, window):
if x >= len(word_list):
break
word_list2 = word_list[x:]
res = zip(word_list, word_list2)
for r in res:
yield r
def get_similarity(word_list1, word_list2):
"""默认的用于计算两个句子相似度的函数。
Keyword arguments:
word_list1, word_list2 -- 分别代表两个句子，都是由单词组成的列表
"""
words = list(set(word_list1 + word_list2))
vector1 = [float(word_list1.count(word)) for word in words]
vector2 = [float(word_list2.count(word)) for word in words]
vector3 = [vector1[x] * vector2[x] for x in xrange(len(vector1))]
vector4 = [1 for num in vector3 if num > 0.]
co_occur_num = sum(vector4)
if abs(co_occur_num) <= 1e-12:
return 0.
denominator = math.log(float(len(word_list1))) + math.log(float(len(word_list2))) # 分母
if abs(denominator) < 1e-12:
return 0.
return co_occur_num / denominator
def sort_words(vertex_source, edge_source, window=2, pagerank_config={'alpha': 0.85, }):
"""将单词按关键程度从大到小排序
Keyword arguments:
vertex_source -- 二维列表，子列表代表句子，子列表的元素是单词，这些单词用来构造pagerank中的节点
edge_source -- 二维列表，子列表代表句子，子列表的元素是单词，根据单词位置关系构造pagerank中的边
window -- 一个句子中相邻的window个单词，两两之间认为有边
pagerank_config -- pagerank的设置
"""
sorted_words = []
word_index = {}
index_word = {}
_vertex_source = vertex_source
_edge_source = edge_source
words_number = 0
for word_list in _vertex_source:
for word in word_list:
if not word in word_index:
word_index[word] = words_number
index_word[words_number] = word
words_number += 1
graph = np.zeros((words_number, words_number))
for word_list in _edge_source:
for w1, w2 in combine(word_list, window):
if w1 in word_index and w2 in word_index:
index1 = word_index[w1]
index2 = word_index[w2]
graph[index1][index2] = 1.0
graph[index2][index1] = 1.0
debug('graph:\n', graph)
nx_graph = nx.from_numpy_matrix(graph)
scores = nx.pagerank(nx_graph, **pagerank_config) # this is a dict
sorted_scores = sorted(scores.items(), key=lambda item: item[1], reverse=True)
for index, score in sorted_scores:
item = AttrDict(word=index_word[index], weight=score)
sorted_words.append(item)
return sorted_words
def sort_sentences(sentences, words, sim_func=get_similarity, pagerank_config={'alpha': 0.85, }):
"""将句子按照关键程度从大到小排序
Keyword arguments:
sentences -- 列表，元素是句子
words -- 二维列表，子列表和sentences中的句子对应，子列表由单词组成
sim_func -- 计算两个句子的相似性，参数是两个由单词组成的列表
pagerank_config -- pagerank的设置
"""
sorted_sentences = []
_source = words
sentences_num = len(_source)
graph = np.zeros((sentences_num, sentences_num))
for x in xrange(sentences_num):
for y in xrange(x, sentences_num):
similarity = sim_func(_source[x], _source[y])
graph[x, y] = similarity
graph[y, x] = similarity
nx_graph = nx.from_numpy_matrix(graph)
scores = nx.pagerank(nx_graph, **pagerank_config) # this is a dict
sorted_scores = sorted(scores.items(), key=lambda item: item[1], reverse=True)
for index, score in sorted_scores:
item = AttrDict(index=index, sentence=sentences[index], weight=score)
sorted_sentences.append(item)
return sorted_sentences
if __name__ == '__main__':
pass
Segmentation.py：包含用于分词和分句的类。
# -*-coding:utf-8-*-
# 把新版本的特性引入当前版本
from __future__ import (absolute_import, division, print_function, unicode_literals)
# 导入结巴分词的词性标注组件
import jieba.posseg as pseg
# 导入编码转换模块
import codecs
# 导入操作系统模块
import os
# 导入工具包组件
from textrank4zh import util
# 获取停用词文件的路径
def get_default_stop_words_file():
# 获取当前脚本所在的路径
d = os.path.dirname(os.path.realpath(__file__))
# 返回停用词表所在路径，os.path.join方法用于将多个路径组合后返回
return os.path.join(d, 'stopwords.txt')
"""分词类"""
class WordSegmentation(object):
"""初始化函数，获取词性列表和停用词表"""
def __init__(self, stop_words_file=None, allow_speech_tags=util.allow_speech_tags):
"""
:param stop_words_file：保存停用词表的文件路径，使用utf-8编码方式，每行存放一个停用词，若不是str类型，则使用默认的停用词
:param allow_speech_tags：默认的词性列表，用于过滤某些词性的词
:return:无
"""
# 词性列表
allow_speech_tags = [util.as_text(item) for item in allow_speech_tags]
# 将词性列表设置为默认的词性列表
self.default_speech_tags_filter = allow_speech_tags
# 使用set方法创建空集合
self.stop_words = set()
# 获取停用词文件的路径
self.stop_words_file = get_default_stop_words_file()
# 若停用词文件路径不是str类型，则使用默认的停用词
if type(stop_words_file is str):
self.stop_words_file = stop_words_file
# 打开并读取停用词文件，将其中的停用词加入停用词集合
for word in codecs.open(self.stop_words_file, 'r', 'utf-8', 'ignore'):
self.stop_words.add(word.strip())
"""对文本进行分词，返回的分词结果以列表方式存储"""
def segment(self, text, lower=True, user_stop_words=True, use_speech_tags_filter=False):
"""
:param text: 要进行分词的文本
:param lower: 是否要将单词小写，针对英文
:param user_stop_words: 若为True，表示使用停用词集合进行过滤，去掉停用词
:param use_speech_tags_filter:是否基于词性进行过滤，若为True，则使用默认的词性列表进行过滤
:return:词性过滤后的词列表
"""
# 待分词的文本
text = util.as_text(text)
# 词性标注结果列表
jieba_result = pseg.cut(text)
if use_speech_tags_filter == True:
# 进行词性过滤后的词性标注结果
jieba_result = [w for w in jieba_result if w.flag in self.default_speech_tags_filter]
else:
# 不进行词性过滤的词性标注结果
jieba_result = [w for w in jieba_result]
# 去除特殊符号
# 去除非语素字和词两端的空格
# 非语素字只是一个符号，字母x通常用于代表未知数、符号
word_list = [w.word.strip() for w in jieba_result if w.flag != 'x']
# 去除空字符
word_list = [word for word in word_list if len(word) > 0]
# 是否将英文单词小写
if lower:
word_list = [word.lower() for word in word_list]
# 是否使用停用词集合进行过滤
if user_stop_words:
word_list = [word.strip() for word in word_list if word.strip() not in self.stop_words]
# 返回词性过滤后的词列表
return word_list
"""将列表sentences中的每个元素/句子转换为由单词构成的列表"""
def segment_sentences(self, sentences, lower=True, user_stop_words=True, user_speech_tags_filter=False):
"""
:param sentences: 句子列表
:return: 以词性过滤后的词列表为元素的列表
"""
res = []
for sentence in sentences:
# 调用segment方法，将词性过滤后的词列表加入到列表中
res.append(self.segment(text=sentences, lower=lower, user_stop_words=user_stop_words, use_speech_tags_filter=user_speech_tags_filter))
# 返回以词性过滤后的词列表为元素的列表
return res
"""分句类"""
class SentenceSegmentation(object):
"""初始化函数，获取用于分句的分隔符集合"""
def __init__(self, delimiters=util.sentence_delimiters):
"""
:param delimiters: 可迭代对象，用于拆分句子
"""
self.delimiters = set([util.as_text(item) for item in delimiters])
"""将文本划分为句子，返回句子列表"""
def segment(self, text):
# 获取文本
res = [util.as_text(text)]
# 调试
util.debug(res)
util.debug(self.delimiters)
# 分句，使用了两层循环
# 遍历分隔符对象
for sep in self.delimiters:
# res表示分句结果
text, res = res, []
# 遍历文本对象
for seq in text:
# 分句操作
res += seq.split(sep)
# 去除句子两端空格，并滤除空句
res = [s.strip() for s in res if len(s.strip() > 0)]
# 返回句子列表
return res
"""分割类"""
class Segmentation(object):
"""初始化函数"""
def __init__(self, stop_word_file=None, allow_speech_tags=util.allow_speech_tags, delimiters=util.sentence_delimiters):
"""
:param stop_word_file: 停用词文件
:param allow_speech_tags: 词性列表，用于过滤某些词性的词
:param delimiters: 用于拆分句子的分隔符
"""
# 创建分词类的实例
self.ws = WordSegmentation(stop_word_file=stop_word_file, allow_speech_tags=allow_speech_tags)
# 创建分句类的实例
self.ss = SentenceSegmentation(delimiters=delimiters)
def segment(self, text, lower=False):
# 获取文本
text = util.as_text(text)
# 拆分文本，得到句子列表
sentences = self.ss.segment(text)
# 未进行词性过滤后的词列表
words_no_filter = self.ws.segment_sentences(sentences=sentences, lower=lower, user_stop_words=False, user_speech_tags_filter=False)
# 去掉停用词后的词列表
words_no_stop_words = self.ws.segment_sentences(sentences=sentences, lower=lower, user_stop_words=True, user_speech_tags_filter=False)
# 进行词性过滤并去掉停用词后的词列表
words_all_filters = self.ws.segment_sentences(sentences=sentences, lower=lower, user_stop_words=True, user_speech_tags_filter=True)
# 返回以上结果
return util.AttrDict(sentences=sentences, words_no_filter=words_no_filter, words_no_stop_words=words_no_stop_words, words_all_filters=words_all_filters)
# 主模块
if __name__ == '__main__':
# 空语句，保持程序结构的完整性
pass
TextRank4Keyword.py：包含用于提取关键词和关键词组的类。
#-*-coding:utf-8-*-
# 把新版本的特性引入当前版本
from __future__ import (absolute_import, division, print_function, unicode_literals)
# 导入操作复杂网络的模块
import networkx as nx
# 导入数值计算模块
import numpy as np
# 导入工具包组件
from textrank4zh import util
# 导入Segmentation文件
from textrank4zh.Segmentation import Segmentation
class TextRank4Keyword(object):
"""初始化函数"""
def __init__(self, stop_words_file=None, allow_speech_tags=util.allow_speech_tags, delimiters=util.sentence_delimiters):
"""
:param stop_words_file:str类型，指定停用词文件的路径，若为其他类型，则使用默认的停用词文件
:param allow_speech_tags:词性列表，用于过滤某些词性的词
:param delimiters:用于拆分句子的分隔符，默认值为`?!;？！。；…\n`
"""
self.text = ''
self.Keywords = None
# 创建分割类的实例
self.seg = Segmentation(stop_words_file=stop_words_file, allow_speech_tags=allow_speech_tags, delimiters=delimiters)
# 句子列表
self.sentences = None
# 对sentences中每个句子分词而得到的两维列表
self.words_no_filter = None
# 去掉words_no_filter中的停止词而得到的两维列表
self.word_no_stop_words = None
# 保留words_no_stop_words中指定词性的单词而得到的两维列表
self.words_all_filters = None
"""分析文本的函数，体现算法思想的部分"""
def analyze(self, text, window=2, lower=False, vertex_source='all_filters', edge_source='no_stop_words', pagerank_config={'alpha': 0.85,}):
"""
:param text: 文本内容
:param window: 窗口大小，整型，用于构造单词之间的边，去默认值为2
:param lower: 是否将英文文本转换为小写，默认值为False
:param vertex_source: 选择使用words_no_filter, words_no_stop_words, words_all_filters中的哪一个来构造pagerank对应的图中的节点。默认值为`'all_filters'`，可选值为`'no_filter', 'no_stop_words', 'all_filters'`。关键词也来自`vertex_source`
:param edge_source:选择使用words_no_filter, words_no_stop_words, words_all_filters中的哪一个来构造pagerank对应的图中的节点之间的边。默认值为`'no_stop_words'`，可选值为`'no_filter', 'no_stop_words', 'all_filters'`。边的构造要结合`window`参数。
:param pagerank_config:pagerank算法参数配置，阻尼系数为0.85
"""
self.text = text
self.word_index = {}
self.index_word = {}
# 关键词列表
self.keywords = []
self.graph = None
result = self.seg.segment(text=text, lower=lower)
self.sentences = result.sentences
self.words_no_filter = result.words_no_filter
self.word_no_stop_words = result.word_no_stop_words
self.words_all_filters = result.words_all_filters
# 调试
util.debug(20 * '*')
util.debug('self.sentences in TextRank4Keyword:\n', ' || '.join(self.sentences))
util.debug('self.words_no_filter in TextRank4Keyword:\n', self.words_no_filter)
util.debug('self.words_no_stop_words in TextRank4Keyword:\n', self.words_no_stop_words)
util.debug('self.words_all_filters in TextRank4Keyword:\n', self.words_all_filters)
# 选项，几种模式
options = ['no_filter', 'no_stop_words', 'all_filters']
# 模式选择
if vertex_source in options:
_vertex_source = result['words_' +vertex_source]
else:
_vertex_source = result['words_all_filters']
if edge_source in options:
_edge_source = result['words_' + edge_source]
else:
_edge_source = result['words_no_stop_words']
self.keywords = util.sort_words(_vertex_source, _edge_source, window=window, pagerank_config=pagerank_config)
"""获取最重要的num个长度大于等于word_min_len的关键词"""
def get_keywords(self, num=6, word_min_len=1):
"""
:param num: 返回的关键词个数
:param word_min_len: 最小关键词长度
:return: 关键词列表
"""
result = []
count = 0
for item in self.keywords:
if count >= num:
break
if len(item.word) >= word_min_len:
result.append(item)
count += 1
return result
"""获取 keywords_num 个关键词构造的可能出现的短语，要求这个短语在原文本中至少出现的次数为min_occur_num"""
def get_keyphrases(self, keywords_num=12, min_occur_num=2):
"""
:param keywords_num: 返回的关键词短语个数
:param min_occur_num: 短语在文本中的最小出现次数
:return: 关键词短语列表
"""
# 关键词集合
keywords_set = set([item.word for item in self.get_keywords(num=keywords_num, word_min_len=1)])
# 关键词短语集合
keyphrases = set()
for sentence in self.words_no_filter:
one = []
for word in sentence:
if word in keywords_set:
one.append(word)
else:
if len(one) > 1:
# 将关键词组成关键词短语
keyphrases.add(''.join(one))
if len(one) == 0:
continue
else:
one = []
# 兜底
if len(one) > 1:
keyphrases.add(''.join(one))
# 在原文本中至少出现min_occur_num词
return [phrase for phrase in keyphrases if self.text.count(phrase) >= min_occur_num]
# 主模块
if __name__ == '__main__':
# 空语句，保持程序结构的完整性
pass
TextRank4Sentence.py：包含用于提取关键句的类。
# -*- encoding:utf-8 -*-
"""
@author: letian
@homepage: http://www.letiantian.me
@github: https://github.com/someus/
"""
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import networkx as nx
import numpy as np
from . import util
from .Segmentation import Segmentation
class TextRank4Sentence(object):
def __init__(self, stop_words_file=None,
allow_speech_tags=util.allow_speech_tags,
delimiters=util.sentence_delimiters):
"""
Keyword arguments:
stop_words_file -- str，停止词文件路径，若不是str则是使用默认停止词文件
delimiters -- 默认值是`?!;？！。；…\n`，用来将文本拆分为句子。
Object Var:
self.sentences -- 由句子组成的列表。
self.words_no_filter -- 对sentences中每个句子分词而得到的两级列表。
self.words_no_stop_words -- 去掉words_no_filter中的停止词而得到的两级列表。
self.words_all_filters -- 保留words_no_stop_words中指定词性的单词而得到的两级列表。
"""
self.seg = Segmentation(stop_words_file=stop_words_file,
allow_speech_tags=allow_speech_tags,
delimiters=delimiters)
self.sentences = None
self.words_no_filter = None # 2维列表
self.words_no_stop_words = None
self.words_all_filters = None
self.key_sentences = None
def analyze(self, text, lower=False,
source='no_stop_words',
sim_func=util.get_similarity,
pagerank_config={'alpha': 0.85, }):
"""
Keyword arguments:
text -- 文本内容，字符串。
lower -- 是否将文本转换为小写。默认为False。
source -- 选择使用words_no_filter, words_no_stop_words, words_all_filters中的哪一个来生成句子之间的相似度。
默认值为`'all_filters'`，可选值为`'no_filter', 'no_stop_words', 'all_filters'`。
sim_func -- 指定计算句子相似度的函数。
"""
self.key_sentences = []
result = self.seg.segment(text=text, lower=lower)
self.sentences = result.sentences
self.words_no_filter = result.words_no_filter
self.words_no_stop_words = result.words_no_stop_words
self.words_all_filters = result.words_all_filters
options = ['no_filter', 'no_stop_words', 'all_filters']
if source in options:
_source = result['words_' + source]
else:
_source = result['words_no_stop_words']
self.key_sentences = util.sort_sentences(sentences=self.sentences,
words=_source,
sim_func=sim_func,
pagerank_config=pagerank_config)
def get_key_sentences(self, num=6, sentence_min_len=6):
"""获取最重要的num个长度大于等于sentence_min_len的句子用来生成摘要。
Return:
多个句子组成的列表。
"""
result = []
count = 0
for item in self.key_sentences:
if count >= num:
break
if len(item['sentence']) >= sentence_min_len:
result.append(item)
count += 1
return result
if __name__ == '__main__':
pass
2 textrank4zh模块的使用
2.1 textrank4zh模块的安装
这里介绍几种安装Python模块的方法，仅供参考。
1）python setup.py install --user
2）sudo python setup.py install
3）pip install textrank4zh --user
4）sudo pip install textrank4zh
textrank4zh模块在python2或python3中均可使用，它所依赖的其他模块要求满足：
jieba >= 0.35； numpy >= 1.7.1；networkx >= 1.9.1
2.2 textrank4zh的使用实例
因为操作比较简单，所有直接以代码的形式展示例子，代码在python3环境下亲测可用。
1）提取关键词、关键短语和关键句
#-*-coding:utf-8-*-
"""
@author:taoshouzheng
@time:2018/5/18 8:20
@email:[email protected]
"""
# 导入系统模块
import sys
# imp模块提供了一个可以实现import语句的接口
from imp import reload
# 异常处理
try:
# reload方法用于对已经加载的模块进行重新加载，一般用于原模块有变化的情况
reload(sys)
# 设置系统的默认编码方式，仅本次有效，因为setdefaultencoding函数在被系统调用后即被删除
sys.setdefaultencoding('utf-8')
except:
pass
"""
展示textrank4zh模块的主要功能：
提取关键词
提取关键短语（关键词组）
提取摘要（关键句）
"""
# 导入编码转换模块
import codecs
# 从textrank4zh模块中导入提取关键词和生成摘要的类
from textrank4zh import TextRank4Keyword, TextRank4Sentence
# 待读取的文本文件，一则新闻
file = r'C:\Users\Tao Shouzheng\Desktop\01.txt'
# 打开并读取文本文件
text = codecs.open(file, 'r', 'utf-8').read()
# 创建分词类的实例
tr4w = TextRank4Keyword()
# 对文本进行分析，设定窗口大小为2，并将英文单词小写
tr4w.analyze(text=text, lower=True, window=2)
"""输出"""
print('关键词为：')
# 从关键词列表中获取前20个关键词
for item in tr4w.get_keywords(num=20, word_min_len=1):
# 打印每个关键词的内容及关键词的权重
print(item.word, item.weight)
print('\n')
print('关键短语为：')
# 从关键短语列表中获取关键短语
for phrase in tr4w.get_keyphrases(keywords_num=20, min_occur_num=2):
print(phrase)
print('\n')
# 创建分句类的实例
tr4s = TextRank4Sentence()
# 英文单词小写，进行词性过滤并剔除停用词
tr4s.analyze(text=text, lower=True, source='all_filters')
print('摘要为：')
# 抽取3条句子作为摘要
for item in tr4s.get_key_sentences(num=3):
# 打印句子的索引、权重和内容
print(item.index, item.weight, item.sentence)
结果如下：
关键词为：
媒体 0.02155864734852778
高圆圆 0.020220281898126486
微 0.01671909730824073
宾客 0.014328439104001788
赵又廷 0.014035488254875914
答谢 0.013759845912857732
谢娜 0.013361244496632448
现身 0.012724133346018603
记者 0.01227742092899235
新人 0.01183128428494362
北京 0.011686712993089671
博 0.011447168887452668
展示 0.010889176260920504
捧场 0.010507502237123278
礼物 0.010447275379792245
张杰 0.009558332870902892
当晚 0.009137982757893915
戴 0.008915271161035208
酒店 0.00883521621207796
外套 0.008822082954131174
关键短语为：
微博
>摘要为：
0 0.07097195571711616 中新网北京12月1日电(记者 张曦) 30日晚，高圆圆和赵又廷在京举行答谢宴，诸多明星现身捧场，其中包括张杰(微博)、谢娜(微博)夫妇、何炅(微博)、蔡康永(微博)、徐克、张凯丽、黄轩(微博)等
6 0.05410372364148859 高圆圆身穿粉色外套，看到大批记者在场露出娇羞神色，赵又廷则戴着鸭舌帽，十分淡定，两人快步走进电梯，未接受媒体采访
27 0.04904283129838876 记者了解到，出席高圆圆、赵又廷答谢宴的宾客近百人，其中不少都是女方的高中同学
2）展示textrank4zh模块的三种分词模式的效果
三种分词模式分别为：
words_no_filter模式：简单分词，不剔除停用词，不进行词性过滤
words_no_stop_words模式：剔除停用词
words_all_filters模式（默认）：即剔除停用词，又进行词性过滤
#-*-coding:utf-8-*-
"""
@author:taoshouzheng
@time:2018/5/18 14:52
@email:[email protected]
"""
import codecs
from imp import reload
from textrank4zh import TextRank4Keyword, TextRank4Sentence
import sys
try:
reload(sys)
sys.setdefaultencoding('utf-8')
except:
pass
"""测试3类分词的效果"""
text = '这间酒店位于北京东三环，里面摆放很多雕塑，文艺气息十足。答谢宴于晚上8点开始。'
tr4w = TextRank4Keyword()
tr4w.analyze(text=text, lower=True, window=2)
# 将文本划分为句子列表
print('sentences:')
for s in tr4w.sentences:
print(s)
print('\n')
# 对句子列表中的句子进行分词，不进行词性过滤
print('words_no_filter:')
# words为词列表，tr4w.words_no_filter为由词列表组成的列表
for words in tr4w.words_no_filter:
print('/'.join(words))
print('\n')
# 打印去掉停用词的词列表
print('words_no_stop_words:')
for words in tr4w.words_no_stop_words:
print('/'.join(words))
print('\n')
# 打印去掉停用词并进行词性过滤之后的词列表
print('words_all_filters:')
for words in tr4w.words_all_filters:
print('/'.join(words))
结果如下：
<span style="font-family:SimSun;">sentences:
这间酒店位于北京东三环，里面摆放很多雕塑，文艺气息十足
答谢宴于晚上8点开始
words_no_filter:
这/间/酒店/位于/北京/东三环/里面/摆放/很多/雕塑/文艺/气息/十足
答谢/宴于/晚上/8/点/开始
words_no_stop_words:
间/酒店/位于/北京/东三环/里面/摆放/很多/雕塑/文艺/气息/十足
答谢/宴于/晚上/8/点
words_all_filters:
酒店/位于/北京/东三环/摆放/雕塑/文艺/气息
答谢/宴于/晚上</span>
值得参考的文章，附上链接如下：