def keywords():
countnumber = readWeiboData.count()[0]
for i in range(1,countnumber):
textdata = readWeiboData.getText(i)
# textdata = str(textdata).split('http')[0:-1]
text = str(textdata).decode('utf8')
text = SnowNLP(text)
texttosql = ''
for j in range(0,len(text.keywords(3))):
texttosql+=text.keywords(3)[j]+" "
writeWeiboData.keywordsWriteToSql(texttosql,i)
def search_word(self):
"""
from doc_queue search author article and store
"""
while not self.doc_queue.empty():
print "runing thread is %s" % threading.current_thread().getName()
arti_url,arti_title = self.doc_queue.get().keys()[0]
#get aritcle and store in file
try:
soup = BeautifulSoup(urllib2.urlopen("http://"+self.index_url+arti_url).read())
except urllib2.HTTPError:
self.max_doc_num+=1
continue
data = soup.find('meta',{'name':'author'})
data = data['content'].encode('utf-8')
author = {'d':data}
author_enc = urllib.urlencode(author)[2:]
lead_div = soup.find('div',{"class":"atl-main"})
text = lead_div.find('div',{'class':'bbs-content clearfix'}).get_text().strip().encode('utf-8')+"\r\n"
text = unicode(text.decode('utf-8'))
s = SnowNLP(text)
fp = open("%s/%s.txt"%(self.folder,arti_title),"a")
fp.write("title:%s\r\n"%arti_title.encode("utf-8"))
fp.write("URL:%s\r\n"%arti_url.encode("utf-8"))
fp.write("data:%s"%text.encode('utf-8'))
fp.write("keywords:")
for key in s.keywords(5):
fp.write(key.encode('utf-8')+" ")
fp.flush()
fp.close()
"""store file
def keyword(texts, path):
user_list = list()
word_dict = dict()
idx = 0
for user, age, querys in texts:
idx += 1
print idx
s = SnowNLP('\t'.join(querys))
keys = s.keywords(100)
user_list.append(keys)
for word in keys:
if word not in word_dict:
word_dict[word] = 0
word_dict[word] += 1
new_word_dict = dict()
for idx, word in enumerate(
sorted(word_dict.iteritems(), key=lambda x: x[1],
reverse=True)[0:10000]):
new_word_dict[word[0]] = idx
print 'start write ...'
with open(path, 'w') as fw:
idx = 0
for info, words in zip(texts, user_list):
idx += 1
print idx
vector = [0] * len(new_word_dict)
for word in words:
if word in new_word_dict:
vector[new_word_dict[word]] = 1
fw.writelines(
(info[0] + '\t' + info[1] + '\t' +
' '.join([str(t) for t in vector]) + '\n').encode('gb18030'))
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 keywords(route):
file = open(route)
text = file.read()
s = SnowNLP(text)
keywords = s.keywords(1)
result = str(keywords).replace("'", "").replace("[", "").replace("]", "")
return result
def text_rewrite(input_text: str) -> str:
"""
句子改写相关实现
"""
tmp_str = input_text
s = SnowNLP(tmp_str)
# # 纠错 : 基于 pycorrector
# correct_str , _ = pycorrector.correct(tmp_str)
# 专有名字/缩略词扩充 : 结合 词典 README.md 中有词典相关资源
pass
# 去除非中文
just_chinese_str = re.sub(r'[^\u4e00-\u9fa5]+', '', tmp_str)
# 繁简转化
han_str = s.han
# 关键词
keywords_list = s.keywords(5)
# 拼音
pinin_list = s.pinyin
return '', '', just_chinese_str, han_str, keywords_list, pinin_list
def __textRankHandle(self,text,count):
""" perform textRank operation
Generate and return a list of keywords from the input string.
Args:
text: a sequence of strings which need to generate keywords.
count: the number of keywords generated from text.
Returns:
a list of keywords generated from text. All the keywords in the list are
in Descending order according to its weight
For example:
["桃花开","春天"]
"""
out = []
if self.pkg =="snownlp":
snow = SnowNLP(text)
out = snow.keywords(count)
#print "snownlp....."
else:
for x, w in jieba.analyse.textrank(text,withWeight=True):
out.append(x)
#print "jieba....."
return out[: count if count<len(out) else len(out)]
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 Part_of_Speech_tagging(text):
# 词性分析和关键词提取
word_tag = ""
s = SnowNLP(text)
for w in s.tags:
word_tag += w[0] + "/" + w[1] + " "
key = s.keywords(3)
return word_tag, key
def get_keywords(text):
output = getWordCutResult(text)
s = SnowNLP(output)
tags = [x for x in s.tags]
#print("########"+str(tags))
theNounSentence = nounSentence(tags)
sNoun = SnowNLP(theNounSentence)
keywords = sNoun.keywords(limit=5)
print(keywords)
return keywords
def _tweet_to_feature(self, tweetlist):
f = numpy.zeros(len(self.featuretable),dtype=numpy.float64)
for tweet in tweetlist:
s = SnowNLP(tweet)
s = SnowNLP(s.han)
keys = s.keywords(3)
for wd in keys:
if self.featuretable.has_key(wd):
f[self.featuretable[wd]-1]+=1
return f/numpy.sqrt(numpy.dot(f,f))
def get_index_of_summary(article,k):
list_word = article
k = len(article)/k
article = ''.join(article)
s = SnowNLP(article.decode("utf8"))
keyword_list = s.keywords(k)
s = " ".join(list_word).replace("\n","")
cal_list = []
for i,sen in enumerate(re.split('，|。|：|；|？|！',s)):
sen_list = sen.split(' ')
temp_list = []
temp_value = 0.0
n = 0
for j , word in enumerate(sen_list):
if word in keyword_list:
temp_list.insert(j,1)
else:
temp_list.insert(j,0)
length = 0
for k in temp_list:
length += 1
if k==1:
n += 1
try:
temp_value = n*n*1.0/length
except:
temp_value = 0
sen = ''.join(sen.split())
sen = re.sub("\d{4,}",'',sen)
cal_list.append((i,temp_value,sen))
cal_list = sorted(cal_list,key=lambda x : (-x[1],x[0]))
all_size = 0
ans_list = []
for t in cal_list:
if all_size+len(t[2].decode("utf8"))+1 <= 60 and t[1]>0:
ans_list.append(t)
all_size+=(len(t[2].decode("utf8"))+1)
ans_list = sorted(ans_list,key=lambda x : (x[0]))
ans = ""
for i,t in enumerate(ans_list):
if i == len(ans_list)-1:
ans+=t[2]
ans+="。"
else:
ans+=t[2]
ans+="，"
return ans
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 keywords():
f = open(path + '政府的救助措施.txt',
encoding='gbk') # 疫情传播、疫情防控、疫情救治、疫情对经济的影响、政府的救助措施
text = f.read()
n = 10 # keywords_nums
# SnowNLP
s = SnowNLP(text)
print(s.keywords(n))
# jiagu
keywords = jiagu.keywords(text, n) # 关键词
print(keywords)
def snownlp_test():
text0 = u'因为森林人即将换代，这套系统没必要装在一款即将换代的车型上，因为肯定会影响价格。'
textn = u'四驱价格貌似挺高的，高的可以看齐XC60了，看实车前脸有点违和感。不过大众的车应该不会差。'
textn2 = u'这玩意都是给有钱任性又不懂车的土豪用的，这价格换一次我妹夫EP020可以换三锅了'
textp = u'优惠可以了！购进吧！买了不会后悔的！时间可鉴！ '
s = SnowNLP(text0)
print('中立:')
print(s.sentiments)
print(s.keywords(5))
print('=' * 2)
print('负面:')
sn = SnowNLP(textn)
sn2 = SnowNLP(textn2)
print(sn.sentiments)
print(sn.keywords(5))
print(sn2.sentiments)
print('=' * 2)
print('正面:')
sp = SnowNLP(textp)
print(sp.sentiments)
print(sp.keywords(5))
def main():
"主程序"
while True:
content = input("Please enter a word or paragraph:")
sentence = SnowNLP(content)
keyword_num = 8
keywords = sentence.keywords(limit=keyword_num)
print(keywords)
cluster = Cluster()
probability, category = cluster.get_most_possible_category(keywords)
print(probability, category)
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 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 ajax_analyze(request):
speech_data = request.GET.get('speech_data')
s = SnowNLP(speech_data)
#seg_list = jieba.cut(speech_data) # 默认是精确模式
count_dict = dict(Counter(s.words))
analyze_dict = {}
analyze_dict['count_dict'] = count_dict
analyze_dict['time'] = time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time()))
analyze_dict['sentiments'] = s.sentiments
analyze_dict['keywords'] = s.keywords(3)
Speech_main.objects.create(data=speech_data, sentiments=s.sentiments)
return JsonResponse(analyze_dict)
def calculate_labels():
with open(fname, 'r', encoding='utf-8') as f:
names = f.readlines()
kw = []
for n in names:
sobj = SnowNLP(n)
kw += [x for x in sobj.keywords(limit=3) if len(x) > 1]
keywords = [x[0] for x in Counter(kw).most_common(30)]
with open(fkw, 'w', encoding='utf-8') as f:
for n in keywords:
f.write(n)
f.write('\n')
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(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 store_to_mysql(self, response):
# newspaper提取文章相关内容（文章详情页）：（目前newspaper可以对中文页面做简单的提取，部分功能运用到中文页面会失效）
a = Article(response.url, language='zh') # chinese
a.download(response.body)
a.parse()
print('---------------title---------------------------------------')
title = a.title
text = a.text
# 判断 title 是否为空，若为空，将其填充：
if title == "":
# title = re.match(r'(.*)。.*', text).groups()[0]
title = text.summary(1)
print(title)
print('---------------text---------------------------------------')
print(text[:100])
print(
'---------------------meta_description--(文章摘要)----------------------------------'
)
meta_description = a.meta_description
print(meta_description)
print(
'====================================+++++snowNPL+++++========================================='
)
# 用snowNLP进行关键字提取（优化newspaper的关键字泛滥问题）：（缺点：提取速度较慢）
s = SnowNLP(text)
keyword5 = s.keywords(5) # 可自行决定关键字数量
print('关键词：')
print(keyword5)
data = {
'title': title,
'meta_description': meta_description,
'keyword5': keyword5,
'text': text
}
print(data)
self.news_info.insert_one(data)
print("插入数据成功")
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
})
def parseNewsDetail(self, r: dict):
entity = {}
# 新闻标题
entity['title'] = r['title']
print(entity['title'])
# 新闻的 url，进一步获取新闻的具体内容，从而生成关键字、摘要
entity['url'] = r['url']
print(entity['url'])
# 新闻的时间
timeInt = int(r['time'])
entity['time'] = timeInt
# 新闻的具体文本内容
content = self.getNewsContent(entity['url'])
contentConcat = ''
if len(content) >= 1:
contentConcat = '\n'.join(content)
entity['content'] = contentConcat
# 使用 SnowNLP 提供的生成关键词、提取摘要的接口
# 具体算法是 TextRank，毕业论文需要具体介绍这种方法
if contentConcat:
s = SnowNLP(contentConcat)
# 生成关键词，因为有的时候关键词是一个单字（常用字），所以只保留长度大于等于 2 的
keywords10 = s.keywords(10)
keywords = [
x for x in keywords10 if (len(x) > 1 and self.validKeywords(x))
]
keywordsSQL = '|'.join(keywords)
entity['keywords'] = keywordsSQL
# 生成一个三句话的摘要
summary = s.summary(3)
summarySQL = '|'.join(summary)
entity['summary'] = summarySQL
# print(keywordsSQL)
# print(summarySQL)
# print('='*80)
# 写入数据库中
self.dbUtil.insert(entity)
def trainfeature(self, filepath):
featuretable = {}
(utf8_encoder, utf8_decoder, utf8_reader, utf8_writer) = codecs.lookup('utf-8')
fd = utf8_reader(open(filepath))
tweetlist = fd.readlines()
fd.close()
VALID_EXP = ur'([A-Za-z\u4e00-\u9fa5]+)'
VALID_REGEX = re.compile(VALID_EXP)
for tweet in tweetlist:
s=SnowNLP(tweet)
s=SnowNLP(s.han)
keys = s.keywords(3)
for wd in keys:
mtch = VALID_REGEX.search(wd)
if mtch is None:
continue
else:
wd = mtch.group(0)
if featuretable.has_key(wd):
continue
else:
featuretable[wd]=len(featuretable)+1
if len(featuretable):
self.featuretable = featuretable
def snownlp_base():
# 目标字符串
content_1 = "我愛武漢，来武汉必来黄鹤楼打卡，周边停车很方便，进去后坐了一个观光车，价格也不贵，很不错，黄鹤楼很气派，一起有六层，不算很高，高层风景很好，可以看到武汉长江大桥，里面逛的地方不多，总体来说，还是值得来的，不错"
content_2 = "没啥看头，给外地人看的……"
content_2 = "非常满意，行程安排的很合理，导游服务态度非常好"
content_2 = "值得一来，刘导把行程安排的很妥帖，完全不用操心，推荐！！"
# with open(file="/temp/target_sentiments_negative.txt", mode="r", encoding="utf-8") as f:
# content_1 = f.read();
# 分词
snownlp_1 = SnowNLP(content_1)
snownlp_2 = SnowNLP(content_2)
print(snownlp_1.words)
# 词性
print(snownlp_1.tags)
print(list(item for item in snownlp_1.tags))
# 断句
print(snownlp_1.sentences)
# 情绪值，接近 1 表示正面情绪，接近 0 表示负面情绪
print(snownlp_1.sentiments)
print(snownlp_2.sentiments)
# 汉字转拼音
print(snownlp_1.pinyin)
# 繁体字转简体字
print(snownlp_1.han)
# 关键字抽取
print(snownlp_1.keywords(10))
# 概括总结文意
print(snownlp_1.summary(4))
# 在台湾亦很常见。'
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]
from snownlp import normal
from snownlp import seg
from snownlp.summary import textrank
from snownlp import SnowNLP
if __name__ == '__main__':
'''
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):
print(w)
'''
text = u'#菇morning#看到这个热门我的第一反应是 '
s = SnowNLP(text.encode('utf-8'))
keywords = s.keywords(10)
for each in keywords:
print(each)
tmp = s.sentiments
print(tmp)
__author__ = 'Luolin'
import urllib2
from bs4 import BeautifulSoup
import urllib
from snownlp import SnowNLP
soup = BeautifulSoup(urllib2.urlopen("http://bbs.tianya.cn/post-lookout-358741-1.shtml").read())
data = soup.find('meta',{'name':'author'})
db = soup.find("div")
data = data['content'].encode('utf-8')
author = {'d':data}
author_enc = urllib.urlencode(author)[2:]
lead_div = soup.find('div',{"class":"atl-main"})
text = lead_div.find('div',{'class':'bbs-content clearfix'}).get_text().strip().encode('utf-8')+"\r\n"
#docs = soup.findAll('div',{'js_username':author_enc})
"""
for div in docs:
text+= div.find('div',{'class':'bbs-content'}).get_text().strip().encode('utf-8')+"\r\n"
"""
text = unicode(text.decode('utf-8'))
s = SnowNLP(text)
for key in s.keywords(10):
if len(key)>1:
print key
def getKeyWords(text,keyWordsNum):
s = SnowNLP(text)
return s.keywords(keyWordsNum)
# 情感分析
def get_sentiments(origin_s):
s = SnowNLP(origin_s)
return s.sentiments
df['c_sentiments'] = df['c_data'].apply(get_sentiments)
df['c_sentiments'].plot.hist()
plt.savefig('../data/positive.png')
plt.show()
# 全部评论的关键字
all_comments = ''.join(df['c_data'])
all_snow = SnowNLP(all_comments)
keywords = all_snow.keywords(30)
print(keywords)
# 摘要
# ['故事里每个人的结局都很好', '大家都不是一个人', '每个人都有故事每个人都有视角每个人都有选择']
summary = all_snow.summary(3)
print(summary)
# 其他应用机器学习进行探索...
# 简单的可视化
sns.countplot('c_rank_num', data=df)
plt.savefig('../data/rank.png')
plt.show()
import jieba
from jieba import analyse
import json
from snownlp import SnowNLP
from pyhanlp import *
with open('data/coreEntityEmotion_train.txt', 'r') as f:
data = f.readline()
data = json.loads(data)
print(data["coreEntityEmotions"])
s = SnowNLP(data["content"])
print("snowNLP", s.keywords(10))
# print(s.summary(3))
# print(s.sentiments)
print(
"jieba",
jieba.analyse.textrank(data["content"],
topK=20,
withWeight=False,
allowPOS=('ns', 'n', 'vn', 'v')))
print("HanLP", HanLP.extractKeyword(data["content"], 2))
# while(data):
# data = json.loads(data)
# print(data['newsId'], len(data['coreEntityEmotions']))
# data = f.readline()
# print(data.keys())
# print(data['coreEntityEmotions'][0].keys())
f.close()
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()
def keywords(text,num):
s = SnowNLP(text.decode('utf8'))
#st = frequency.Stopwords()
return s.keywords(num)
for each in s.words:
print each,
print '\n'
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'
20、提价放量阶段，主要对应2018年，此阶段关键矛盾为平抑价格泡沫，为此茅台五年来首次提价并加大春节投放量，目前来看价格已实现阶段性稳定。
21、首先我们复盘上一轮周期，发现上轮价格崩盘主要源于消费结构不合理、渠道囤货现象严重以及不科学的量价政策，因此认为本轮周期不会重蹈上轮崩盘覆辙。
22、未来展望来看，供给端预计缓慢提升，需求端预计延续扩张，因此供需偏紧格局将长期存在。
23、结合厂家、监管层以及社会舆论对茅台价格的治理作用，我们认为茅台价格未来将保持稳中有升的上涨节奏。
24、我们基于人均收入对应的合理购买力水平，测算出2020年茅台的合理终端价区间为1536元~1920元。
25、投资建议：重申“买入”评级。
26、我们预计：需求端，随着消费升级红利延续且当前库存水位健康（20%），茅台将进入需求周期和库存周期的共振阶段；
27、供给端，公司供应偏紧持续存在，且定价权愈发收放自如，考虑到当前渠道价差充足，公司具备持续提价能力。
28、中长期来看，我们认为公司收入有望持续保持20%以上的稳健增长，建议以更长远视角来看待公司的良好投资机会。
29、我们预计公司2018-2020年营业总收入分别为801.75/973.17/1151.52亿元，同比增长31.3%/21.4%/18.3%；
30、净利润分别为373.61/461.58/550.10亿元，同比增长37.97%/23.55%/19.18%，对应EPS分别为29.74/36.74/43.79元。
31、风险提示：打压三公消费力度继续加大、高端酒动销不及预期、食品安全事件。'''
with open('./data/test.china_tax.txt') as f:
article = f.read()
s = SnowNLP(article)
print('keywords', s.keywords(100)) # [u'语言', u'自然', u'计算机']
print('summary', s.summary(5)) # [u'因而它是计算机科学的一部分',
# u'自然语言处理是一门融语言学、计算机科学、
# 数学于一体的科学',
# u'自然语言处理是计算机科学领域与人工智能
# 领域中的一个重要方向']
# print('sentences', s.sentences)
# s = SnowNLP([[u'这篇', u'文章'], [u'那篇', u'论文'], [u'这个']])
# print(s.tf)
# print(s.idf)
# print(s.sim([u'文章'])) # [0.3756070762985226, 0, 0]
print(s.han)#'「繁体字」「繁体中文」的叫法在台湾亦很常见。'
text = '''
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此，这一领域的研究将涉及自然语言，即人们日常使用的语言，
所以它与语言学的研究有着密切的联系，但又有重要的区别。
自然语言处理并不是一般地研究自然语言，
而在于研制能有效地实现自然语言通信的计算机系统，
特别是其中的软件系统。因而它是计算机科学的一部分。
'''
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}]
from common.persistence import from_pickle, to_pickle
from common.html_util import strip_tags
pos_dict = from_pickle('pos_norm.pkl')
print '%d positions' % len(pos_dict)
pid = 403932
assert pid in pos_dict
for p in pos_dict[pid]:
print p
# get keywords of pos
print 'jieba tags'
pos = pos_dict[pid]
import jieba.analyse
tags = jieba.analyse.extract_tags(pos[2])
for t in tags:
print t
print 'snow tags'
from snownlp import SnowNLP
s = SnowNLP(pos[2])
for t in s.keywords(limit=20):
print t
#!/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'''
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此, 这一领域的研究将涉及自然语言, 即人们日常使用的语言,
所以它与语言学的研究有着密切的联系, 但又有重要的区别。
自然语言处理并不是一般地研究自然语言,
而在于研制能有效地实现自然语言通信的计算机系统,
特别是其中的软件系统。因而它是计算机科学的一部分。
s.han # 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 -*-
__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')
def scrap_eastmoney_comment(url, a_path, ts_code):
def reload_page_and_wait(driver, text):
print(text)
driver.refresh()
WebDriverWait(driver, 60).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".hs_list")))
def current_page(driver):
page = driver.current_url.split(",")[2].replace("f_", "").replace(".html", "")
return str(page)
driver.get(url)
a_result = []
soup = BeautifulSoup(driver.page_source, "lxml")
max_pages = int(soup.select(".sumpage")[0].text)
print("start scrap")
try:
while True:
counter=current_page(driver)
if str(counter) == str(max_pages):
print("Everything Scraped from",ts_code)
break
#make sure website is loaded
for _ in range(10):
try:
print("loaded")
WebDriverWait(driver, 60).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".hs_list")))
break
except Exception as e:
print(e)
reload_page_and_wait(driver,"page not loaded")
break # continue
else:
print("website loading error")
break #to finish
# load html bloc
for _ in range (10):
try:
html = driver.page_source
soup = BeautifulSoup(html, "lxml")
all_title = soup.select(".normal_post")
break
except Exception as e:
print(e)
reload_page_and_wait(driver,"html not parsed")
else:
print("html parsing error")
break # to finish
# scrap each article
for title in all_title:
try:
read=title.select(".l1.a1")[0].text
comment=title.select(".l2.a2")[0].text
h3 = title.select(".l3.a3 a")[0].text
href = title.select(".l3.a3 a")[0]["href"]
#username = title.select(".l4.a4 a font")[0].text
date_source = title.select(".l5.a5")[0].text
# NLP sentiment analysis: needs training
s = SnowNLP(h3)
sentiment = s.sentiments
k1 = s.keywords(1)
k1=k1[0]
d_result = {"read":read,"comment":comment,"h3": h3, "href": href, "date": date_source, "sentiment":sentiment, "k1":k1}
a_result.append(pd.Series(d_result))
print(ts_code, counter, d_result)
except Exception as e:
print(e)
print("scraping individual comment error")
# click the next page
for _ in range(10):
try:
print("try to click next page")
WebDriverWait(driver, 60).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".pagernums a:nth-last-of-type(2)"))).click()
break
except Exception as e:
print(e)
reload_page_and_wait(driver,"can not go to next page")
else:
print("no next page to click")
break
except Exception as e:
#forced to finish for strange reasons
print(e)
df = pd.DataFrame(a_result)
LB.to_csv_feather(df=df, a_path=a_path, skip_feather=True)
print("Finished at page", counter)
def content_color(self, content):
s = SnowNLP(content)
color = s.sentiments
keywords = s.keywords(3)
print keywords
return color, keywords
__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
def analyze_sentiment(df_text):
"""
natural language processing on every row from the input.
1. for loop dataframe:
2. preprocess text in the df.
3. get entity using pyLTP
4. get sentiment, keywords, summary using SnowNLP.
5. append result to df
Keyword Arguments:
df_text --
"""
df_result = pd.DataFrame(
columns=['datetime', 'entity', 'keyword', 'summary', 'score'])
for item in df_text.iterrows():
# print(item[1]['Conclusion'])
title = item[1]['Title']
logging.info(item[0])
logging.info(title)
text = item[1]['Conclusion']
#res = client.lexer(text)
#tag = client.commentTag(text)
# 文章标签
#keyword = client.keyword(title, text)
# 文本分类
# topic = client.topic(title, text)
# 情感倾向分析
# sentiment = client.sentimentClassify(text)
datetime = item[1]['InfoPublDate']
if text:
text_split = preprocess_string(text, filter_setting)
# 词性标注
# postagger = Postagger() # 初始化实例
words = text_split.split() # 分词结果
postags = postagger.postag(words) # 词性标注
# 命名实体识别
# recognizer = NamedEntityRecognizer() # 初始化实例
netags = recognizer.recognize(words, postags) # 命名实体识别
dict_netags = defaultdict(list)
ls_netags = list(zip(netags, words))
for x, y in ls_netags:
dict_netags[x].append(y)
s = SnowNLP(text)
score = s.sentiments * 2
# continue
ls_entity = [dict_netags[x] for x in ['B-Ni', 'E-Ni', 'I-Ni']]
try:
df_result = df_result.append(
{
'datetime': datetime,
'keyword': ','.join(s.keywords()),
'entity': list(
itertools.chain.from_iterable(ls_entity)),
'summary': ';'.join(s.summary()),
'score': score
# 'text': text,
},
ignore_index=True)
except:
continue
return df_result
# # 在台湾亦很常见。'
# text = u'''
# 自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
# 它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
# 自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
# 因此，这一领域的研究将涉及自然语言，即人们日常使用的语言，
# 所以它与语言学的研究有着密切的联系，但又有重要的区别。
# 自然语言处理并不是一般地研究自然语言，
# 而在于研制能有效地实现自然语言通信的计算机系统，
# 特别是其中的软件系统。因而它是计算机科学的一部分。
# '''
start = time.time()
s = SnowNLP(text)
print "======================"
for item in s.keywords(3): # [u'语言', u'自然', u'计算机']
print item.decode('utf-8')
print "======================"
res = s.summary(3) # [u'因而它是计算机科学的一部分',
# u'自然语言处理是一门融语言学、计算机科学、
# 数学于一体的科学',
# u'自然语言处理是计算机科学领域与人工智能
# 领域中的一个重要方向']
for item in res:
print item.decode('utf-8')
print time.time() - start
# -*- 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)
#!/usr/bin/python3
# coding: utf-8
# 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'''
自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。
它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。
自然语言处理是一门融语言学、计算机科学、数学于一体的科学。
因此, 这一领域的研究将涉及自然语言, 即人们日常使用的语言,
所以它与语言学的研究有着密切的联系, 但又有重要的区别。
自然语言处理并不是一般地研究自然语言,
而在于研制能有效地实现自然语言通信的计算机系统,
input=sys.argv[1]
output=sys.argv[2]
print(input)
content=open(input,"r").read()
#the number of keywords is set about square root of length
from math import *
length=ceil(sqrt(len(content)))
r=SnowNLP(content)
#print(r.keywords(10, False))
outSnowNLP="C:\\Users\\Tassadar\\Desktop\\Course\\weibo\\temp\\snowOutput.txt"
outSnowF=open(outSnowNLP,"w")
f=open(output,"w")
result=r.keywords(length, False)
print("\n",file=f)
print("\n",file=outSnowF)
for x in result:
print(x,end="\n",file=f)
print(x,end="\n",file=outSnowF)
print(r.keywords(length, False))
f.close()
