def get_sentiments(from_date, to_date):
s = SnowNLP(u'''1、中信证券在经纪、投行业务市场份额中均处于行业领先地位,为新业务的扩张提供了优质的客户和渠道基础;
2、对经纪业务依赖度较低,在差异化转型中已经具有先发优势;
3、净资本规模、风控水平和综合能力使其成为新业务试点的首选券商,将长期享受“优先布局”的去监管政策红利。
去监管政策逐项落地将使行业估值底部逐步抬升。
自下而上创新过程中,证券公司在支付、托管、交易等基础功能领域正逐步扩展。
去监管政策阶段性推出、逐步验证利润的过程将使行业估值底部在震荡中逐步抬升''')
for sub in s.summary(5):
print sub
s = SnowNLP(u'中信证券:12年净利润同比下滑66.2% 600030 中信证券(600030.CH/人民币13.85;6030.HK/港币20.40,持有)昨日发布业绩快报,2012年实现归属于上市公司股东的净利润42.55亿元,同比下滑66.2%。 我们对此评论如下: 1)中信证券利润同比大幅下滑的主要原因,是由于公司在2011年出售华夏基金51%的股权而实现约131亿元的投资收益,如果剔除这部分一次性收益的影响,我们估计中信证券2012年净利润同比正增长50%左右,在艰难的市场环境下能实现这样的业绩已属不易。中信证券前三季度净利润同比下滑12.4%,能在4季度实现业绩反转,我们估计主要是得益于有效的人员费用控制,12月份A股市场的强劲反弹以及金石投资等子公司的良好表现。 2)2012年A股市场总体表现不佳,两市股票成交量同比下滑29.4%,IPO融资金额下降63.4%。在不利的市场环境下,中信证券经营仍有亮点:其投资银行业务表现强劲,股权承销金额同比仅下降13%,债券承销金额则同比增长37%;融资融券业务发展迅速,年末余额达88亿元,市场份额9.9%,在各券商中排名第一。 3)目前中信证券A股股价相当于1.76倍2012年市净率或1.67倍2013年市净率,35.84倍2012年市盈率或24.89倍2013年市盈率;H股股价相当于2.09倍2012年市净率或1.97倍2013年市净率,42.49倍2012年市盈率或29.51倍2013年市盈率。我们预测中信证券2013年净利润同比增速将在44%,但其ROE仅能从2012年的4.92%上升至6.88%,估值相比ROE仍然偏高。我们认为券商股的投资价值主要在于大盘反弹时的高弹性,因此短期策略仍以把握交易性机会为主。维持对中信证券A股和H股的持有评级不变。')
for sub in s.summary(5):
print(sub)
print SnowNLP(sub).sentiments
def single():
content = u""
if request.method == 'GET':
content = u"12日上午，国家主席习近平同美国总统特朗普通电话。两国元首就朝鲜半岛局势等共同关心的问题交换了意见。习近平强调，中方坚持实现半岛无核化目标，坚持维护半岛和平稳定，主张通过和平方式解决问题，愿同美方就半岛问题保持沟通协调。关于叙利亚问题，习近平指出，任何使用化学武器的行为都不可接受。叙利亚问题要坚持政治解决的方向。联合国安理会保持团结对解决叙利亚问题非常重要，希望安理会发出一致声音。两国元首同意通过各种方式保持密切联系。"
if request.method == 'POST':
content = request.form['content']
content = re.sub(u'(\s|\n|t)', u'', content)
print content
seg_list = [(word, flag) for word, flag in pseg.cut(content)]
textrank_key_list = analyse.textrank(content, topK=5, withWeight=True)
tf_idf_key_list = analyse.tfidf(content, topK=5, withWeight=True)
s = sentiment.Sentiment()
sentiment_score = s.single_review_sentiment_score(content)
sentiment_score_up = (math.atan(sentiment_score) * 2 / math.pi +
1) / 2 * 100
sentiment_score_down = 100 - sentiment_score_up
s = SnowNLP(content)
summary = s.summary(3)
# print key_list
# print("Default Mode: " + "/ ".join(seg_list)) # 精确模式
return render_template(
"single.html",
seg_list=seg_list,
textrank_key_list=textrank_key_list,
tf_idf_key_list=tf_idf_key_list,
sentiment_score_up=sentiment_score_up,
sentiment_score_down=sentiment_score_down,
summary=summary,
content=content,
)
def wordseg(method):
cfg_path = os.path.expanduser(u'~/.nomadic')
# Open the config file.
with open(cfg_path, 'r') as cfg_file:
user_cfg = json.load(cfg_file)
config.update(user_cfg)
notepath = config['root']
#testnote = str(notepath + '/wdxtub.md')
h = codecs.open(testnote, 'r', 'utf-8')
text = h.read()
if method == 1:
seg_list = jieba.cut(text, cut_all=False)
fh = codecs.open('./seg/test.txt', 'w', 'utf-8')
fh.write(' '.join(seg_list))
tags = jieba.analyse.extract_tags(text, topK=10)
print(",".join(tags))
elif method == 2:
s = SnowNLP(text)
for w in s.keywords(10):
print w.encode('utf-8')
for su in s.summary(3):
print su.encode('utf-8')
print 'done'
def summary(route):
file = open(route)
text = file.read()
s = SnowNLP(text)
words = s.summary(1)
result = str(words).replace("'", "").replace("[", "").replace("]", "")
return result
def Spider_how(sentence):
sentence = urllib2.quote(sentence)
url = 'http://jingyan.baidu.com/search?word='
finalUrl = url + sentence
webpage = urllib2.urlopen(finalUrl)
text = webpage.read()
soup = BeautifulSoup(text)
website = soup.findAll(log = "type:1000,pos:search_result,num:1")[0]
postfix = website['href']
result = 'http://jingyan.baidu.com'
finalresult = result + postfix
resultpage = urllib2.urlopen(finalresult)
text = resultpage.read()
result_soup = BeautifulSoup(text)
readable_text = result_soup.findAll('p')
readable_text = readable_text[1:]
preprocess = ''
for line in readable_text:
for sub_line in str(line).split('。'):
preprocess = preprocess + sub_line + '\n'
text = strip_tags(preprocess)
print text
text = SnowNLP(text)
summary_text = ''
for line in text.summary(3):
summary_text = summary_text + line+'\n'
print summary_text
return summary_text
def Spider_zhihu(sentence):
sentence = urllib2.quote(sentence)
url = 'http://www.zhihu.com/search?q='
finalUrl = url + sentence + '&type=question'
webpage = urllib2.urlopen(finalUrl)
text = webpage.read()
soup = BeautifulSoup(text)
website = soup.findAll(attrs = {'class' :"question_link"})[0]
print website
postfix = website['href']
result = 'http://www.zhihu.com'
finalresult = result + postfix
resultpage = urllib2.urlopen(finalresult)
text = resultpage.read()
result_soup = BeautifulSoup(text)
readable_text = result_soup.findAll(attrs = {'data-action' :'/answer/content'})[0]
#readable_text = readable_text[1:]
print readable_text
preprocess = ''
for line in readable_text:
for sub_line in str(line).split('。'):
preprocess = preprocess + sub_line + '\n'
text = strip_tags(preprocess)
print text
text = SnowNLP(text)
summary_text = ''
for line in text.summary(3):
summary_text = summary_text + line+'\n'
print summary_text
return summary_text
def summary():
"""
简述提取
:return:
"""
client = MongoClient(**MONGO_DATABASE)
db = client.data
for it in db.news.find({"machine_summary": {"$exists": False}}):
content = it.get("content_text")
title = it.get("title")
try:
if content is not None and content != "":
content = content.strip()
snownlp = SnowNLP(content)
summary = snownlp.summary(1)
logging.debug("content:{0}".format(content))
logging.debug("summary:{0}".format(summary))
elif title:
summary = title if type(title) == list else [title]
logging.debug("title:{0}".format(summary[0]))
logging.debug("summary:{0}".format(summary))
db.news.update_one({"_id": it.get("_id")},
{"$set": {
"machine_summary": summary[0]
}})
except Exception as e:
logging.error("数据{0}提取简述异常:{1}".format(content,
traceback.format_exc()))
continue
def cal_summary():
article_list = get_test_article_list()
result_list = []
for i, article in enumerate(article_list):
s = SnowNLP(article.decode('utf8'))
keysentence_list = s.summary(20)
keysentence_list = [ks.encode("utf8") for ks in keysentence_list]
result = ""
for j, sentence in enumerate(keysentence_list):
sentence = re.sub('\d{4,}', '', sentence).decode("utf8")
if j == 0 and len(sentence) > 59:
result = sentence[:59]
result += u"。"
break
if (len(result) + len(sentence)) <= 59:
result += sentence
result += u"，"
else:
break
#print type(result)
if result[-1] == u"，":
result = result[:-2] + u"。"
result_list.append(result)
print i, result
return result_list
def wordseg(method):
cfg_path = os.path.expanduser(u'~/.nomadic')
# Open the config file.
with open(cfg_path, 'r') as cfg_file:
user_cfg = json.load(cfg_file)
config.update(user_cfg)
notepath = config['root']
#testnote = str(notepath + '/wdxtub.md')
h = codecs.open(testnote, 'r', 'utf-8')
text = h.read()
if method == 1:
seg_list = jieba.cut(text, cut_all=False)
fh = codecs.open('./seg/test.txt', 'w', 'utf-8')
fh.write(' '.join(seg_list))
tags = jieba.analyse.extract_tags(text, topK=10)
print(",".join(tags))
elif method == 2:
s = SnowNLP(text)
for w in s.keywords(10):
print w.encode('utf-8')
for su in s.summary(3):
print su.encode('utf-8')
print 'done'
def get_person_str(ws, pos, ner, old_q_input):
snow_nlp = SnowNLP(old_q_input)
snow_summer_list = snow_nlp.summary(10)
context = ",".join(snow_summer_list)
sentence_list = [context]
word_sentence_list = ws(
sentence_list,
# sentence_segmentation = True, # To consider delimiters
# segment_delimiter_set = {",", "。", ":", "?", "!", ";"}), # This is the defualt set of delimiters
# recommend_dictionary = dictionary1, # words in this dictionary are encouraged
# coerce_dictionary = dictionary2, # words in this dictionary are forced
)
pos_sentence_list = pos(word_sentence_list)
entity_sentence_list = ner(word_sentence_list, pos_sentence_list)
#print(entity_sentence_list)
set_entity = set()
for i, sentence in enumerate(sentence_list):
#print()
#print(f"'{sentence}'")
#print_word_pos_sentence(word_sentence_list[i], pos_sentence_list[i])
for entity in sorted(entity_sentence_list[i]):
if entity[2] == 'PERSON':
#print(entity[3])
set_entity.add(entity[3].replace(" ", ""))
str_entity = ','.join(set_entity)
#print(str_entity)
return str_entity.split(",")
def cal_rouge_snownlp(article_lst, summ_lst):
rouge = Rouge()
rouges = np.zeros((3, 3))
cnt = 0
for article, summ in zip(*(article_lst, summ_lst)):
s = SnowNLP(article)
hyps = s.summary(5)
hyps = "，".join(hyps)
hyps = clean(hyps)
summ = summ.strip()
summ = clean(summ)
summ_ids, hyps_ids = word_for_rouge(summ, hyps)
rouge_score = rouge.get_scores(" ".join(hyps_ids)[:len(summ)],
" ".join(summ_ids))
rouge1 = rouge_score[0]["rouge-1"]
rouge2 = rouge_score[0]["rouge-2"]
rougel = rouge_score[0]["rouge-l"]
rouges[0] += np.array(list(rouge1.values()))
rouges[1] += np.array(list(rouge2.values()))
rouges[2] += np.array(list(rougel.values()))
cnt += 1
rouges = rouges / cnt
print("Rouge: Rouge-1 : F P R")
print("Rouge: Rouge-2 : F P R")
print("Rouge: Rouge-L : F P R")
print(rouges)
def extractSummary(sentences,N):
# print("extractSummary")
# if(sentences.)
# print(sentences[0:50])
s = SnowNLP(sentences)
ret = s.summary(N)
# print(ret)
print("suc")
return ret
def get_article_summary_res(res):
summary_res = set()
s = SnowNLP(res)
for su in s.summary(8):
#print "summary:"
summary_res.add(su.strip().replace("\xe3\x80\x80", ""))
#for item in summary_res:
# print item
return summary_res
def summary(*args):
try:
args = str(args)
chars = SnowNLP(args)
chars = "".join(chars.summary(5))
chars = chars.replace('\r\n', '')
return chars
except TypeError:
return args
def summary_candidate_fin(text):
tr4s = TextRank4Sentence()
tr4s.analyze(text=text, lower=True, source='all_filters')
#設定只保留中文、英文、數字（去掉韓語日語德語，也會去掉表情符號等等）
#reference: https://zhuanlan.zhihu.com/p/84625185
rule = re.compile(u"[^a-zA-Z0-9\u4e00-\u9fa5]")
#print( '摘要：' )
tt = []
for i, item in enumerate(tr4s.get_key_sentences(num=3,
sentence_min_len=80)):
#print('第{}順位，利用textrank的第一次摘要: '.format(i+1))
#print(item.index, item.weight, item.sentence)
s = SnowNLP(item.sentence)
#print('利用snownlp再取一次的結果: ')
secnd_sn = s.summary(3)
#print(secnd_sn)
for cont in secnd_sn:
ttt = rule.sub(' ', str(cont))
if len(ttt.split(' ')) < 3 and len(ttt) > 12:
tt.append(ttt)
#print(' ')
s = SnowNLP(text)
#print('直接使用snownlp的摘要: ')
word = {}
first_sn = s.summary(3)
for cont in first_sn:
ttt = rule.sub(' ', str(cont))
if len(ttt.split(' ')) < 3 and len(ttt) > 12:
if word.get(ttt) == None:
word[ttt] = 1
tt.append(ttt)
#print(first_sn)
#print(' ')
if len(tt) == 0:
print('無適合的標題')
tt.append("無適合的標題")
return tt
return tt
def abstract_text(texts, n=3):
"""
提取整个字符串的摘要
:param texts: 字符串
n: 整数类型，字符串摘要的数目
:return: 返回摘要
"""
ab_text = SnowNLP(tests)
text_abstract = ab_text.summary(n)
return text_abstract
def snowanalysis(self):
for li in self.message:
s = SnowNLP(li)
self.sentimentslist.append(s.sentiments)
self.summary.append(s.summary(3))
print(len(self.sentimentslist))
plt.hist(self.sentimentslist, bins=np.arange(0, 1, 0.01))
plt.savefig("./sentiment.png")
plt.figure('情感分析图')
plt.show()
def __call__(self, image_path):
print(image_path)
# assert not os.path.exists(image_path), "The image does not exist!"
image = Image.open(image_path)
text = pytesseract.image_to_string(image, lang='chi_sim')
text = self.__preprocessing(text)
s = SnowNLP(text)
topK_titles = s.summary(self.topK)
return topK_titles
def keyword_summary(self, j_data):
text = self.json_text(j_data)
a1 = SnowNLP(text)
a2 = a1.summary(2)
# keywords1 = self.keyword_TR(j_data)
keywords2 = self.keyword_IDF(j_data)
a2_str = ",".join(a2)
ret = "{\"keyword\":[" + keywords2 + "], \"summary\":\"" + a2_str + "\"}"
# print ret
return ret
def main(options):
print("text")
text = strip_tags(get_text(options))
print(text)
s = SnowNLP(text)
print("Summary:")
for summary in s.summary(3):
print(summary)
print("Keywords:")
for keyword in s.keywords():
print(keyword)
def print_snow(text):
s = SnowNLP(text)
print('words: ', s.words)
print('tags: ', s.tags)
print('sentiment: ', s.sentiments)
print('pinyin: ', s.pinyin)
print('han: ', ' '.join(s.han.split('\n')))
print('keywords(3): ', s.keywords(3))
print('summary(3): ', s.summary(3))
print('sentences: ', s.sentences)
print('+++++++++++++++++++++++++++++++++++++')
def runDemo():
s = SnowNLP(u'这个东西真心很赞')
print("原句：%s" % s.doc)
# 分词
print("分词：" + " ".join(s.words))
print("词性分析： %s" % list(s.tags))
print("情感化程度： %f" % s.sentiments) # 情感化程度0~1 ,越接近1表示正面情绪,越接近0表示负面情绪
print("拼音： %s" % s.pinyin)
print("\n")
s = SnowNLP(u'「繁體字」「繁體中文」的叫法在臺灣亦很常見。')
# 翻译成简体中文
print("简化字： %s" % s.han)
print("\n")
text = u'''
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此，这一领域的研究将涉及自然语言，即人们日常使用的语言，
所以它与语言学的研究有着密切的联系，但又有重要的区别。
自然语言处理并不是一般地研究自然语言，
而在于研制能有效地实现自然语言通信的计算机系统，
特别是其中的软件系统。因而它是计算机科学的一部分。
'''
s = SnowNLP(text)
print("原句：%s" % s.doc)
# 关键词提取
print("关键词： %s" % s.keywords(3))
# 摘要生成
print("摘要三句话： %s " % s.summary(3)) # [u'因而它是计算机科学的一部分',
# u'自然语言处理是一门融语言学、计算机科学、
# 数学于一体的科学',
# u'自然语言处理是计算机科学领域与人工智能
# 领域中的一个重要方向']
print(s.sentences)
print("\n")
l = [[u'这篇', u'文章'], [u'那篇', u'论文'], [u'这个']]
print("假设有这么三句话,已分词： %s" % l)
s = SnowNLP(l)
#计算相似度
print("计算与'文章'这个词汇的相似度，也可以是分词后的句子")
print(s.sim([u'文章'])) # [0.3756070762985226, 0, 0]
def get_summarize(texts):
if len(texts) > 850:
key_sen = 50
else:
key_sen = np.round(len(texts) / 15).astype('int')
#key_sen = 50
summ = SnowNLP(texts)
t_keysen = summ.summary(key_sen)
# sents = []
# for t in t_keysen:
# sents.extend(sent_tokenize(t))
return t_keysen
def GetNewsUrlSummary(self,newsUrl):
newsTextNodeSoup = self.GetNewsTextNodeSoup(newsUrl)
newsText = " ".join(map(lambda node : node.get_text(),newsTextNodeSoup))
try:
newsText = unicode(newsText)
except:
pass
snow = SnowNLP(newsText)
summaryList = snow.summary(3)
map(lambda aPieceSummary:(len(aPieceSummary) > self.MaxSummaryLen) and summaryList.remove(aPieceSummary),summaryList)
summaryText = " ".join(summaryList)
if len(summaryText) > self.MaxSummaryLen:
summaryText = summaryText[0:self.MaxSummaryLen]
return summaryText
def requestSina(startPage, endPage):
# 数据库链接，填入你的 mysql 数据库用户名和密码
dbUtil = DatabaseConnector(user='******', password='******')
for i in range(startPage, endPage):
try:
# 打开网页，获取网页内容
response = requests.get(rootURL,
params=globalParams(i),
headers=headers)
if response.status_code == 200:
# 网页为 gbk 编码，需要进行转码
gbkContent = response.content.decode('gbk')
j = json.loads(gbkContent)
data = j['result']['data']
for d in data:
title = d['title'] # 标题
url = d['url'] # 新闻链接
keywords = d['keywords'] # 关键词（如有，没有的话也用 TextRank 算法提取）
ctime = datetime.fromtimestamp(int(d['ctime'])) # 新闻时间
print(title, '-> 获取新闻内容')
_content = requestContent(url)
content = '' # 新闻正文
if len(_content) > 0:
content = '\n'.join(_content)
# ！！！SnowNLP 这个库中的关键词提取、摘要提取就是用的 TextRank 算法
# 论文中可以详细介绍这一算法：http://www.hankcs.com/nlp/textrank-algorithm-java-implementation-of-automatic-abstract.html
# 主要思路：分词后根据句子中的词，计算出每个句子的一个向量表示，根据相邻句子对当前句子的"贡献"，以相似度为权重，计算当前句子的重要程度，最重要的句子即为摘要
s = SnowNLP(content)
# 利用 TextRank 提取最重要的 10 个关键词
keywords10 = s.keywords(10)
_keywords = [
x for x in keywords10
if (len(x) > 1 and validKeywords(x))
]
if not keywords:
keywords = ','.join(_keywords)
# 生成一个三句话的摘要
_summary = s.summary(3)
summary = '|'.join(_summary)
# 写入数据库，供查询展示
dbUtil.insertOne(title, content, keywords, summary,
url, ctime)
# 暂停一下，避免爬虫太频繁
time.sleep(random.random() * 10.0)
except requests.RequestException:
# 爬虫程序无法获取网页内容
print('Cannot get or response')
# 每一组也暂停 30s
time.sleep(30)
def index(request):
context = {}
if request.method == 'POST':
news = request.POST['newsInput']
context['raw_input'] = news
if news:
snow = SnowNLP(news)
summary = snow.summary(3)
_summay_all = ' '.join(summary)
context['summary'] = summary
result = predict(model, MODEL_PATH, _summay_all)
context['result'] = result
else:
context['error'] = '输入错误，请重新输入！'
return render(request, 'news_classification/index.html', context=context)
def get(self, article_sid, type):
args = parser.parse_args()
if type == 'extract':
article = self.db.get('select title,content from article where sid=%s', (article_sid,))
s = SnowNLP(article['content'])
keywords = s.keywords()
abstract = s.summary()
keywords = ','.join(keywords)
abstract = ','.join(abstract)
self.db.update('update article set keywords=%s,abstract=%s,processed=1 where sid=%s',
(keywords, abstract, article_sid))
return {
'sid': article_sid,
'keywords': keywords,
'abstract': abstract
}
def get_abstract(data_list):
ab_list = []
for i in range(1, len(data_list)):
data = data_list[i]
if data != '':
em = SnowNLP(data)
# 获取自动摘要
ab = em.summary(5)
ab = '。'.join(ab)
ab_list.append(ab)
print(ab)
else:
ab_list.append("null")
print("自动摘要成功")
return ab_list
def jsonFunc():
f = file('test.json')
source = f.read()
result = json.loads(source)
if not result.has_key('answer'):
return u'对不起我找不到呢'.encode('utf-8')
elif len(result['answer']['text'].encode('utf-8')) <= 100:
return result['answer']['text'].encode('utf-8')
elif len(result['answer']['text'].encode('utf-8')) > 100:
original = result['answer']['text'].encode('utf-8').replace('。','\n')
text = SnowNLP(original)
summary_text = ''
for line in text.summary(3):
summary_text = summary_text + line + u'。'.encode('utf-8')
print summary_text
return summary_text
def request_roll(category: int, startPage: int, endPage: int):
category_prefix = category_map[category]
file_out = '../data/' + category_prefix + '.txt'
with open(file_out, 'a', encoding='utf-8') as fw:
count = 0
for i in range(startPage, endPage):
try:
# 打开网页，获取网页内容
response = requests.get(ROOT_URL,
params=global_params(category, i),
headers=headers)
if response.status_code == 200:
# 网页为 gbk 编码，需要进行转码
gbk_content = response.content.decode('gbk')
j = json.loads(gbk_content)
data = j['result']['data']
for d in data:
title = d['title'] # 标题
url = d['url'] # 新闻链接
print(title, '-> 获取新闻内容')
_content = request_content(url)
if len(_content) > 0:
content = '\n'.join(_content)
# SnowNLP 这个库中的关键词提取、摘要提取就是用的 TextRank 算法
# 论文中可以详细介绍这一算法：http://www.hankcs.com/nlp/textrank-algorithm-java-implementation-of-automatic-abstract.html
# 主要思路：分词后根据句子中的词，计算出每个句子的一个向量表示，根据相邻句子对当前句子的"贡献"，以相似度为权重，计算当前句子的重要程度，最重要的句子即为摘要
s = SnowNLP(content)
# 生成一个三句话的摘要
_summary = s.summary(3)
# 写入对应的文件中
fw.write(' '.join(_summary) + '\n')
fw.flush()
count += 1
if count % 10 == 0:
print('=========', count,
category_prefix + '新闻已保存')
else:
print('当前新闻网页格式特殊，未能成功解析，跳过')
# 暂停一下，避免爬虫太频繁
time.sleep(random.random() * 5.0)
except requests.RequestException:
# 爬虫程序无法获取网页内容
print('Cannot get response')
# 每一组也暂停 30s
time.sleep(30)
def __call__(self, image_path):
try:
# assert not os.path.exists(image_path), "The image does not exist!"
#image = Image.open(image_path)
#text = pytesseract.image_to_string(image, lang='chi_sim')
# cnocr的中文OCR识别效果显著更好
tmp = ocr.ocr(image_path) #中间结果, 形如 ['兼', '葭'], ['先', '秦', ':', '佚', '名']
text=''.join([''.join(line) for line in tmp] )
text = self.__preprocessing(text)
if len(text) > 0:
s = SnowNLP(text)
topK_titles = s.summary(self.topK)
return topK_titles
else:
return [text]
except BaseException as e:
ls.logging.exception(e)
return []
def get_sentiments(title, text):
global count
result = []
summary_num = config.getint("feature", "summary_num")
if len(title.strip()) <= 1:
result.append(0.0)
else:
result.append(SnowNLP(title).sentiments)
count += 1
if len(text.strip()) > 2:
s = SnowNLP(text)
for sub in s.summary(summary_num):
result.append(SnowNLP(sub).sentiments)
while (len(result) < 1 + summary_num):
result.append(0.0)
return result
def get(self, article_sid, type):
args = parser.parse_args()
if type == 'extract':
article = self.db.get(
'select title,content from article where sid=%s',
(article_sid, ))
s = SnowNLP(article['content'])
keywords = s.keywords()
abstract = s.summary()
keywords = ','.join(keywords)
abstract = ','.join(abstract)
self.db.update(
'update article set keywords=%s,abstract=%s,processed=1 where sid=%s',
(keywords, abstract, article_sid))
return {
'sid': article_sid,
'keywords': keywords,
'abstract': abstract
}
def _summary(text='', ns:int=7, nk:int=4, outfile:str=None):
"""Summarize Chinese text
Keyword Arguments:
text {str} -- text will be summarized (default: {''})
ns {int} -- number of sentences (default: {7})
nk {int} -- number of keywords (default: {4})
outfile {str} -- where the summary is written (default: {None})
"""
s = SnowNLP(text)
output = '*摘要*\n'
for k, sen in enumerate(toolz.unique(s.summary(ns)), 1):
output += '%d. %s\n' % (k, sen)
output += '\n*关键词*:' + ', '.join(s.keywords(nk))
if outfile:
with open(outfile, 'w') as fo:
fo.write(output)
else:
print(output)
def discourse_analysis(input_text: str):
"""
# 长句压缩/消除冗余/文本摘要
# TextRank
# 1. 找语料 2. 找其他方法
# snownlp
# 指代消解
# 探索方法(Transformer)
"""
# 分句
sentences = list(SentenceSplitter.split(input_text))
# 摘要
s = SnowNLP(input_text)
summary_list = s.summary(limit=3)
# 指代消解 : 使用段落上文信息进行指代消解 零指代
#
pass
return sentences, summary_list
def cal_summary_and_weight(comments):
"""
计算评论内容的摘要及其对应权重
:param comments: 需要分析的评论列表
:return: 返回列表，列表元素为元组，元组中包含摘要和其对应的权重
"""
d = {}
ret = []
for c in comments:
nlp = SnowNLP(c.content)
# 评论获赞数越多，权重越高，取对数来平滑极差
w = int(math.log(c.votes + 1) + 1) ** 2
for kw in nlp.summary():
if d.get(kw):
d[kw] += w
else:
d[kw] = w
for k in d.keys():
ret.append((k, d.get(k)))
return ret
def Spider_what(sentence):
sentence = urllib2.quote(sentence)
url = 'http://zh.wikipedia.org/wiki/'
finalUrl = url + sentence
webpage = urllib2.urlopen(finalUrl)
text = webpage.read()
soup = BeautifulSoup(text)
readable_text = soup.findAll('p')
preprocess = ''
for line in readable_text:
for sub_line in str(line).split('。'):
preprocess = preprocess + sub_line + '\n'
#readable_text = str(readable_text)[1:-1]
#preprocess = unicode(preprocess,'utf-8').encode('utf-8')
text = strip_tags(preprocess)
text = SnowNLP(text)
summary_text = ''
for line in text.summary(1):
summary_text = summary_text + line + '\n'
print summary_text
return summary_text
def generate(request):
_content = request.POST.get('content', '')
keywords = []
summary = []
if _content:
s = SnowNLP(_content)
# 利用 TextRank 提取最重要的 10 个关键词
keywords10 = s.keywords(10)
_keywords = [
x for x in keywords10 if (len(x) > 1 and validKeywords(x))
]
keywords = ','.join(_keywords)
# 生成一个三句话的摘要
_summary = s.summary(3)
summary = '。'.join(_summary)
context = _content.split()
all_text = ''.join(context)
lead3_summary = []
for x in re.split('。|，|！|？| | ', all_text):
if len(x) > 5 and len(lead3_summary) < 3:
lead3_summary.append(x)
elif len(lead3_summary) >= 3:
break
lead_summary = '。'.join(lead3_summary)
return render(request,
'app/generate.html',
context={
'inputText': _content,
'keywords': keywords,
'summary': summary,
'lead_summary': lead_summary
})
return render(request,
'app/generate.html',
context={
'inputText': None,
'keywords': keywords,
'summary': summary
})
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此，这一领域的研究将涉及自然语言，即人们日常使用的语言，
所以它与语言学的研究有着密切的联系，但又有重要的区别。
自然语言处理并不是一般地研究自然语言，
而在于研制能有效地实现自然语言通信的计算机系统，
特别是其中的软件系统。因而它是计算机科学的一部分。
'''
s = SnowNLP(text)
#提取文本关键词
print(s.keywords(3)) #['语言', '自然', '计算机']
#提取文本摘要
print(s.summary(3))#['因而它是计算机科学的一部分', '自然语言处理是计算机科学领域与人工智能领域中的一个重要方向', '自然语言处理是一门融语言学、计算机科学、数学于一体的科学']
#分割成句子
print(s.sentences) #['自然语言处理是计算机科学领域与人工智能领域中的一个重要方向', '它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法', '自然语言处理是一门融语言学、计算机科学、数学于一体的科学', '因此', '这一领域的研究将涉及自然语言', '即人们日常使用的语言', '所以它与语言学的研究有着密切的联系', '但又有重要的区别', '自然语言处理并不是一般地研究自然语言', '而在于研制能有效地实现自然语言通信的计算机系统', '特别是其中的软件系统', '因而它是计算机科学的一部分']
s = SnowNLP([['这篇', '文章'],
['那篇', '论文'],
['这个']])
#词频 tf
print(s.tf) # [{'文章': 1, '这篇': 1}, {'论文': 1, '那篇': 1}, {'这个': 1}]
#IDF
print(s.idf)#{'文章': 0.5108256237659907, '这篇': 0.5108256237659907, '论文': 0.5108256237659907, '那篇': 0.5108256237659907, '这个': 0.5108256237659907}
__author__ = 'Luolin'
#-*-encoding:utf-8-*-
from snownlp import SnowNLP
text = u'''
很久没有写文章了，但是回想起这几年坎坷的奋斗路程，其中的酸甜苦辣，血泪交加，值得整理成文字，纪念我们即将逝去的青春。同时希望正在惆怅的年轻人们，看了我的奋斗历程，能收获微薄的安慰和鼓励，仅此而已。 08年的金融海啸，把很多人推向了失业和破产的潮流，无数人在这一年输的心惊胆战，如今提起尚有不寒而栗的感觉。而那年我们大四，步入了东奔西跑的求职路，几乎所有人都碰的头破血流、皮青脸肿的回来，我也不例外。直至09年初，整个专业签约的寥寥无几，对于一所历史悠久的985工程大学来说，是前所未有的。 09年春节还未过完，我就背着沉甸甸的精神包袱，踏上了艰辛的求职之路，这是一条看不到目标和方向的路。火车是站票到上海的，全程27小时，人山人海，几乎透不过气来。从火车上下来那一刻，站的浮肿的脚踏在真实的地面上，酥麻无力，走起路来东摇西摆的，不过呼吸到新鲜的空气，有一种重获新生的舒适感。但是这种舒适的感觉转瞬即逝，想起此行的目的，又有一种坠入地狱深渊的痛楚。借宿在上海理工大学的学生宿舍里，很感激当时收留我的朋友，农和西瓜，也很感谢那个时候认识的兄弟，良。 顶着凛冽的寒风，一会虹口，一会闸北闵行，大大小小的招聘会，都出现我狼狈的身影，奔波劳累一个月之后，终于在虹口一个小招聘会上，找到了一份要求是高中毕业的业务员工作，工资1800，不包吃住，没有其他补贴，工作地点在杨浦区。接着又匆匆忙忙的赶回学校，赶着写毕业论文，赶着毕业答辩。就在即将毕业的时候，谈了四年的女朋友和我分手了，她保送的是上海交大的研究生，这也是当初我选择上海的原因，当时也犹豫要不要放弃上海的工作，南回广深，但是最终还是选择继续上海行，因为答应过的事情要做到。
文章会慢慢的上来跟大家分享，平时工作比较忙，我一般会晚上更新.毕业的分离，依然是那么不舍，男的女的都哭的稀里哗啦。我走的晚，送走一个又一个，那种离别的伤痛，总似尖刀，一次又一次的在心上雕刻着他们每个人的名字，列车远去的时候，泪水模糊了视线。我离开的时候，整个宿舍楼都是空荡荡的了，记得很清楚来给我送行的人，也记得很清楚我在列车上给我打电话送别的每个人，但是没有她。09年7月初我从学校直接到了上海，开始了我更加艰辛的奋斗历程，当我步入这个我人生中第一次任职的公司（以下简称A公司）的时候，满含着期待和紧张，认真的审视着公司的每一个人。
@人生下站见2012 3楼 2013-12-27 23:14:44 楼主，我看着呢，继续呀！我是12年毕业的那你是刚刚步入社会一年半，也应该是事业开始上升的时期了。加油！一个刚毕业的，没有任何工作经验的人，一开始做的更多是打杂的事情，公司很小，就几个人，我每天会早一会到公司，先打扫收拾一遍，一直坚持几个月，直至公司来了几个新人。而业务上的事情没人带，没人教，自己拿着公司的资料了解产品，几天之后，经理就给我下达约客户的任务，于是我拿着公司提供的名册，开始了电话营销的工作。刚开始的时候，连按号码的手都是发抖的，颤颤巍巍，战战兢兢的，电话接通那一刻，之前自己拟好的对话语句忘的干干净净，对面喂喂的声音震耳发聩，只好硬着头皮，磕磕绊绊的说了几句，对方听的不耐烦，啪一声挂掉了电话。这啪的一声似乎震伤了心，回想当时的心灵是那么脆弱，又是那么卑微，相信每个做业务的人，都有经历过那一幕，有的人或许因为打击放弃了，如果你选定了业务这个工作，那么不过再多坎坷，也要坚持。我拿起电话，继续拨通了下一个号码，继续着听到许多啪啪的声音，一次一次的撞击着心灵。那天我打了100个电话，却没有约到一个客户，那种无望，那种黑暗，让人看不到光明，感受到的只是7月夏季里的冰冷，接受着公司领导的批评。好不容易熬到了下班，逃一般的跑出公司，买了几瓶啤酒，在一个人少的小公园，独自喝着，看着这个繁华无比的城市，却没有一点点的归属感，一股强烈的悲伤感。半夜，拖着半醉的身体，回到那个住着七八个人的一室一厅房子，我们过着轮流着睡床上或打地铺的日子，对于我那微薄1800工资来说，上海的房租太高了，而离开了学校，我就坚决不会向家里要钱，而且还有两个弟弟在上大学。
连续拨打几天电话之后，终于有一天约到了客户，连续如此，后来一个东北的大哥聊的还可以，毕竟在东北上了四年学，有些许话题，最后这个大哥在一个项目上试用了我们的产品，说如果这次试用效果好的话，以后就都用我们的产品。这是我工作以来第一个客户，我一直小心翼翼的，只是没想到试用的产品，都问题不断，最终客户就做死了，后来也很不好意思去见这个东北大哥。其实真正的业务能手，是能够拉回这个客户的，当时的我，意识不到所有公司的产品都有可能存在这样那样的问题，重点是一定要帮客户解决，所以就没继续跟进客户。后来认识一位年纪比较大的师傅，姓金，我在深圳他还给我来过电话，鼓励我。当时金师傅虽然没有买我们的产品，因为他们做的是政府项目，使用的产品都是选定的，但是他一直鼓励我，让我在这个冰冷的世界里，看到了希望。在公司还是认识了一位终生的朋友，一名华工的博士，进，无论硬件软件都是一流的高手，掌握着智能视频方面的核心算法，我们经常下班了一起喝低档的红酒，他当时买房买车，压力很大。就这样在A公司10个月时间，后来一直没什么业绩，总觉得自己很没脸面继续下去，在2010年的4月辞职，买了到桂林的火车票，这是我毕业以来第一次旅游，弟弟在那边上学，他带我在桂林玩了几天，接着回家玩了半个月，见了几个兄弟，理了理思路。
2010年过了五一，我就整理行装，开始了深圳之旅，这个以速度著称的城市，让我充满好奇，也让我的人生开始了新的篇章。匆匆忙忙的面试，最后选了一家做手机屏幕和镜头的F公司，依然是业务员，底薪低的不愿意说，只是当时深圳的最低工资水平。上班的第一天，我就跟着经理去K公司送样品，这是我们公司第一次与K公司接触，这家上市公司在国内外都是赫赫有名的，我和经理都非常紧张。门卫拨通了我们仅认识的一位吴采购的电话，确认过之后才让我们进K公司的大门，在偌大的一个园区中找到了吴采购的办公楼区。吴采购很忙，几乎没有正眼看过我们，经理说我们是F公司，过来贵司送样品的，吴采购哦了一声之后说我现在有事情，你们把样品送到5栋6楼张工那里去测试吧，然后就不见人影了，经理说要去见客户，也离开了，剩下我一个人经过了层层询问之后，才找到了张工，和他简单聊了几句，我说我第一天来上班的，好不容易才找到这里，他则说这里太大，你能找到算是不错，怪不得你们公司那么放心你一个新人来跟我们的项目。听到这里有点欣慰，其实他对我的评价不是因为我能找到他这里，是因为我一个新人就能来跟K公司那么大的项目，而只有我自己才清楚，是没人愿意来跟K公司，因为觉得没希望，经理也是被迫于老板的指令才来的。
昨晚被灌醉了，现在还难受。这几天感冒了，难受啊，还没来得及写下来更新，sorry。K公司因为没有成单的希望，经理非常迅捷的把K公司的跟进任务甩给了我，像甩了个巨大的包袱。我是一个实诚的人，哪怕同事们都议论K公司不可能，让我别费心思，应付一下就好，我还是坚持每天去K公司拜访，了解项目的进展情况。或许因为我经常出现，或许又因为我实在不浮夸滑头，张工对我就不那么陌生了，有时候会跟我聊聊天，说的都是一些工作上的事情：都是些K公司制度严格，要求高，做个项目一但超出预算，奖金就打水漂，又问我们待遇情况怎么样。我呢，则是话少的人，听多说少，因为怕说多了出错。样品测试的效果稍微差了一些，以致项目一直没什么进展，K公司当时已经决定使用另外一家供应商X公司的产品，他们之间一直有合作。直到有一天，我在K公司等张工的时候，他从会议室出来，唠叨的说了一句：整机成本怎么会超出1块钱呢，哎！我则敏锐的接收到了这句话的所有信息：K公司这个项目整机成本要求100元人民币以下，而这次会议核算出来的成本是101，也就意味着按照目前的计划做下去的话，整个项目组的奖金都会泡汤。我们的价格比X公司的便宜0.5元，样品测试的效果其实和X公司的差不了多少，我为什么不借这个超出预算的机会导入我们的产品呢？于是我幽幽的对张工说：整机客户要求挺高，还要成本控制在100以下，真的挺难的，现在这些配件都是大批量采购的价格，降几分钱都困难啊。张工：是啊，愁啊，折腾了两个多月了，原本以为这个项目就这样完美收官了呢，谁知道这时候出现成本超出问题。我：客户要求真的很严格吗？您上次测试我们的产品效果和X公司对比差很多吗？张工：其实没什么差别，只是说一直和X公司合作，组里的人不愿意轻易换，担心换了没保障。我：既然效果差不多，我们的比X公司的便宜0.5元，我再想办法找老板谈谈，让他平本接这个单，估计能腾出来1块钱空间。张工：这个很难吧，不赚钱的生意你们老板会做吗？再则，组里的人我怎么说服他们。我：客户主要是看效果，您用我们的产品装出整机让客户看，如果客户接受了，你们的成本又能降下来1块钱，我相信这个是大家都很乐意接受的事情。价格上我会帮您想办法的。张工：那好吧，你明天再带10个你们的样品过来，我试试装整机给客户看效果。我：没问题。
帮你顶，人还是厚道点好恩呢，厚道的人走的远~@confidencel 13楼 2014-01-06 15:31:54 身体是革命的本钱，修养好继续啊，期待着。。。你写的很好！谢谢，我工作之余写的！
第二天我领了样品一大早给张工送过去，他看到我带着样品来，知道我昨天答应他的事情搞定了，就兴致勃勃的带着我去项目技术主管那：李工，这个是F公司的小郑，这是他们的产品，你测试一下，然后让人装整机明天带给迪拜客户看效果。李工：好的，先放这，我一会测试。我：李工，您好，麻烦您尽快测试一下，这样你们的客户能尽早看效果确认，那么这个项目也能早些完成。李工：那好，我现在就测试，你留个名片给我，有什么事情我联系你。在这里分享一点，客户说先放着，我一会有空了测试的时候，一定要追着客户让他测试，因为你不知道他接下来会不会有空，或者有空了会不会想起来去测试，又或者根本不想测试，切记。我把新的报价单给了张工，他也在上面潇洒的签了字，然后让我拿给采购。
去送样品之前还有一段小故事：从K公司出来，突然觉得深圳的空气质量不错，深呼吸了几下，立马赶回公司，经理不在，又事关紧急，我直接杀到了老板办公室：杨总，我是小郑，关于K公司的事我想跟您谈谈。杨总：小郑，你刚来公司的吧，怎么K公司是你在跟？这边坐。我：是的，经理忙，让我来跟。杨总：哦，那你说说K公司那边的进展。我：K公司的这个项目本来已经决定了用X的产品，但是出现了一个问题，他们整机成本超出预算1块钱。杨总：既然决定了，那还有什么希望呢，成本才超出1块钱，对于他们这样的大公司来说是没什么问题的。我：多1块少1块对K公司本身是没什么影响，但是对这个项目组的每个人影响很大，K公司有个规定，成本超出预算，项目组所有奖金取消。杨总：哦，还有这个规定啊，这是让整个项目组的人为公司想尽办法降低成本啊，K公司就是高明。那现在你想怎么做？我：我们的产品效果是和X公司差不多，报价上比他们低0.5元，我想着我们索性再降0.5元，帮他们解决成本问题，那么他们肯定会用我们的产品。虽然价格上比我们预期的少0.5元，但是我们不需要花钱请客送红包等其他交际费用了，再加上市面上元件成本在下降，我们一旦与K公司合作成功，一开始可能没什么利润，但是慢慢就会带来利润空间的，而且我们又帮了他们，取得信任之后，我们还可以与K公司合作其他项目，这是一个难得的机会。杨总沉思了一下说：小郑你在哪里上的学，什么专业的？我：在东北大学，学的是工商管理市场营销专业。杨总：哦，难怪，想法不错，就按照你说的办，你从新拟个报价单，我来签字，以后整个公司为你开直通车，关于K公司的事情，你可以直接来找我。我：谢谢杨总，客户还需要10个样品，我明天带给他们。杨总拿来个单签了字递给我：多领两个给他们备用。我：好的。
我拿着有张工签字的报价单，找到了采购部吴采购的位置，恰巧他不在那，于是我问他旁边位置的同事：您好，请问吴先生不在吗？他说：吴工今天请假了，你有事么事吗？我：我是F公司的，这是项目部张工让我给吴先生的报价单。他接着说：那你放吴工桌上吧，明天他来了能看到。我思索了一下，假如就放在桌子上，这里是大办公室，经常有同行的人来来往往拜访，如果他们看到了，价格透露了不说，万一同行把我的报价单偷偷拿走了，那到时候采购部拿不到报价审核部下来就麻烦了，于是我说：张工说了，事情很急，要我今天一定交上去给采购部审核。他答道：这样啊，那你去右边第二间办公室找采购薛主管吧。我：谢谢您。咚咚咚，我敲了三下门，里面传出声音：进来。我推开门，这不大不小的办公司布置很简约，一张深色办公桌，几张椅子，一个一幅将近两米宽的山水国画，上面有草书题字，我也是喜爱国画书法的人，于是不禁夸了一句：山峦层层相叠，流水潺潺延绵，字体粗狂有力，好画好字。薛主管说到：你也是喜欢国粹的人啊。我赶忙说：薛主管，不好意思，光欣赏您的书画，忘了自我介绍了，我是F公司的小郑，这里有一个报价单是项目部张工让我交给您的审核的。薛主管接着说：哈哈，现在年纪轻轻的，没几个像你这样还喜欢书画了，来来，坐。我一边坐下，一边把有张工签字的报价单交给薛主管，顺带了一张名片。薛主管边看边说：这个产品之前不是选定了X公司的吗，老张之前也签了字的，怎么突然改了呢。我想着他们公司内部的事情不能乱说，就假装不知道的说：我也不清楚，有一次张工开完会跟我说让我再做个新报价单的，还送样测试。薛主管拿起电话：老张，这个项目之前不是决定用X公司的产品吗？怎么还让其他公司报价？也不知道张工说了什么，一会薛主管说：那好吧，但是样品你们可要测试好，毕竟以前没合作过。挂了电话之后，薛主管对我说：小郑，张工挺看好你们的产品啊，不过咱们之前没合作过，即使项目部那边测试结果通过了，我们采购部和品质部还要对你们公司进一步审查，通过之后才能获得我们公司合格供应商的资格，这个是公司有明文规定的。我：那贵司需要哪些审查呢？薛主管：企业注册年限、注册资金、合作过的企业这些都需要，但主要是审厂。我听得有点迷糊，审厂又审哪些方面呢，想问又不敢再问了。
'''
s = SnowNLP(text)
for word in s.keywords(10): # [u'语言', u'自然', u'计算机']
print word
for sum in s.summary(3):
print sum
# -*- coding: utf-8 -*-
__author__ = 'jz'
from snownlp import SnowNLP
if __name__ == "__main__":
a = u'this is test for something you dont know,my name is zhouwenjie,you should tell me your name right now'
b = u'我去，这个能不能分词啊，毕业设计就靠你了'
c = u'Natalegawa.Ảnh: dvbTỉnh Hải Nam, Trung Quốc gần đây tuyên bố sẽ cho phép cảnh sát biển kiểm tra thậm chí là chiếm giữ tàu lạ ở khu'
s_a = SnowNLP(c)
print(s_a.keywords(3))
print(s_a.summary())
print('end')
text = unicode(f_string, 'utf-8')
print(isinstance(text, unicode))
from snownlp import normal
from snownlp import seg
from snownlp.summary import textrank
from snownlp import SnowNLP
if __name__ == '__main__':
s = SnowNLP(text)
print(s.keywords(3))
print(s.summary(3))
t = normal.zh2hans(text)
sents = normal.get_sentences(t)
doc = []
for sent in sents:
words = seg.seg(sent)
words = normal.filter_stop(words)
doc.append(words)
rank = textrank.TextRank(doc)
rank.solve()
for index in rank.top_index(5):
print(sents[index])
keyword_rank = textrank.KeywordTextRank(doc)
keyword_rank.solve()
for w in keyword_rank.top_index(5):
# 在台湾亦很常见。'
text = u'''
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此，这一领域的研究将涉及自然语言，即人们日常使用的语言，
所以它与语言学的研究有着密切的联系，但又有重要的区别。
自然语言处理并不是一般地研究自然语言，
而在于研制能有效地实现自然语言通信的计算机系统，
特别是其中的软件系统。因而它是计算机科学的一部分。
'''
s = SnowNLP(text)
s.keywords(3) # [u'语言', u'自然', u'计算机']
s.summary(3) # [u'因而它是计算机科学的一部分',
# u'自然语言处理是一门融语言学、计算机科学、
# 数学于一体的科学',
# u'自然语言处理是计算机科学领域与人工智能
# 领域中的一个重要方向']
s.sentences
s = SnowNLP([[u'这篇', u'文章'],
[u'那篇', u'论文'],
[u'这个']])
s.tf
s.idf
s.sim([u'文章'])# [0.3756070762985226, 0, 0]
print '词性标注：'
for each in s.tags:
print "('" + each[0] + "','" + each[1] + "')"
print '\n'
print '拼音：'
for each in s.pinyin:
print each,
print '\n'
print '提取文本关键字：'
for each in s.keywords(3):
print each,
print '\n'
print '提取文本摘要：'
for each in s.summary(3):
print each
print '\n'
print '分割成句子：'
for each in s.sentences:
print each
print '\n'
print "积极情感度：" + str(s.sentiments) + '\n'
#!/usr/bin/python3
# coding: utf-8
# pip install snownlp
# SnowNLP 是一个 python 写的类库, 可以方便的处理中文文本内容, 是受到了 TextBlob 的启发而写的, 由于现在大部分的自然语言处理库基本都是针对英文的,
# 于是写了一个方便处理中文的类库, 并且和 TextBlob 不同的是, 这里没有用 NLTK , 所有的算法都是自己实现的, 并且自带了一些训练好的字典
# 注意本程序都是处理的 unicode 编码, 所以使用时请自行 decode 成 unicode
from snownlp import SnowNLP
s = SnowNLP(u'这个东西真心很赞') # Python2 中要用 u'' 来转成 unicode, Python3 中默认就是 Unicode
print(s.words) # ['这个', '东西', '真心', '很', '赞']
print(s.keywords()) # ['赞', '很', '真心', '东西']
print(s.summary()) # ['这个东西真心很赞']; 对文章进行梗概, 这里只有一句话, 所以是本身
print(list(s.tags)) # [('这个', 'r'), ('东西', 'n'), ('真心', 'd'), ('很', 'd'), ('赞', 'Vg')]
print(s.sentiments) # 0.9769663402895832 positive 的概率
print(s.pinyin) # ['zhe', 'ge', 'dong', 'xi', 'zhen', 'xin', 'hen', 'zan']
## 找出 keywords 中的 名词
print([word for word in s.keywords() if dict(s.tags)[word] == 'n']) # dict(s.tags) 不是函数, 不能加 ()
##################################################################
## 繁体字处理
s = SnowNLP(u'「繁體字」「繁體中文」的叫法在臺灣亦很常見。')
print(s.han) # u'「繁体字」「繁体中文」的叫法在台湾亦很常见。'
##################################################################
## 处理一段文本 keywords(), summary() 两个重量级的函数
text = u'''
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此, 这一领域的研究将涉及自然语言, 即人们日常使用的语言,
所以它与语言学的研究有着密切的联系, 但又有重要的区别。
自然语言处理并不是一般地研究自然语言,
而在于研制能有效地实现自然语言通信的计算机系统,
特别是其中的软件系统。因而它是计算机科学的一部分。
text = u'''
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此，这一领域的研究将涉及自然语言，即人们日常使用的语言，
所以它与语言学的研究有着密切的联系，但又有重要的区别。
自然语言处理并不是一般地研究自然语言，
而在于研制能有效地实现自然语言通信的计算机系统，
特别是其中的软件系统。因而它是计算机科学的一部分。
'''
s = SnowNLP(text)
s.keywords(3) # [u'语言', u'自然', u'计算机']
s.summary(3) # [u'自然语言处理是一门融语言学、计算机科学、
# 数学于一体的科学',
# u'即人们日常使用的语言',
# u'自然语言处理是计算机科学领域与人工智能
# 领域中的一个重要方向']
s.sentences
s = SnowNLP([[u'这篇', u'文章'],
[u'那篇', u'论文'],
[u'这个']])
s.tf
s.idf
s.sim([u'文章'])# [0.3756070762985226, 0, 0]
# -*- coding: utf-8 -*-
"""
Created on Sun Jul 05 15:11:29 2015
@author: mongolia19
"""
#from pyteaser import SummarizeUrl
#url = "http://en.wikipedia.org/wiki/Automatic_summarization"
#summaries = SummarizeUrl(url)
#print summaries
from snownlp import SnowNLP
import FileUtils
passage = FileUtils.OpenFileGBK('./reading/passage.txt')
passage = passage.encode("UTF-8")
s = SnowNLP(passage)
print s.keywords(5)
print s.summary(1)
