├── .gitignore ├── README.md ├── cmp.py ├── corpus └── 1000001.txt ├── dataClean.py ├── dict_file ├── cilin.txt ├── dict.txt.big ├── part_of_speech.txt ├── stop_words.txt └── user_dict.txt ├── dijkstra.py ├── excel_handle.py ├── fileHandle.py ├── main.py ├── semanticsCount.py ├── src ├── __init__.py ├── dir_handle.py ├── excel_handle.py ├── file_handle.py ├── html_handle.py ├── scrapy_handle.py └── seg_handle.py ├── statisticsCount.py ├── test.py ├── textPreprocessing.py ├── textRank.py └── tfidf.py /.gitignore: -------------------------------------------------------------------------------- 1 | *.txt 2 | *.pyc 3 | corpus/ 4 | segFile/ 5 | tfidfFile/ 6 | *.xls 7 | .idea/ 8 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## 基于语义的中文文本关键词提取算法（SKE） 2 | 3 | ####关键词： 同义词词林、jieba分词、语义相似度、居间度、Dijkstra、TF-IDF 4 | 5 | ### 程序框架说明 -------------------------------------------------------------------------------- /cmp.py: -------------------------------------------------------------------------------- 1 | # encoding=utf-8 2 | 3 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 4 | from __future__ import unicode_literals 5 | import json 6 | import os 7 | import sys 8 | # 操作中文必须语句，解决字符问题 9 | reload(sys) 10 | sys.setdefaultencoding('utf8') 11 | import src.scrapy_handle as scrapy_handle 12 | import src.html_handle as html_handle 13 | import src.file_handle as file_handle 14 | import src.excel_handle as excel_handle 15 | import src.seg_handle as seg_handle 16 | import textRank 17 | import main 18 | 19 | # 《界面》文章标签的抓取 20 | tagDatas = [] 21 | recordCount = 0 22 | flag = 1353000 23 | # 统计文章标签来源于词频正确率 24 | fileCount = 0 25 | tagCount = 0 26 | while flag <= 1400000: 27 | baseurl = 'http://www.jiemian.com/article/%d.html' % (flag) 28 | # 进行文本抓取 29 | text = scrapy_handle.get_html_data(baseurl) 30 | # 进行文本信息获取 31 | if not text: 32 | flag += 1 33 | continue 34 | else: 35 | # 进行文本信息获取 36 | article_data = html_handle.get_article_data(text) 37 | # print article_data 38 | 39 | # 进行文本信息的记录(便于打印输出) 40 | # type = json.dumps(article_data[0], ensure_ascii=False) 41 | # title = json.dumps(article_data[1], ensure_ascii=False) 42 | # sub_title = json.dumps(article_data[2], ensure_ascii=False) 43 | # date = json.dumps(article_data[3], ensure_ascii=False) 44 | # tags = json.dumps(article_data[4], ensure_ascii=False) 45 | # content = json.dumps(article_data[5], ensure_ascii=False) 46 | # print type, title, sub_title, date, tags, content 47 | # print type, title, date, tags 48 | 49 | # 若数据为空，不进行记录操作 50 | if len(article_data) == 0: 51 | flag += 1 52 | continue 53 | 54 | # 文章数据记录，便于后续SKE算法实现 55 | recordFileName = str(flag) + '.txt' 56 | recordFilePath = 'files/' + str(flag) + '.txt' 57 | print recordFilePath 58 | # 仅存储文章标题和正文 59 | file_handle.write_file(recordFilePath, article_data[1]) # 类型暂时不写入，直接通过文件名区分 60 | file_handle.write_file(recordFilePath, article_data[2]) 61 | file_handle.write_file(recordFilePath, article_data[5]) 62 | 63 | # 文章数据 64 | path = 'files' 65 | fileName = recordFileName 66 | 67 | # 统计数据包括类别、文章标题、文章链接、文章标签、SKE算法标签、TextRank算法标签 68 | 69 | # textRank 算法统计 70 | keywords, keypharses, abstract = textRank.details(fileName, path) 71 | print keywords 72 | # 进行textrank关键词数据处理 73 | textrankKeywords = keywords 74 | 75 | # SKE算法统计 76 | ske = main.main(fileName, path) 77 | print json.dumps(ske, ensure_ascii=False) 78 | # 进行ske关键词的数据处理 79 | skeKeywordsData = ske[0:9] #top10 80 | skeKeywordsList = [] 81 | for data in skeKeywordsData: 82 | skeKeywordsList.append(data[0]) 83 | skeKeywords = '\\'.join(skeKeywordsList) 84 | print skeKeywords 85 | 86 | # 词频算法统计 87 | wordFrequency = seg_handle.seg_data(article_data[5]) 88 | # 对数据进行组织 89 | frequencyDatasList = [] 90 | wordCount = 0 91 | # TOP10 92 | for data in wordFrequency: 93 | if wordCount > 10: 94 | break 95 | tmpData = data[0] + '/' + str(data[1]) + ' ' 96 | frequencyDatasList.append(data[0]) 97 | wordCount += 1 98 | # 进行词频关键词的数据处理 99 | frequencyDatas = '\\'.join(frequencyDatasList) 100 | print frequencyDatas 101 | frequencyKeywords = frequencyDatas 102 | 103 | # 文章原始标签 104 | tagList = article_data[4].split(',') 105 | # 标签正确率统计 106 | skeCount = 0 107 | textrankCount = 0 108 | frequencyCount = 0 109 | for tag in tagList: 110 | if len(tag) == 0: 111 | continue 112 | else: 113 | skeFlag = skeKeywords.find(tag) 114 | textrankFlag = textrankKeywords.find(tag) 115 | frequencyFlag = frequencyKeywords.find(tag) 116 | if skeFlag > 0: 117 | skeCount += 1 118 | if textrankFlag > 0: 119 | textrankCount += 1 120 | if frequencyFlag > 0: 121 | frequencyCount += 1 122 | 123 | print skeCount, textrankCount, frequencyCount 124 | 125 | # 计算flag(查找其中正确率最高的) 126 | maxNum = max(skeCount, textrankCount, frequencyCount) 127 | flagList = [] 128 | if maxNum == 0: 129 | flagList.append('null') 130 | else: 131 | if maxNum == skeCount: 132 | flagList.append('ske') 133 | if maxNum == textrankCount: 134 | flagList.append('textrank') 135 | if maxNum == frequencyCount: 136 | flagList.append('frequency') 137 | curflag = '\\'.join(flagList) 138 | 139 | 140 | # 进行数据记录textrankKeywords 141 | tagData = [article_data[0], article_data[1], baseurl, article_data[4], skeKeywords, textrankKeywords, frequencyKeywords, str(skeCount), str(textrankCount), str(frequencyCount), curflag] 142 | tagDatas.append(tagData) 143 | excel_handle.write_append('results.xls', tagData, '.') 144 | 145 | 146 | fileCount += 1 147 | print "当前已处理文章数为： ", fileCount 148 | # if fileCount >= 1: 149 | # break 150 | 151 | 152 | flag += 1 153 | 154 | # 进行文件记录 155 | # excel_handle.excel_write('tag_record_back.xls', tagDatas, '.') -------------------------------------------------------------------------------- /corpus/1000001.txt: -------------------------------------------------------------------------------- 1 | 王兴：棋至中盘 王要见王 2 | 3 | 或许在骨子里，王兴依然是一位执着而痴迷的极客，互联网下半场的大幕拉开，没有人知道，他们打出的下一张牌会是什么。 4 | 5 | 人物志 6 | 7 | 8 | 2012年冬，北京马可波罗酒店门口，两个年轻人正在等车。一辆出租车停在门口，司机探出头，“哪位约的车？”滴滴出行CEO程维摆摆手，得意的看向身旁的美团CEO王兴。 9 | 就在刚刚结束的饭局上，程维向王兴展示自己的作品“嘀嘀打车”，不料王兴只看了一眼，一盆冷水浇下来，“这个产品注册流程设计的太垃圾，你看看现在的互联网产品，哪里还有需要注册的。” 10 | 这件旧事，在四年后的乌镇世界互联网大会期间，被重提。王兴已经记忆模糊，“我不习惯用垃圾两个字，当时说用户体验有很多需要改进的地方。”程维笑笑，“其实我也觉得那个设计挺垃圾的。”中国互联网圈王兴对产品很有洞见，之后的故事也佐证了这一点。 11 | 事后外界才得知，这款被王兴视为“垃圾”的产品，是外包公司找一位山东的中专老师带着学生鼓捣出来的。也正是这个产品让早期的滴滴一时间陷入僵局，直到原百度技术牛人张博加入，并用了近一年时间重新研发打磨产品。 12 | 两位看似毫无交集的男主角在之后的4年多时间里，上演了两场颇为相似的商战大戏。地推巷战、融资阻击、资本寒冬……最终以合并的方式扫清战场，堪称中国O2O战场的经典战役。 13 | 2016年将过，这一年里他们完成了跑马圈地的加速狂奔，O2O战局趋稳，行业巨头的头部效应正在显露。但是，战场没有中场休整，下半场已经如约而至。正如王兴引用钱穆的话，“过去未去，未来已来”。没错，移动互联网和互联网是交织在一起的。 14 | 2017年，王兴和程维又将重新站上“下半场”起跑线。如果说BAT这些互联网前辈已经完成人和信息、信息和信息的连接，搭建起互联网的“水电煤”生态。王兴等互联网“少壮派”完成人与交通工具、人与吃喝玩乐的物理连接后，他们的眼光已经投向“下半场”——技术创业、产业融合和国际化。一场触达传统产业链的化学反应正在发生。 15 | 大逃杀 16 | 2010年，王兴创立美团，并在三年间从“千团大战”“百团大战”中杀出重围，坐稳团购网站头把交椅，随后成长为一个吃喝玩乐一站式服务平台。2012年，程维告别供职八年的阿里巴巴创立滴滴，并用四年时间打造国内最大的出行平台。 17 | 战事过半，王兴和程维都刚从一场腥风血雨中险胜。回忆起过去的疯狂扩张，王兴不后悔，“快是必要的，竞争在某些时刻是非常残酷的。一个很受触动的片段是，舒马赫和阿隆索在一次最后对决的时候，双方长期齐驱并驾。经过长时间的僵持后，最后阿隆索胜出了。事后别人问他为什么，他说大家都不松的话，可能车毁人亡，他有小孩，我没小孩，他应该会让我。” 18 | 程维对此高度认同，“双方轮流竞价到一定阶段后，这是一种必然。如果你并不能够靠一直踩油门把对手踩死，也并非一定要车毁人亡才能结束战争，也许还有第三种解决方式。” 19 | 竞争到极致是残酷的，但商业归商业，王兴和程维在冲刺的一刻抓住了下半场仅有的几张船票。 20 | 两人并未选择刹车，也不是踩油门，而是合并。谈及合并，据王兴回忆，“我和张涛互相很了解，要克服的障碍就是要不要合。美团与点评合并从最根本上的关注点是一样的，我们希望把让中国人吃得更好，活得更好这件事做好，让消费者、商户的整个体系更好，这是最根本的点。” 21 | 这也是“下半场”出现的重要契机，“合则两利，”王兴说，“不需要在广度很薄的层面上焦灼的拉锯，而是能够腾出资源，去做更有竞争性的事情。” 22 | 如今的美团点评已经从一家团购网站成长为是吃喝玩乐一站式服务平台，也就是以餐饮为中心，到店综合和酒旅为两翼的阵势初步整合完成。目前美团点评覆盖全国超过2800个市县区，拥有用户近6亿，日订单量突破1300万单，移动端月度活跃用户超1.8亿，年度活跃买家达2.2亿，2015年总交易额超1700亿元。O2O市场的“巨型独角兽”雏形初现，美团点评被视为BAT之外的互联网第四极。 23 | 控局 24 | 早在今年七月份，王兴就抛出“互联网下半场”的话术。他断言，中国互联网产业发展进入下半场，行业竞争模式从外部竞争升级到打造企业核心竞争力，这将决定各家的成败。正如王兴所说，下半场是ARPU值（每用户平均价值）的体现，是大数据和人工智能的突破，也是更高效的重构一个产业链。 25 | 毫无疑问，O2O上半场的疯狂，很大程度上得益于人口红利。但是随着人口红利的消退，互联网上半场疯狂烧钱、不计回报的日子已经不复返。“到今天，中国7亿网民正好过半，你的用户数已经不可能翻倍了。但是每个用户能够创造的价值还远不只翻倍的空间。”这也是王兴提出“下半场”的根本依据，“以人工智能为例，现在仍然方兴未艾，但是已经搞了几十年，现在终于有了强大的计算能力，有了数据和算法。” 26 | 今年的乌镇世界互联网大会上，BAT三巨头也相继抛出了相似的观点。李彦宏说，移动互联网的时代已经结束；马化腾说，中国互联网已经发展到了下一片的深水区；马云说，未来30年属于“用好互联网技术”的公司、国家和年轻人。虽然话术不同，但是对“下半场”基本达成共识。 27 | 作为“下半场”言论的发起者，王兴的理解有三个层面。“一是真正的硬科技；二是跟传统产业的全面深度结合；第三条路就是海外市场。” 28 | 合并一个月后，王兴进行第一次组织架构调整：设立平台事业群、到店餐饮事业群、到店综合事业群、外卖配送事业群、酒店旅游事业群、猫眼电影全资子公司、广告平台部等业务板块。如今，王兴的目光转向B端商户，8月29日美团点评宣布推出餐饮开放平台，与餐饮ERP（企业资源管理）服务商共建餐饮生态系统。“商家的需求越来越复杂，以前只是要客户，现在还要管理收支，掌握房租、人力成本、食材采购、营销等成本。” 29 | 王兴布下的每一个棋子，都意味深长。在采访中，王兴举例说，“猫眼电影已经是全国卖票最多的平台。我们发现电影这个事情不是光卖票，还要跟发行、制片等整个B端平台去结合，这是一种深入。” 30 | 和王兴不同的是，程维的头上多了一把“悬顶之剑”——新政。他在等待“靴子落地”的同时，也正在下半场的悄然布局。例如，滴滴与150家出租车达成产业融合合作；今年双十一，滴滴和天猫跨界合作，在北京和上海试水“移动超市”；滴滴出行与安飞士巴吉集团达成合作，在近175个国家和地区提供境外安飞士（Avis）以及巴吉（Budget）的租车服务；另外，滴滴还将推动公交行业的变革。 31 | 对于国际化，王兴和程维也有着不同的理解和动作。“中国主场的比赛基本结束，接下来滴滴要打客场比赛（国际化）。”程维毫不掩饰其征战全球的野心，他相继投资了东南亚的Grabtaxi、印度的Ola以及美国的Lyft，组建起“滴滴国际联盟”，对手正是出行巨兽Uber全球。 32 | 而在王兴看来，“国际化和全球化这两个词是有细微差别的。国际化是默认国家是最核心的单元，认为国家是天然边界，同时还是多语言化、多货币化、多人种化。而全球化是覆盖全球概念，它不认为国家是最重要的，可能对它来讲，语言是最重要的。我觉得全球化是个最统称的概念。” 33 | 今年上半年，王兴走访了硅谷、柏林、以色列、雅加达，他已经开始考虑全球化的问题，“我们本土市场比较大，先搞定本土市场，然后再往外走。第一，国际化一定要做，第二，国际化急也急不得，这是一个长期战役，我觉得不是一两年，也不是五年，很可能是十年以上才会有大成的事情。” 34 | 大多数时间，王兴的脑子里都在思考“边界的事情”。在他看来，把事物划分一半一半是最容易的，但事物的发展轨迹并非如此简单。或许在骨子里，王兴依然是一位执着而痴迷的极客，互联网下半场的大幕拉开，没有人知道，他们打出的下一张牌会是什么。 35 | 更多专业报道，请点击下载“界面新闻”APP 36 | //执行获取文章信息函数 37 | var aid = '1000001'; 38 | 39 | 40 | -------------------------------------------------------------------------------- /dataClean.py: -------------------------------------------------------------------------------- 1 | #encoding=utf-8 2 | 3 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 4 | from __future__ import unicode_literals 5 | import sys 6 | import json 7 | import os 8 | 9 | # 操作中文必须语句，解决字符问题 10 | reload(sys) 11 | sys.setdefaultencoding('utf8') 12 | 13 | # 数据清洗(读取用户自定义标签字典，去重) 14 | import codecs 15 | import fileHandle 16 | 17 | # 字典文件读取 18 | def dict_read(fileName, path): 19 | filePath = os.path.join(path, fileName) 20 | dictFileObject = open(filePath, 'r') # 进行分词文件的读取 21 | dictDatas = [] 22 | for line in dictFileObject: 23 | word = line.strip('\n') # 去除换行符 24 | dictDatas.append(word) 25 | return dictDatas 26 | 27 | # jieba字典文件读取 28 | def jieba_dict_read(): 29 | path = 'dict_file/' 30 | fileName = 'dict.txt.big' 31 | filePath = os.path.join(path, fileName) 32 | dictFileObject = open(filePath, 'r') # 进行分词文件的读取 33 | dictDatas = [] 34 | for line in dictFileObject: 35 | wordStr = line.strip('\n') # 去除换行符 36 | wordData = wordStr.split(' ') 37 | word = wordData[0] 38 | dictDatas.append(word) 39 | return dictDatas 40 | 41 | # 字典文件写入 42 | # 默认方式：追加 43 | def dict_write(data, fileName, path, mode = 'a+'): 44 | filePath = os.path.join(path, fileName) 45 | fileObject = codecs.open(filePath, mode, 'utf-8') 46 | for word in data: 47 | fileObject.write(word) 48 | fileObject.write(' ') 49 | # 字典中词频越高,成词概率越大 50 | fileObject.write('4') 51 | fileObject.write(' ') 52 | fileObject.write('n') 53 | fileObject.write('\n') 54 | fileObject.close() 55 | 56 | if __name__ == "__main__": 57 | pass 58 | # 进行进一步处理（对于其中已经存在于jieba字典中的进行剔除） 59 | fileName = 'user_dict_back.txt' 60 | path = 'dict_file/' 61 | wordDatas = dict_read(fileName, path) 62 | print len(wordDatas) 63 | processedWordDatas = list(set(wordDatas)) 64 | jiebaDictWordDatas = jieba_dict_read() 65 | writeData= [] 66 | for word in processedWordDatas: 67 | if word in jiebaDictWordDatas: 68 | print word 69 | pass 70 | #processedWordDatas.remove(word) 71 | else: 72 | writeData.append(word) 73 | 74 | fileName = 'user_dict.txt' 75 | dict_write(writeData, fileName, path, mode='r+') 76 | # print fileData -------------------------------------------------------------------------------- /dict_file/part_of_speech.txt: -------------------------------------------------------------------------------- 1 | 1. 名词 (1个一类，7个二类，5个三类) 2 | 名词分为以下子类： 3 | n 名词 4 | nr 人名 5 | nr1 汉语姓氏 6 | nr2 汉语名字 7 | nrj 日语人名 8 | nrf 音译人名 9 | ns 地名 10 | nsf 音译地名 11 | nt 机构团体名 12 | nz 其它专名 13 | nl 名词性惯用语 14 | ng 名词性语素 15 | 16 | 2. 时间词(1个一类，1个二类) 17 | t 时间词 18 | tg 时间词性语素 19 | 20 | 3. 处所词(1个一类) 21 | s 处所词 22 | 23 | 4. 方位词(1个一类) 24 | f 方位词 25 | 26 | 5. 动词(1个一类，9个二类) 27 | v 动词 28 | vd 副动词 29 | vn 名动词 30 | vshi 动词“是” 31 | vyou 动词“有” 32 | vf 趋向动词 33 | vx 形式动词 34 | vi 不及物动词（内动词） 35 | vl 动词性惯用语 36 | vg 动词性语素 37 | 38 | 6. 形容词(1个一类，4个二类) 39 | a 形容词 40 | ad 副形词 41 | an 名形词 42 | ag 形容词性语素 43 | al 形容词性惯用语 44 | 45 | 7. 区别词(1个一类，2个二类) 46 | b 区别词 47 | bl 区别词性惯用语 48 | 49 | 8. 状态词(1个一类) 50 | z 状态词 51 | 52 | 9. 代词(1个一类，4个二类，6个三类) 53 | r 代词 54 | rr 人称代词 55 | rz 指示代词 56 | rzt 时间指示代词 57 | rzs 处所指示代词 58 | rzv 谓词性指示代词 59 | ry 疑问代词 60 | ryt 时间疑问代词 61 | rys 处所疑问代词 62 | ryv 谓词性疑问代词 63 | rg 代词性语素 64 | 65 | 10. 数词(1个一类，1个二类) 66 | m 数词 67 | mq 数量词 68 | 69 | 11. 量词(1个一类，2个二类) 70 | q 量词 71 | qv 动量词 72 | qt 时量词 73 | 74 | 12. 副词(1个一类) 75 | d 副词 76 | 77 | 13. 介词(1个一类，2个二类) 78 | p 介词 79 | pba 介词“把” 80 | pbei 介词“被” 81 | 82 | 14. 连词(1个一类，1个二类) 83 | c 连词 84 | cc 并列连词 85 | 86 | 15. 助词(1个一类，15个二类) 87 | u 助词 88 | uzhe 着 89 | ule 了 喽 90 | uguo 过 91 | ude1 的 底 92 | ude2 地 93 | ude3 得 94 | usuo 所 95 | udeng 等 等等 云云 96 | uyy 一样 一般 似的 般 97 | udh 的话 98 | uls 来讲 来说 而言 说来 99 | uzhi 之 100 | ulian 连 （“连小学生都会”） 101 | 102 | 16. 叹词(1个一类) 103 | e 叹词 104 | 105 | 17. 语气词(1个一类) 106 | y 语气词(delete yg) 107 | 108 | 18. 拟声词(1个一类) 109 | o 拟声词 110 | 111 | 19. 前缀(1个一类) 112 | h 前缀 113 | 114 | 20. 后缀(1个一类) 115 | k 后缀 116 | 117 | 21. 字符串(1个一类，2个二类) 118 | x 字符串 119 | xx 非语素字 120 | xu 网址URL 121 | 122 | 22. 标点符号(1个一类，16个二类) 123 | w 标点符号 124 | wkz 左括号，全角：（ 〔 ［ ｛ 《 【 〖 〈 半角：( [ { < 125 | wky 右括号，全角：） 〕 ］ ｝ 》 】 〗 〉 半角： ) ] { > 126 | wyz 左引号，全角：“ ‘ 『 127 | wyy 右引号，全角：” ’ 』 128 | wj 句号，全角：。 129 | ww 问号，全角：？ 半角：? 130 | wt 叹号，全角：！ 半角：! 131 | wd 逗号，全角：， 半角：, 132 | wf 分号，全角：； 半角： ; 133 | wn 顿号，全角：、 134 | wm 冒号，全角：： 半角： : 135 | ws 省略号，全角：…… … 136 | wp 破折号，全角：—— －－ ——－ 半角：--- ---- 137 | wb 百分号千分号，全角：％ ‰ 半角：% 138 | wh 单位符号，全角：￥ ＄ ￡ ° ℃ 半角：$ 139 | 140 | 141 | 142 | ag 形语素(形容词性语素。形容词代码为 a，语素代码ｇ前面置以A。) 143 | a 形容词(取英语形容词 adjective的第1个字母。) 144 | ad 副形词(直接作状语的形容词。形容词代码 a和副词代码d并在一起。) 145 | an 名形词(具有名词功能的形容词。形容词代码 a和名词代码n并在一起。) 146 | b 区别词(取汉字“别”的声母。) 147 | c 连词(取英语连词 conjunction的第1个字母。) 148 | dg 副语素(副词性语素。副词代码为 d，语素代码ｇ前面置以D。) 149 | d 副词(取 adverb的第2个字母，因其第1个字母已用于形容词。) 150 | e 叹词(取英语叹词 exclamation的第1个字母。) 151 | f 方位词(取汉字“方”) 152 | g 语素(绝大多数语素都能作为合成词的“词根”，取汉字“根”的声母。) 153 | h 前接成分(取英语 head的第1个字母。) 154 | i 成语(取英语成语 idiom的第1个字母。) 155 | j 简称略语(取汉字“简”的声母。) 156 | k 后接成分 157 | l 习用语(习用语尚未成为成语，有点“临时性”，取“临”的声母。) 158 | m 数词(取英语 numeral的第3个字母，n，u已有他用。) 159 | ng 名语素(名词性语素。名词代码为 n，语素代码ｇ前面置以N。) 160 | n 名词(取英语名词 noun的第1个字母。) 161 | nr 人名(名词代码 n和“人(ren)”的声母并在一起。) 162 | ns 地名(名词代码 n和处所词代码s并在一起。) 163 | nt 机构团体(“团”的声母为 t，名词代码n和t并在一起。) 164 | nz 其他专名(“专”的声母的第 1个字母为z，名词代码n和z并在一起。) 165 | o 拟声词(取英语拟声词 onomatopoeia的第1个字母。) 166 | p 介词(取英语介词 prepositional的第1个字母。) 167 | q 量词(取英语 quantity的第1个字母。) 168 | r 代词(取英语代词 pronoun的第2个字母,因p已用于介词。 ) 169 | s 处所词(取英语 space的第1个字母。 ) 170 | tg 时语素(时间词性语素。时间词代码为 t,在语素的代码g前面置以T。) 171 | t 时间词(取英语 time的第1个字母。 ) 172 | u 助词(取英语助词 auxiliary ) 173 | vg 动语素(动词性语素。动词代码为 v。在语素的代码g前面置以V。 ) 174 | v 动词(取英语动词 verb的第一个字母。 ) 175 | vd (直接作状语的动词。动词和副词的代码并在一起。 ) 176 | vn 名动词(指具有名词功能的动词。动词和名词的代码并在一起。 ) 177 | w 标点符号 178 | x 非语素字(非语素字只是一个符号，字母 x通常用于代表未知数、符号。 ) 179 | y 语气词(取汉字“语”的声母。 ) 180 | z 状态词(取汉字“状”的声母的前一个字母。 ) -------------------------------------------------------------------------------- /dict_file/stop_words.txt: -------------------------------------------------------------------------------- 1 | ? 2 | 、 3 | 。 4 | “ 5 | ” 6 | 《 7 | 》 8 | ！ 9 | ， 10 | ： 11 | ； 12 | ？ 13 | 啊 14 | 阿 15 | 哎 16 | 哎呀 17 | 哎哟 18 | 唉 19 | 俺 20 | 俺们 21 | 按 22 | 按照 23 | 吧 24 | 吧哒 25 | 把 26 | 罢了 27 | 被 28 | 本 29 | 本着 30 | 比 31 | 比方 32 | 比如 33 | 鄙人 34 | 彼 35 | 彼此 36 | 边 37 | 别 38 | 别的 39 | 别说 40 | 并 41 | 并且 42 | 不比 43 | 不成 44 | 不单 45 | 不但 46 | 不独 47 | 不管 48 | 不光 49 | 不过 50 | 不仅 51 | 不拘 52 | 不论 53 | 不怕 54 | 不然 55 | 不如 56 | 不特 57 | 不惟 58 | 不问 59 | 不只 60 | 朝 61 | 朝着 62 | 趁 63 | 趁着 64 | 乘 65 | 冲 66 | 除 67 | 除此之外 68 | 除非 69 | 除了 70 | 此 71 | 此间 72 | 此外 73 | 从 74 | 从而 75 | 打 76 | 待 77 | 但 78 | 但是 79 | 当 80 | 当着 81 | 到 82 | 得 83 | 的 84 | 的话 85 | 等 86 | 等等 87 | 地 88 | 第 89 | 叮咚 90 | 对 91 | 对于 92 | 多 93 | 多少 94 | 而 95 | 而况 96 | 而且 97 | 而是 98 | 而外 99 | 而言 100 | 而已 101 | 尔后 102 | 反过来 103 | 反过来说 104 | 反之 105 | 非但 106 | 非徒 107 | 否则 108 | 嘎 109 | 嘎登 110 | 该 111 | 赶 112 | 个 113 | 各 114 | 各个 115 | 各位 116 | 各种 117 | 各自 118 | 给 119 | 根据 120 | 跟 121 | 故 122 | 故此 123 | 固然 124 | 关于 125 | 管 126 | 归 127 | 果然 128 | 果真 129 | 过 130 | 哈 131 | 哈哈 132 | 呵 133 | 和 134 | 何 135 | 何处 136 | 何况 137 | 何时 138 | 嘿 139 | 哼 140 | 哼唷 141 | 呼哧 142 | 乎 143 | 哗 144 | 还是 145 | 还有 146 | 换句话说 147 | 换言之 148 | 或 149 | 或是 150 | 或者 151 | 极了 152 | 及 153 | 及其 154 | 及至 155 | 即 156 | 即便 157 | 即或 158 | 即令 159 | 即若 160 | 即使 161 | 几 162 | 几时 163 | 己 164 | 既 165 | 既然 166 | 既是 167 | 继而 168 | 加之 169 | 假如 170 | 假若 171 | 假使 172 | 鉴于 173 | 将 174 | 较 175 | 较之 176 | 叫 177 | 接着 178 | 结果 179 | 借 180 | 紧接着 181 | 进而 182 | 尽 183 | 尽管 184 | 经 185 | 经过 186 | 就 187 | 就是 188 | 就是说 189 | 据 190 | 具体地说 191 | 具体说来 192 | 开始 193 | 开外 194 | 靠 195 | 咳 196 | 可 197 | 可见 198 | 可是 199 | 可以 200 | 况且 201 | 啦 202 | 来 203 | 来着 204 | 离 205 | 例如 206 | 哩 207 | 连 208 | 连同 209 | 两者 210 | 了 211 | 临 212 | 另 213 | 另外 214 | 另一方面 215 | 论 216 | 嘛 217 | 吗 218 | 慢说 219 | 漫说 220 | 冒 221 | 么 222 | 每 223 | 每当 224 | 们 225 | 莫若 226 | 某 227 | 某个 228 | 某些 229 | 拿 230 | 哪 231 | 哪边 232 | 哪儿 233 | 哪个 234 | 哪里 235 | 哪年 236 | 哪怕 237 | 哪天 238 | 哪些 239 | 哪样 240 | 那 241 | 那边 242 | 那儿 243 | 那个 244 | 那会儿 245 | 那里 246 | 那么 247 | 那么些 248 | 那么样 249 | 那时 250 | 那些 251 | 那样 252 | 乃 253 | 乃至 254 | 呢 255 | 能 256 | 你 257 | 你们 258 | 您 259 | 宁 260 | 宁可 261 | 宁肯 262 | 宁愿 263 | 哦 264 | 呕 265 | 啪达 266 | 旁人 267 | 呸 268 | 凭 269 | 凭借 270 | 其 271 | 其次 272 | 其二 273 | 其他 274 | 其它 275 | 其一 276 | 其余 277 | 其中 278 | 起 279 | 起见 280 | 起见 281 | 岂但 282 | 恰恰相反 283 | 前后 284 | 前者 285 | 且 286 | 然而 287 | 然后 288 | 然则 289 | 让 290 | 人家 291 | 任 292 | 任何 293 | 任凭 294 | 如 295 | 如此 296 | 如果 297 | 如何 298 | 如其 299 | 如若 300 | 如上所述 301 | 若 302 | 若非 303 | 若是 304 | 啥 305 | 上下 306 | 尚且 307 | 设若 308 | 设使 309 | 甚而 310 | 甚么 311 | 甚至 312 | 省得 313 | 时候 314 | 什么 315 | 什么样 316 | 使得 317 | 是 318 | 是的 319 | 首先 320 | 谁 321 | 谁知 322 | 顺 323 | 顺着 324 | 似的 325 | 虽 326 | 虽然 327 | 虽说 328 | 虽则 329 | 随 330 | 随着 331 | 所 332 | 所以 333 | 他 334 | 他们 335 | 他人 336 | 它 337 | 它们 338 | 她 339 | 她们 340 | 倘 341 | 倘或 342 | 倘然 343 | 倘若 344 | 倘使 345 | 腾 346 | 替 347 | 通过 348 | 同 349 | 同时 350 | 哇 351 | 万一 352 | 往 353 | 望 354 | 为 355 | 为何 356 | 为了 357 | 为什么 358 | 为着 359 | 喂 360 | 嗡嗡 361 | 我 362 | 我们 363 | 呜 364 | 呜呼 365 | 乌乎 366 | 无论 367 | 无宁 368 | 毋宁 369 | 嘻 370 | 吓 371 | 相对而言 372 | 像 373 | 向 374 | 向着 375 | 嘘 376 | 呀 377 | 焉 378 | 沿 379 | 沿着 380 | 要 381 | 要不 382 | 要不然 383 | 要不是 384 | 要么 385 | 要是 386 | 也 387 | 也罢 388 | 也好 389 | 一 390 | 一般 391 | 一旦 392 | 一方面 393 | 一来 394 | 一切 395 | 一样 396 | 一则 397 | 依 398 | 依照 399 | 矣 400 | 以 401 | 以便 402 | 以及 403 | 以免 404 | 以至 405 | 以至于 406 | 以致 407 | 抑或 408 | 因 409 | 因此 410 | 因而 411 | 因为 412 | 哟 413 | 用 414 | 由 415 | 由此可见 416 | 由于 417 | 有 418 | 有的 419 | 有关 420 | 有些 421 | 又 422 | 于 423 | 于是 424 | 于是乎 425 | 与 426 | 与此同时 427 | 与否 428 | 与其 429 | 越是 430 | 云云 431 | 哉 432 | 再说 433 | 再者 434 | 在 435 | 在下 436 | 咱 437 | 咱们 438 | 则 439 | 怎 440 | 怎么 441 | 怎么办 442 | 怎么样 443 | 怎样 444 | 咋 445 | 照 446 | 照着 447 | 者 448 | 这 449 | 这边 450 | 这儿 451 | 这个 452 | 这会儿 453 | 这就是说 454 | 这里 455 | 这么 456 | 这么点儿 457 | 这么些 458 | 这么样 459 | 这时 460 | 这些 461 | 这样 462 | 正如 463 | 吱 464 | 之 465 | 之类 466 | 之所以 467 | 之一 468 | 只是 469 | 只限 470 | 只要 471 | 只有 472 | 至 473 | 至于 474 | 诸位 475 | 着 476 | 着呢 477 | 自 478 | 自从 479 | 自个儿 480 | 自各儿 481 | 自己 482 | 自家 483 | 自身 484 | 综上所述 485 | 总的来看 486 | 总的来说 487 | 总的说来 488 | 总而言之 489 | 总之 490 | 纵 491 | 纵令 492 | 纵然 493 | 纵使 494 | 遵照 495 | 作为 496 | 兮 497 | 呃 498 | 呗 499 | 咚 500 | 咦 501 | 喏 502 | 啐 503 | 喔唷 504 | 嗬 505 | 嗯 506 | 嗳 507 | a 508 | able 509 | about 510 | above 511 | abroad 512 | according 513 | accordingly 514 | across 515 | actually 516 | adj 517 | after 518 | afterwards 519 | again 520 | against 521 | ago 522 | ahead 523 | ain't 524 | all 525 | allow 526 | allows 527 | almost 528 | alone 529 | along 530 | alongside 531 | already 532 | also 533 | although 534 | always 535 | am 536 | amid 537 | amidst 538 | among 539 | amongst 540 | an 541 | and 542 | another 543 | any 544 | anybody 545 | anyhow 546 | anyone 547 | anything 548 | anyway 549 | anyways 550 | anywhere 551 | apart 552 | appear 553 | appreciate 554 | appropriate 555 | are 556 | aren't 557 | around 558 | as 559 | a's 560 | aside 561 | ask 562 | asking 563 | associated 564 | at 565 | available 566 | away 567 | awfully 568 | b 569 | back 570 | backward 571 | backwards 572 | be 573 | became 574 | because 575 | become 576 | becomes 577 | becoming 578 | been 579 | before 580 | beforehand 581 | begin 582 | behind 583 | being 584 | believe 585 | below 586 | beside 587 | besides 588 | best 589 | better 590 | between 591 | beyond 592 | both 593 | brief 594 | but 595 | by 596 | c 597 | came 598 | can 599 | cannot 600 | cant 601 | can't 602 | caption 603 | cause 604 | causes 605 | certain 606 | certainly 607 | changes 608 | clearly 609 | c'mon 610 | co 611 | co. 612 | com 613 | come 614 | comes 615 | concerning 616 | consequently 617 | consider 618 | considering 619 | contain 620 | containing 621 | contains 622 | corresponding 623 | could 624 | couldn't 625 | course 626 | c's 627 | currently 628 | d 629 | dare 630 | daren't 631 | definitely 632 | described 633 | despite 634 | did 635 | didn't 636 | different 637 | directly 638 | do 639 | does 640 | doesn't 641 | doing 642 | done 643 | don't 644 | down 645 | downwards 646 | during 647 | e 648 | each 649 | edu 650 | eg 651 | eight 652 | eighty 653 | either 654 | else 655 | elsewhere 656 | end 657 | ending 658 | enough 659 | entirely 660 | especially 661 | et 662 | etc 663 | even 664 | ever 665 | evermore 666 | every 667 | everybody 668 | everyone 669 | everything 670 | everywhere 671 | ex 672 | exactly 673 | example 674 | except 675 | f 676 | fairly 677 | far 678 | farther 679 | few 680 | fewer 681 | fifth 682 | first 683 | five 684 | followed 685 | following 686 | follows 687 | for 688 | forever 689 | former 690 | formerly 691 | forth 692 | forward 693 | found 694 | four 695 | from 696 | further 697 | furthermore 698 | g 699 | get 700 | gets 701 | getting 702 | given 703 | gives 704 | go 705 | goes 706 | going 707 | gone 708 | got 709 | gotten 710 | greetings 711 | h 712 | had 713 | hadn't 714 | half 715 | happens 716 | hardly 717 | has 718 | hasn't 719 | have 720 | haven't 721 | having 722 | he 723 | he'd 724 | he'll 725 | hello 726 | help 727 | hence 728 | her 729 | here 730 | hereafter 731 | hereby 732 | herein 733 | here's 734 | hereupon 735 | hers 736 | herself 737 | he's 738 | hi 739 | him 740 | himself 741 | his 742 | hither 743 | hopefully 744 | how 745 | howbeit 746 | however 747 | hundred 748 | i 749 | i'd 750 | ie 751 | if 752 | ignored 753 | i'll 754 | i'm 755 | immediate 756 | in 757 | inasmuch 758 | inc 759 | inc. 760 | indeed 761 | indicate 762 | indicated 763 | indicates 764 | inner 765 | inside 766 | insofar 767 | instead 768 | into 769 | inward 770 | is 771 | isn't 772 | it 773 | it'd 774 | it'll 775 | its 776 | it's 777 | itself 778 | i've 779 | j 780 | just 781 | k 782 | keep 783 | keeps 784 | kept 785 | know 786 | known 787 | knows 788 | l 789 | last 790 | lately 791 | later 792 | latter 793 | latterly 794 | least 795 | less 796 | lest 797 | let 798 | let's 799 | like 800 | liked 801 | likely 802 | likewise 803 | little 804 | look 805 | looking 806 | looks 807 | low 808 | lower 809 | ltd 810 | m 811 | made 812 | mainly 813 | make 814 | makes 815 | many 816 | may 817 | maybe 818 | mayn't 819 | me 820 | mean 821 | meantime 822 | meanwhile 823 | merely 824 | might 825 | mightn't 826 | mine 827 | minus 828 | miss 829 | more 830 | moreover 831 | most 832 | mostly 833 | mr 834 | mrs 835 | much 836 | must 837 | mustn't 838 | my 839 | myself 840 | n 841 | name 842 | namely 843 | nd 844 | near 845 | nearly 846 | necessary 847 | need 848 | needn't 849 | needs 850 | neither 851 | never 852 | neverf 853 | neverless 854 | nevertheless 855 | new 856 | next 857 | nine 858 | ninety 859 | no 860 | nobody 861 | non 862 | none 863 | nonetheless 864 | noone 865 | no-one 866 | nor 867 | normally 868 | not 869 | nothing 870 | notwithstanding 871 | novel 872 | now 873 | nowhere 874 | o 875 | obviously 876 | of 877 | off 878 | often 879 | oh 880 | ok 881 | okay 882 | old 883 | on 884 | once 885 | one 886 | ones 887 | one's 888 | only 889 | onto 890 | opposite 891 | or 892 | other 893 | others 894 | otherwise 895 | ought 896 | oughtn't 897 | our 898 | ours 899 | ourselves 900 | out 901 | outside 902 | over 903 | overall 904 | own 905 | p 906 | particular 907 | particularly 908 | past 909 | per 910 | perhaps 911 | placed 912 | please 913 | plus 914 | possible 915 | presumably 916 | probably 917 | provided 918 | provides 919 | q 920 | que 921 | quite 922 | qv 923 | r 924 | rather 925 | rd 926 | re 927 | really 928 | reasonably 929 | recent 930 | recently 931 | regarding 932 | regardless 933 | regards 934 | relatively 935 | respectively 936 | right 937 | round 938 | s 939 | said 940 | same 941 | saw 942 | say 943 | saying 944 | says 945 | second 946 | secondly 947 | see 948 | seeing 949 | seem 950 | seemed 951 | seeming 952 | seems 953 | seen 954 | self 955 | selves 956 | sensible 957 | sent 958 | serious 959 | seriously 960 | seven 961 | several 962 | shall 963 | shan't 964 | she 965 | she'd 966 | she'll 967 | she's 968 | should 969 | shouldn't 970 | since 971 | six 972 | so 973 | some 974 | somebody 975 | someday 976 | somehow 977 | someone 978 | something 979 | sometime 980 | sometimes 981 | somewhat 982 | somewhere 983 | soon 984 | sorry 985 | specified 986 | specify 987 | specifying 988 | still 989 | sub 990 | such 991 | sup 992 | sure 993 | t 994 | take 995 | taken 996 | taking 997 | tell 998 | tends 999 | th 1000 | than 1001 | thank 1002 | thanks 1003 | thanx 1004 | that 1005 | that'll 1006 | thats 1007 | that's 1008 | that've 1009 | the 1010 | their 1011 | theirs 1012 | them 1013 | themselves 1014 | then 1015 | thence 1016 | there 1017 | thereafter 1018 | thereby 1019 | there'd 1020 | therefore 1021 | therein 1022 | there'll 1023 | there're 1024 | theres 1025 | there's 1026 | thereupon 1027 | there've 1028 | these 1029 | they 1030 | they'd 1031 | they'll 1032 | they're 1033 | they've 1034 | thing 1035 | things 1036 | think 1037 | third 1038 | thirty 1039 | this 1040 | thorough 1041 | thoroughly 1042 | those 1043 | though 1044 | three 1045 | through 1046 | throughout 1047 | thru 1048 | thus 1049 | till 1050 | to 1051 | together 1052 | too 1053 | took 1054 | toward 1055 | towards 1056 | tried 1057 | tries 1058 | truly 1059 | try 1060 | trying 1061 | t's 1062 | twice 1063 | two 1064 | u 1065 | un 1066 | under 1067 | underneath 1068 | undoing 1069 | unfortunately 1070 | unless 1071 | unlike 1072 | unlikely 1073 | until 1074 | unto 1075 | up 1076 | upon 1077 | upwards 1078 | us 1079 | use 1080 | used 1081 | useful 1082 | uses 1083 | using 1084 | usually 1085 | v 1086 | value 1087 | various 1088 | versus 1089 | very 1090 | via 1091 | viz 1092 | vs 1093 | w 1094 | want 1095 | wants 1096 | was 1097 | wasn't 1098 | way 1099 | we 1100 | we'd 1101 | welcome 1102 | well 1103 | we'll 1104 | went 1105 | were 1106 | we're 1107 | weren't 1108 | we've 1109 | what 1110 | whatever 1111 | what'll 1112 | what's 1113 | what've 1114 | when 1115 | whence 1116 | whenever 1117 | where 1118 | whereafter 1119 | whereas 1120 | whereby 1121 | wherein 1122 | where's 1123 | whereupon 1124 | wherever 1125 | whether 1126 | which 1127 | whichever 1128 | while 1129 | whilst 1130 | whither 1131 | who 1132 | who'd 1133 | whoever 1134 | whole 1135 | who'll 1136 | whom 1137 | whomever 1138 | who's 1139 | whose 1140 | why 1141 | will 1142 | willing 1143 | wish 1144 | with 1145 | within 1146 | without 1147 | wonder 1148 | won't 1149 | would 1150 | wouldn't 1151 | x 1152 | y 1153 | yes 1154 | yet 1155 | you 1156 | you'd 1157 | you'll 1158 | your 1159 | you're 1160 | yours 1161 | yourself 1162 | yourselves 1163 | you've 1164 | z 1165 | zero -------------------------------------------------------------------------------- /dict_file/user_dict.txt: -------------------------------------------------------------------------------- 1 | 江苏银行 4 n 2 | 财经资讯 4 n 3 | 境外投资 4 n 4 | 私募基金 4 n 5 | 混合基金 4 n 6 | 大并购 4 n 7 | 中国华融 4 n 8 | 证金公司 4 n 9 | 政府监管 4 n 10 | 养老金入市 4 n 11 | 东方红新动力 4 n 12 | 苏宁环球 4 n 13 | 华人富豪 4 n 14 | 微信 4 n 15 | 影子银行 4 n 16 | TCL集团 4 n 17 | 银行卡清算 4 n 18 | 股权投资 4 n 19 | 黄金ETF 4 n 20 | 中植系 4 n 21 | 京津冀一体化 4 n 22 | 内幕交易 4 n 23 | 回归A股 4 n 24 | 汽车金融 4 n 25 | NFC 4 n 26 | 中国人寿 4 n 27 | 结构化理财 4 n 28 | 定增 4 n 29 | 消费金融 4 n 30 | 蓝思科技 4 n 31 | 中银基金 4 n 32 | 华尔道夫 4 n 33 | 政策解读 4 n 34 | 日日盈 4 n 35 | 高管 4 n 36 | lending club 4 n 37 | 虚拟货币 4 n 38 | 金融诈骗 4 n 39 | 美国运通 4 n 40 | 大智慧 4 n 41 | 比特币 4 n 42 | 两会动态 4 n 43 | 云计算 4 n 44 | 开鑫 4 n 45 | 跨国并购 4 n 46 | 复星集团 4 n 47 | 股权众筹 4 n 48 | ST股票 4 n 49 | 银行股 4 n 50 | 信用体系 4 n 51 | 理财教育 4 n 52 | UP技能 4 n 53 | 人民币国际化 4 n 54 | P2P网贷 4 n 55 | 财报那些事 4 n 56 | 大数据 4 n 57 | 天弘基金 4 n 58 | 在线支付 4 n 59 | 机器学习 4 n 60 | 公募债券 4 n 61 | 首创集团 4 n 62 | 理财红黑榜 4 n 63 | 一行三会 4 n 64 | 周周发 4 n 65 | 中概股 4 n 66 | 伊利股份 4 n 67 | 人民的名义 4 n 68 | 在线外汇交易 4 n 69 | 安邦保险 4 n 70 | iPhone 4 n 71 | 中国平安 4 n 72 | 场景消费 4 n 73 | IPO 4 n 74 | 两会前瞻 4 n 75 | 西南证券 4 n 76 | 海通证券 4 n 77 | QDII 4 n 78 | 打新 4 n 79 | PPP项目 4 n 80 | P2P 4 n 81 | 分红套现 4 n 82 | 上投摩根 4 n 83 | 社保基金 4 n 84 | 可穿戴设备 4 n 85 | 活期理财 4 n 86 | 森马服饰 4 n 87 | 马云 4 n 88 | 大宗商品 4 n 89 | 指数基金 4 n 90 | 做空 4 n 91 | 博鳌亚洲论坛 4 n 92 | 唐纳德·特朗普 4 n 93 | 蚂蚁金服 4 n 94 | 上汽集团 4 n 95 | 芝麻信用 4 n 96 | 沪股通 4 n 97 | 风控 4 n 98 | 中国股市 4 n 99 | 移动电商 4 n 100 | 资产证券化 4 n 101 | 互联网+ 4 n 102 | 新能源汽车 4 n 103 | 价值投资 4 n 104 | 股指期货 4 n 105 | 庞氏骗局 4 n 106 | 日益月鑫 4 n 107 | 富国基金 4 n 108 | 独家重磅 4 n 109 | 互联网金融 4 n 110 | 共享单车 4 n 111 | 海外收购 4 n 112 | 今日股市消息 4 n 113 | 红包大战 4 n 114 | 中国建筑 4 n 115 | 陆金所 4 n 116 | 新经济时代 4 n 117 | 反腐聚焦 4 n 118 | 拉卡拉 4 n 119 | 博时主题 4 n 120 | 许家印 4 n 121 | 沪港通 4 n 122 | 宜信 4 n 123 | 易到用车 4 n 124 | 财报 4 n 125 | 兴业证券 4 n 126 | 快鹿集团 4 n 127 | 资本市场 4 n 128 | 公司治理 4 n 129 | 重阳投资 4 n 130 | 金融科技 4 n 131 | 华夏幸福 4 n 132 | 万能险 4 n 133 | 私募股权 4 n 134 | 我们看剧 4 n 135 | 高收益理财 4 n 136 | 谷歌 4 n 137 | 全产业链 4 n 138 | 高送转 4 n 139 | 投资风向标 4 n 140 | FOF 4 n 141 | PPP模式 4 n 142 | 思维方式 4 n 143 | 中国人保 4 n 144 | 至极黑卡 4 n 145 | 广发证券 4 n 146 | 摩根大通 4 n 147 | 类活期 4 n 148 | 奇虎360 4 n 149 | 京东金融 4 n 150 | 泰康保险 4 n 151 | 雄安新区 4 n 152 | 农村经济 4 n 153 | 权威声音 4 n 154 | 两会热点 4 n 155 | 互联网+三农 4 n 156 | 区块链 4 n 157 | 北京城建 4 n 158 | 财经早餐 4 n 159 | 聚益生金 4 n 160 | 税收改革 4 n 161 | 贝恩 4 n 162 | 移动支付 4 n 163 | PPP 4 n 164 | 朝招金 4 n 165 | 一带一路 4 n 166 | VC 4 n 167 | 普惠金融 4 n 168 | 供给侧改革 4 n 169 | 郭广昌 4 n 170 | 新华保险 4 n 171 | 机构动态 4 n 172 | 股票型基金 4 n 173 | 金融产品测评 4 n 174 | 转型升级 4 n 175 | 贵州茅台 4 n 176 | 监管风向标 4 n 177 | 失信惩戒 4 n 178 | 投行 4 n 179 | 报告发布 4 n 180 | 智能投顾 4 n 181 | 众安保险 4 n 182 | 海外资产管理公司 4 n 183 | 中国太保 4 n 184 | 民间高利贷 4 n 185 | 两会提案 4 n 186 | 定向增发 4 n 187 | 财富宝 4 n 188 | 股票基金 4 n 189 | 信用与借贷 4 n 190 | 中国神华 4 n 191 | 山水水泥 4 n 192 | 网贷之家 4 n 193 | 注册制 4 n 194 | AMC 4 n 195 | "民营银行 4 n 196 | 债务违约 4 n 197 | 银行服务 4 n 198 | 个人征信 4 n 199 | 顺丰 4 n 200 | 跨境投资 4 n 201 | 资金池 4 n 202 | 新三板 4 n 203 | 辉山乳业 4 n 204 | 月月盈 4 n 205 | 银行理财 4 n 206 | 投贷联动 4 n 207 | IDG 4 n 208 | 光大证券 4 n 209 | 金融改革 4 n 210 | 华夏基金 4 n 211 | 乐视 4 n 212 | 湘财证券 4 n 213 | 新希望 4 n 214 | REITs 4 n 215 | GDP 4 n 216 | LED 4 n 217 | 风险控制 4 n 218 | 债券基金 4 n 219 | 第三方支付 4 n 220 | 政府调控 4 n 221 | 网贷 4 n 222 | 美股 4 n 223 | 资产配置 4 n 224 | 特色小镇 4 n 225 | A股市场 4 n 226 | VISA 4 n 227 | 平安银行 4 n 228 | 募资 4 n 229 | 消费者权益 4 n 230 | 微信红包 4 n 231 | 海外布局 4 n 232 | 壳资源 4 n 233 | 嘉实基金 4 n 234 | 家族企业传承 4 n 235 | 公募基金 4 n 236 | 工银瑞信 4 n 237 | 瑞士信贷 4 n 238 | 今日投资 4 n 239 | 刘士余 4 n 240 | 众筹 4 n 241 | -------------------------------------------------------------------------------- /dijkstra.py: -------------------------------------------------------------------------------- 1 | #encoding=utf-8 2 | 3 | # 文本预处理 4 | # 分词与词性标注 5 | # 词语过滤 6 | # 词语相关信息记录 7 | 8 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 9 | from __future__ import unicode_literals 10 | import os 11 | import json 12 | import sys 13 | # 操作中文必须语句，解决字符问题 14 | reload(sys) 15 | sys.setdefaultencoding('utf8') 16 | 17 | import json 18 | from sys import argv 19 | 20 | # 完成距离计算(当前中心点标记值+中心点到此点的权值) 21 | def dijkstra_score(G, shortest_distances, v, w): 22 | return shortest_distances[v] + G[v][w] 23 | 24 | 25 | # 此算法完成了从任意指定点startNode到图中任意一点最短距离的计算 26 | def dijkstra(G, startNode): 27 | print '------当前进行Dijkstra算法最短路径的计算操作------' 28 | # 未标记顶点集合 29 | unprocessed = set(G.keys()) # vertices whose shortest paths from source have not yet been calculated 30 | # 初始，将起始点移出 31 | try: 32 | unprocessed.remove(startNode) 33 | except: 34 | raise Exception('invild node!') 35 | # 已标记的顶点集合 36 | shortest_distances = {startNode: 0} 37 | # 进行路径存储 38 | path = {startNode: startNode} 39 | 40 | # 对所有顶点进行遍历 41 | for i in xrange(len(G) - 1): 42 | # find a vertex with the next shortest path, i.e. minimal Dijkstra score 43 | # m代表距离，closest_head代表相邻最近的顶点 44 | length, closest_head = float('inf'), 0 45 | 46 | # 最短路径的记录 47 | tmpPath = '' 48 | 49 | # 已处理顶点集合中的当前中心点 50 | for tail in shortest_distances: 51 | # 以已标记顶点集中点作为起点，遍历查询未标记顶点集中距离最小的点 52 | for head in G[tail]: 53 | # 对未标记的顶点集合进行遍历计算 54 | if head in unprocessed: 55 | distance = dijkstra_score(G, shortest_distances, tail, head) 56 | if distance < length: 57 | length, closest_head = distance, head 58 | # 最短路径记录 59 | tmpPath = tail + '->' + head 60 | # 查找到距离已标记顶点集合中的最近的邻接点，并标记记录 61 | 62 | 63 | # 会存在 64 | # 在未标记顶点集中移除 65 | if closest_head != 0: 66 | unprocessed.remove(closest_head) 67 | # 添加新的标记点 68 | shortest_distances[closest_head] = length 69 | # 最短路径记录 70 | flagList = tmpPath.split('->') 71 | path[closest_head] = path.get(flagList[0]) + '->' + flagList[1] 72 | else: 73 | unprocessed.pop() 74 | 75 | 76 | # in case G is not fully connected 77 | for vertex in unprocessed: 78 | shortest_distances[vertex] = float('inf') 79 | 80 | # 进行合并输出 81 | shortest_data = {} 82 | for key in shortest_distances: 83 | shortest_data[key] = { 84 | 'path': path.get(key), 85 | 'distance': shortest_distances.get(key) 86 | } 87 | 88 | return shortest_data 89 | 90 | 91 | if __name__ == '__main__': 92 | pass -------------------------------------------------------------------------------- /excel_handle.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf8 -*- 2 | 3 | import os 4 | import sys 5 | reload(sys) 6 | sys.setdefaultencoding('utf-8') 7 | 8 | import xlrd 9 | import xlwt 10 | from datetime import datetime 11 | import xlutils 12 | from xlutils.copy import copy 13 | 14 | # excel数据写入 15 | # 输入数据默认为二维数组 16 | def excel_write(fileName, data, path = "./file"): 17 | 18 | # 定义单元格格式 19 | style0 = xlwt.easyxf('font: name Times New Roman, color-index red, bold on', num_format_str='#,##0.00') 20 | style1 = xlwt.easyxf(num_format_str='D-MMM-YY') 21 | 22 | # 创建工作表 23 | wb = xlwt.Workbook() 24 | # sheetObj = wb.add_sheet('Sheet1') 25 | sheetObj = wb.sheet_by_name('Sheet1') 26 | 27 | # 获取写入数据的行数 28 | rowNum = len(data) 29 | 30 | # 写入数据 31 | # 插入超链接 32 | # link = 'HYPERLINK("#%s";"%s")' % (str(i), str(i)) 33 | # sheet_index.write(line, 0, xlwt.Formula(link)) 34 | for row in range(rowNum): 35 | values = [] 36 | colNum = len(data[row]) 37 | for col in range(colNum): 38 | if col == 1: 39 | # 对文章标题插入超链接 40 | # link = 'HYPERLINK("#%s";"%s")' % (data[row][col], data[row][col + 1]) 41 | link = 'HYPERLINK("%s";"%s")' % (data[row][col + 1], data[row][col]) 42 | sheetObj.write(row, col, xlwt.Formula(link)) 43 | elif col == 2: 44 | pass 45 | else: 46 | sheetObj.write(row, col, data[row][col]) 47 | 48 | # 文件存储 49 | filePath = os.path.join(path, fileName) 50 | wb.save(filePath) 51 | 52 | # excel数据读取 53 | def excel_read(fileName, path = "./file"): 54 | filePath = os.path.join(path, fileName) 55 | wb = xlrd.open_workbook(filePath) 56 | # 获取工作簿的个数 57 | sheetNum = wb.nsheets 58 | # 获取所有工作薄的名称 59 | sheetName = wb.sheet_names() 60 | # 获取指定工作薄(索引) 61 | sheetObj = wb.sheet_by_index(0) 62 | # 获取指定工作薄(按名称) 63 | #sheetObj = wb.sheet_by_name('Sheet1') 64 | # 获取指定工作薄的行数 65 | rowNum = sheetObj.nrows 66 | # 获取指定工作薄的列数 67 | colNum = sheetObj.ncols 68 | 69 | # 指定数据输出 70 | # data = [] 71 | # for row in range(rowNum): 72 | # values = [] 73 | # for col in range(colNum): 74 | # values.append(str(sheetObj.cell(row, col).value)) 75 | # print ','.join(values) 76 | # data.append(values) 77 | # return data 78 | 79 | # 仅返回指定行数,对象 80 | w_xls = copy(wb) 81 | return rowNum, colNum, w_xls 82 | 83 | 84 | # excel数据追加 85 | # 输入数据默认为二维数组 86 | def excel_add(fileName, data, path = "./file"): 87 | 88 | # 获取当前文件已有的行数,对象 89 | curRowNum, curColNum, w_xls = excel_read(fileName, path) 90 | print curRowNum 91 | sheet_write = w_xls.get_sheet(0) 92 | sheet_write.write(curRowNum, curColNum, 'class') 93 | 94 | # 定义单元格格式 95 | style0 = xlwt.easyxf('font: name Times New Roman, color-index red, bold on', num_format_str='#,##0.00') 96 | style1 = xlwt.easyxf(num_format_str='D-MMM-YY') 97 | 98 | # 创建工作表 99 | wb = xlwt.Workbook() 100 | sheetObj = wb.add_sheet('Sheet1') 101 | 102 | # 获取写入数据的行数 103 | rowNum = len(data) 104 | 105 | 106 | # 写入数据 107 | # 插入超链接 108 | # link = 'HYPERLINK("#%s";"%s")' % (str(i), str(i)) 109 | # sheet_index.write(line, 0, xlwt.Formula(link)) 110 | for row in range(rowNum): 111 | values = [] 112 | colNum = len(data[row]) 113 | for col in range(colNum): 114 | if col == 1: 115 | # 对文章标题插入超链接 116 | # link = 'HYPERLINK("#%s";"%s")' % (data[row][col], data[row][col + 1]) 117 | try: 118 | link = 'HYPERLINK("%s";"%s")' % (data[row][col + 1], data[row][col]) 119 | sheetObj.add(curRowNum + row, col, xlwt.Formula(link)) 120 | except: 121 | sheetObj.write(curRowNum + row, col, data[row][col]) 122 | sheetObj.write(curRowNum + row, col + 1, data[row][col + 1]) 123 | elif col == 2: 124 | pass 125 | else: 126 | sheetObj.write(curRowNum + row, col, data[row][col]) 127 | 128 | # 文件存储 129 | filePath = os.path.join(path, fileName) 130 | wb.save(filePath) 131 | 132 | 133 | 134 | def add_class(): 135 | wbk = xlwt.Workbook() 136 | workbook = xlrd.open_workbook('tag_record.xls') #r_xls 137 | sheet1 = workbook.sheet_by_index(0) #r_sheet 138 | rows = sheet1.row_values(0) 139 | cols = sheet1.col_values(20) 140 | #print len(cols) 141 | print cols[1] 142 | print type(cols[1]) 143 | print type('聚类-1') 144 | #rows_num = sheet1.nrows #50054 145 | w_xls = copy(workbook) 146 | sheet_write = w_xls.get_sheet(0) 147 | sheet_write.write(0,21,'class') 148 | for i in range(1, len(cols)): 149 | if cols[i] == u'聚类-1': 150 | sheet_write.write(i,21,1) 151 | if cols[i] == u'聚类-2' or cols[i] == u'聚类-4' or cols[i] == u'聚类-6' or cols[i] == u'聚类-11': 152 | sheet_write.write(i,21,2) 153 | if cols[i] == u'聚类-3' or cols[i] == u'聚类-5': 154 | sheet_write.write(i,21,3) 155 | if cols[i] == u'聚类-8': 156 | sheet_write.write(i,21,4) 157 | if cols[i] == u'聚类-9' or cols[i] == u'聚类-10': 158 | sheet_write.write(i,21,5) 159 | w_xls.save('tag_record.xls') 160 | 161 | 162 | def write_append(fileName, data, path): 163 | 164 | filePath = os.path.join(path, fileName) 165 | r_xls = xlrd.open_workbook(filePath) 166 | r_sheet = r_xls.sheet_by_index(0) 167 | rows = r_sheet.nrows 168 | w_xls = copy(r_xls) 169 | sheet_write = w_xls.get_sheet(0) 170 | 171 | for col in range(0, len(data)): 172 | # if col == 1: 173 | # # 对文章标题插入超链接 174 | # # link = 'HYPERLINK("#%s";"%s")' % (data[row][col], data[row][col + 1]) 175 | # try: 176 | # link = 'HYPERLINK("%s";"%s")' % (data[col + 1], data[col]) 177 | # sheet_write.write(rows, col, xlwt.Formula(link)) 178 | # except: 179 | # sheet_write.write(rows, col, data[col]) 180 | # sheet_write.write(rows, col + 1, data[col + 1]) 181 | # elif col == 2: 182 | # pass 183 | # else: 184 | sheet_write.write(rows, col, data[col]) 185 | # sheet_write.write(rows, i, data[i]) 186 | 187 | w_xls.save(filePath) 188 | 189 | 190 | if __name__ == "__main__": 191 | # excel_write('example.xls', '') 192 | # excel_read("example.xls") 193 | add_class() -------------------------------------------------------------------------------- /fileHandle.py: -------------------------------------------------------------------------------- 1 | #encoding=utf-8 2 | 3 | # 文件处理相关函数 4 | 5 | import os 6 | import sys 7 | reload(sys) 8 | sys.setdefaultencoding('utf8') 9 | import codecs 10 | 11 | # 获取指定文件数据 12 | def get_file_data(filename, path): 13 | try: 14 | # 进行文章的读取 15 | filePath = os.path.join(path, filename) 16 | fileObject = open(filePath, 'r+') 17 | fileData = fileObject.read() 18 | return fileData 19 | except: 20 | pass 21 | return '' 22 | finally: 23 | pass 24 | # fileObject.close() 25 | 26 | # 获取文件目录 27 | def get_file_list(path): 28 | filelist = [] 29 | files = os.listdir(path) 30 | for f in files: 31 | if (f[0] == '.'): 32 | pass 33 | else: 34 | # filelist.append(os.path.join(path, f)) 35 | filelist.append(f) 36 | return filelist 37 | 38 | # 获取文件指定行(第一行)(默认为当前路径下) 39 | def get_file_line_details(filename, path): 40 | if not path: 41 | path = get_cur_path() 42 | filePath = os.path.join(path, filename) 43 | file = codecs.open(filePath, 'r', 'utf-8') 44 | text = file.readline() 45 | return text 46 | 47 | # 获取文件第三行数据 48 | def get_file_third_line_details(filename, path): 49 | if not path: 50 | path = get_cur_path() 51 | filePath = os.path.join(path, filename) 52 | file = codecs.open(filePath, 'r', 'utf-8') 53 | count = 1 54 | while count < 6: 55 | text = file.readline() 56 | if count == 5: 57 | tag = text 58 | break 59 | count += 1 60 | return tag 61 | 62 | # 写文件操作(默认为追加) 63 | def write_file(filename, data, mode = 'a+'): 64 | curDir = get_cur_path() 65 | filePath = os.path.join(curDir, filename) 66 | fileObject = codecs.open(filePath, mode, 'utf-8') 67 | fileObject.write(str(data)) 68 | fileObject.write('\n\n') 69 | # fileObject.close() 70 | 71 | # 获取当前文件路径 72 | def get_cur_path(): 73 | # 获取脚本路径 74 | path = sys.path[0] 75 | # 判断为脚本文件还是py2exe编译后的文件，如果是脚本文件，则返回的是脚本的目录，如果是py2exe编译后的文件，则返回的是编译后的文件路径 76 | if os.path.isdir(path): 77 | return path 78 | elif os.path.isfile(path): 79 | return os.path.dirname(path) 80 | 81 | 82 | if __name__ == "__main__": 83 | pass 84 | curPath = get_cur_path() 85 | fileName = 'article.txt' 86 | fileData = get_file_data(fileName, curPath) 87 | print fileData -------------------------------------------------------------------------------- /main.py: -------------------------------------------------------------------------------- 1 | #encoding=utf-8 2 | 3 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 4 | from __future__ import unicode_literals 5 | import sys 6 | import json 7 | import os 8 | 9 | # 操作中文必须语句，解决字符问题 10 | reload(sys) 11 | sys.setdefaultencoding('utf8') 12 | 13 | import fileHandle 14 | import textPreprocessing 15 | import semanticsCount 16 | import statisticsCount 17 | 18 | 19 | def main(fileName, path): 20 | # 逻辑结构 21 | # 1、文本预处理(分词与词性标注、词语过滤、词语相关信息记录) 22 | print '------当前文本预处理操作------' 23 | wordsStatisticsData, wordsData = textPreprocessing.word_segmentation(fileName, path) 24 | # 2、词语语义贡献值计算(计算词语语义相似度、构建词语语义相思网络、计算词语居间度密度) 25 | print '------当前进行词语语义贡献值计算操作------' 26 | intermediaryDensity = semanticsCount.intermediaryDegreeDensity(fileName, path) 27 | # 3、计算词语统计特征值 28 | # keywordDatas = statisticsCount.tfidf() 29 | print '------当前进行词语统计特征值计算操作------' 30 | wordsStatisticsData = statisticsCount.wordsStatistics(wordsStatisticsData) 31 | print '------当前进行汇总计算操作------' 32 | # 4、计算词语关键度 33 | # 算法基础设定 34 | # 语义贡献值权重 35 | vdw = 0.6 36 | # 统计特征值权重 37 | tw = 0.4 38 | # 统计特征位置上权重 39 | locw1, locw2, locw3 = 0.5, 0.3, 0.3 40 | # 统计特征词长权重 41 | lenw = 0.01 42 | # 统计特征值中词性权重 43 | posw = 0.5 44 | # 统计特征中TF-IDF权重 45 | tfidfw = 0.8 46 | 47 | # 对收集到的词语进行重新遍历 48 | ske = {} 49 | for key in wordsStatisticsData.keys(): 50 | # 取语义贡献值(假如居间度密度集合中不存在,补充为0) 51 | if intermediaryDensity.get(key): 52 | vdi = intermediaryDensity.get(key) 53 | else: 54 | vdi = 0 55 | 56 | # 暂时未加tfidf权值 57 | score = vdw * vdi + tw * (locw1 * float(wordsStatisticsData[key][0]) + lenw * int(len(key)) + posw * float( 58 | wordsStatisticsData[key][1])) 59 | ske[key] = score 60 | 61 | ske = sorted(ske.iteritems(), key=lambda d: d[1], reverse=True) # 降序排列 62 | # print json.dumps(ske, ensure_ascii=False) 63 | return ske 64 | 65 | if __name__ == "__main__": 66 | pass 67 | # 进行关键词提取的文章 68 | curPath = fileHandle.get_cur_path() 69 | curPath = 'corpus' 70 | # fileName = '1351409.txt' # bug调试 71 | fileName = '1000005.txt' 72 | 73 | print json.dumps(main(fileName, curPath), ensure_ascii=False) 74 | 75 | -------------------------------------------------------------------------------- /semanticsCount.py: -------------------------------------------------------------------------------- 1 | #encoding=utf-8 2 | 3 | # 文本预处理 4 | # 分词与词性标注 5 | # 词语过滤 6 | # 词语相关信息记录 7 | 8 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 9 | from __future__ import unicode_literals 10 | # 除法运算 11 | from __future__ import division 12 | import os 13 | import json 14 | import sys 15 | # 操作中文必须语句，解决字符问题 16 | reload(sys) 17 | sys.setdefaultencoding('utf8') 18 | 19 | import fileHandle 20 | import textPreprocessing 21 | import dijkstra 22 | 23 | # 词语语义贡献值计算 24 | # 计算词语语义相似度 25 | # 构建词语语义相似度网络 26 | # 计算词语居间度密度 27 | 28 | 29 | # 《同义词词林》的读入 30 | # 返回格式{code: '文字字符串', } 31 | def cilin(): 32 | print '------当前进行《同义词词林》的读入操作------' 33 | cilinFilePath = 'dict_file/cilin.txt' 34 | cilinFileObject = open(cilinFilePath, 'r') # 进行分词文件的读取 35 | cilinDatas = {} 36 | for line in cilinFileObject: 37 | word = line.strip('\n') # 去除换行符 38 | cilinDatas[word[0:8]] = word[9:] 39 | return cilinDatas 40 | 41 | # 变量存储 42 | cilinCodeDatas = cilin() 43 | 44 | # 指定词语编码 45 | def wordEncoding(word ,data = cilinCodeDatas): 46 | print '------当前进行指定词语编码操作------' 47 | if data: 48 | cilinDatas = data 49 | else: 50 | cilinDatas = cilin() 51 | wordEncodingDatas = [] 52 | # 新词检测标记(新词为False,否则为True) 53 | flag = False 54 | wordNewEncodingDatas = [] 55 | for k, v in cilinDatas.iteritems(): 56 | # 此处对于《同义词词林》中不存在的单词进行了过滤 57 | # 对于自定义词库中的标签进行操作 58 | # 对于新词(存在于自定义标签库中)的处理：将所有编码均赋予它，这样其与其他单词的语义相似度均为1，不会影响其产生 59 | wordNewEncodingDatas.append(k) 60 | if str(word) in v: 61 | flag = True 62 | wordEncodingDatas.append(k) 63 | return wordEncodingDatas 64 | # if flag: 65 | # return wordEncodingDatas 66 | # else: 67 | # 对于是否存在于自定义标签库中，进行检测 68 | # userdictFilePath = 'dict_file/user_dict.txt' 69 | # userdictFileObject = open(userdictFilePath, 'r') # 进行分词文件的读取 70 | # 存在True，否则为False 71 | # tagFlag = False 72 | # for line in userdictFileObject: 73 | # data = line.strip('\n') # 去除换行符 74 | # if str(word) in data: 75 | # tagFlag = True 76 | # break 77 | # if tagFlag: 78 | # return wordNewEncodingDatas 79 | # else: 80 | # return wordEncodingDatas 81 | 82 | 83 | # 进行词语间语义相似度计算 84 | def wordSemanticSimilarity(word1, word2, wordsEncodingData): 85 | print '------当前进行词语间语义相似度计算操作------' 86 | # 获取单词的编码 87 | word1EncodingDatas = wordsEncodingData.get(word1) 88 | word2EncodingDatas = wordsEncodingData.get(word2) 89 | # 应对分词不存在于《同义词词林》中的情况 90 | if len(word1EncodingDatas) == 0 or len(word2EncodingDatas) == 0: 91 | return 0 92 | # 自定义初始距离值 93 | init_dis = 10 94 | # 权重数组 95 | weights = [1.0, 0.5, 0.25, 0.125, 0.06, 0.03] 96 | # 进行语义距离计算 97 | disData = [] 98 | for code1 in word1EncodingDatas: 99 | for code2 in word2EncodingDatas: 100 | if code1.find(code2) == 0 and code1[-1] == '#': 101 | tmpDis = weights[5] * init_dis 102 | elif code1.find(code2) == 0 and code1[-1] != '#': 103 | tmpDis = 0 104 | else: 105 | # 判断从第i层开始不同 106 | hierarchy = codeCmp(code1, code2) 107 | tmpDis = weights[hierarchy - 1] * init_dis 108 | disData.append(tmpDis) 109 | # 获取其中最小值 110 | disData.sort() 111 | # 计算语义相似度(参数a = 5) 112 | sim = 5 / (5 + disData[0]) 113 | return sim 114 | 115 | 116 | # 判断两个等长字符串从第几位开始不同，并按照编码规则输出对应的层级 117 | def codeCmp(code1, code2): 118 | if len(code1) != len(code2): 119 | raise Exception("Not the same length!") 120 | flag = 0 121 | for i in range(len(code1) + 1): 122 | if code1[0:i] != code2[0:i]: 123 | flag = i 124 | break 125 | flag += 1 126 | 127 | # 进行层级判断(按照哈工大扩展版编码规则表实现) 128 | if flag == 1 or flag == 2: 129 | hierarchy = flag 130 | if flag == 3 or flag == 4: 131 | hierarchy = 3 132 | if flag == 5: 133 | hierarchy = 4 134 | if flag == 6 or flag == 7: 135 | hierarchy = 5 136 | if flag == 8: 137 | hierarchy = 6 138 | if flag == 9: 139 | hierarchy = 0 140 | return hierarchy 141 | 142 | 143 | # 语义相似度网络 144 | # 返回形式{ 145 | # "词1": {"词2": "词1和词2的语义相似度", "词3": "词1和词3的语义相似度",...} 146 | # "词2": {"词1": "词2和词1的语义相似度", "词3": "词2和词3的语义相似度",...} 147 | # } 148 | def wordSemanticSimilarityGraph(fileName, path): 149 | print '------当前进行语义相似度网络构建操作------' 150 | # 图G的顶点集合 151 | wordsStatisticsData, wordsData = textPreprocessing.word_segmentation(fileName, path) 152 | # 词语编码的统计 153 | wordsEncodingData = {} 154 | for word in wordsData: 155 | code = wordEncoding(word) 156 | wordsEncodingData[word] = code 157 | # 语义相似度阈值 158 | b = 0.66 159 | graphDatas = {} 160 | for startWord in wordsData: 161 | graphData = {} 162 | for endWord in wordsData: 163 | # 若两个单词不同,则计算其语义相似度，大于指定阈值，则生成边 164 | if startWord != endWord: 165 | # 计算语义相似度 166 | sim = wordSemanticSimilarity(startWord, endWord, wordsEncodingData) 167 | if sim > b: 168 | graphData[endWord] = sim 169 | if graphData: 170 | graphDatas[startWord] = graphData 171 | return graphDatas 172 | 173 | 174 | # 居间度集合 175 | def intermediaryDegreeInterval(fileName, path): 176 | print '------当前进行词语居间度集合构建操作------' 177 | # 获取语义相似度网络图 178 | graphDatas = wordSemanticSimilarityGraph(fileName, path) 179 | 180 | # 获取最短路径数据集合 181 | shortestDatas = {} 182 | for key in graphDatas.keys(): 183 | shortestData = dijkstra.dijkstra(graphDatas, key) 184 | shortestDatas[key] = shortestData 185 | 186 | # 构建居间度集合 187 | interval = {} 188 | for key in graphDatas.keys(): 189 | score = intermediaryDegreeScore(key, shortestDatas) 190 | interval[key] = score 191 | 192 | return interval 193 | 194 | 195 | # 计算指定顶点的居间度 196 | # 传入参数：指定顶点，最短路径信息 197 | def intermediaryDegreeScore(word, shortestDatas): 198 | print '------当前进行指定顶点居间度计算操作------' 199 | Score = 0 200 | for m in shortestDatas.keys(): 201 | for k in shortestDatas.keys(): 202 | if m == k: 203 | pass 204 | else: 205 | # 计算两个顶点间的最短路径数(此处可能有歧义) 206 | try: 207 | path = shortestDatas[m][k]['path'] 208 | # 此处有两种处理逻辑，一种是利用距离，一种是利用路径数 209 | # 暂时使用路径数 210 | routes = path.split('->') # 至少为2 211 | routesNum = len(routes) 212 | distances = shortestDatas[m][k]['distance'] 213 | if word in path: 214 | # 使用路径数 215 | score = 1 / (routesNum - 1) 216 | # 使用路径距离 217 | # score = 1 / distances 218 | else: 219 | score = 0 220 | Score += score 221 | except: 222 | Score = 0 223 | return Score 224 | 225 | 226 | # 计算居间度密度 227 | def intermediaryDegreeDensity(fileName, path): 228 | print '------当前进行居间度密度集合构建操作------' 229 | # 顶点集合V对应的居间度集合bc 230 | interval = intermediaryDegreeInterval(fileName, path) 231 | 232 | # 顶点个数 233 | wordCount = len(interval) 234 | # 基础控制参数配置 235 | # bc的区间划分个数 236 | s = 10 237 | # 区间个数增长的速度参数 238 | c = 5 239 | # 区间密度阈值 240 | d = 0.8 241 | # 对bc进行重新划分的最大次数 242 | max = 6 243 | 244 | # 对字典按照键值进行排序(降序) 245 | sortedInterval = sorted(interval.iteritems(), key=lambda asd: asd[1], reverse=True) 246 | # 获取当前居间度密度最大值 247 | maxratio, intervalDensity = refinementBC(sortedInterval, s) 248 | 249 | # 设定循环次数 250 | loop = 1 251 | while maxratio >= d and loop < max: 252 | s = s * c 253 | maxratio, intervalDensity = refinementBC(sortedInterval, s) 254 | loop += 1 255 | 256 | # 根据获取到的居间度密度集合进行相应的单词的居间度密度集合更新 257 | 258 | # 居间度密度集合 259 | intermediaryDensity = {} 260 | for key in intervalDensity: 261 | wordData = intervalDensity[key] 262 | wordList = wordData.split(',') 263 | wordNum = len(wordList) 264 | for word in wordList: 265 | intermediaryDensity[word] = wordNum / wordCount 266 | 267 | return intermediaryDensity 268 | 269 | 270 | # 最优区间划分细度(降序排列的居间度集合) 271 | # 计算最大居间度密度 272 | # 参数:按居间度降序排列的居间度集合sortedInterval,区间划分个数s 273 | def refinementBC(sortedInterval, s): 274 | # 顶点个数 275 | wordCount = len(sortedInterval) 276 | # 居间度最大值&最小值 277 | maxIntermediaryDegree = sortedInterval[0][1] 278 | minIntermediaryDegree = sortedInterval[wordCount - 1][1] 279 | # print maxIntermediaryDegree, minIntermediaryDegree 280 | # 居间度划分区间长度 281 | intervalScore = (maxIntermediaryDegree - minIntermediaryDegree) / s 282 | 283 | # 居间度密度数组 284 | intervalDensity = {} 285 | 286 | tmpNode = minIntermediaryDegree 287 | # 按照居间度平均划分到不同的区间内，区间键为int，键值为单词(中间使用,连接) 288 | for key in sortedInterval: 289 | flag = int((key[1] - minIntermediaryDegree) / intervalScore) 290 | if intervalDensity.has_key(flag): 291 | intervalDensity[flag] = intervalDensity.get(flag) + ',' + key[0] 292 | else: 293 | intervalDensity[flag] = key[0] 294 | 295 | # 首次对区间度集合进行检测,输出当前最大的居间度密度作为比较 296 | maxratio = 0 297 | for key in intervalDensity: 298 | wordData = intervalDensity.get(key) 299 | wordList = wordData.split(',') 300 | wordNum = len(wordList) 301 | if maxratio < (wordNum / wordCount): 302 | maxratio = (wordNum / wordCount) 303 | return maxratio, intervalDensity 304 | 305 | 306 | 307 | if __name__ == "__main__": 308 | pass 309 | 310 | curPath = fileHandle.get_cur_path() 311 | fileName = 'article.txt' 312 | 313 | # 返回单词居间度密度集合 314 | intermediaryDensity = intermediaryDegreeDensity(fileName, curPath) 315 | print json.dumps(intermediaryDensity, ensure_ascii=False) 316 | 317 | -------------------------------------------------------------------------------- /src/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/helencoder/SKE/f534e11f6054a04310b1f532c653e33cadb3da03/src/__init__.py -------------------------------------------------------------------------------- /src/dir_handle.py: -------------------------------------------------------------------------------- 1 | # encoding=utf-8 2 | 3 | import os 4 | import sys 5 | 6 | #获取脚本文件的当前路径 7 | def cur_file_dir(): 8 | 9 | #获取脚本路径 10 | path = sys.path[0] 11 | #判断为脚本文件还是py2exe编译后的文件，如果是脚本文件，则返回的是脚本的目录，如果是py2exe编译后的文件，则返回的是编译后的文件路径 12 | if os.path.isdir(path): 13 | return path 14 | elif os.path.isfile(path): 15 | return os.path.dirname(path) -------------------------------------------------------------------------------- /src/excel_handle.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf8 -*- 2 | 3 | import os 4 | import sys 5 | reload(sys) 6 | sys.setdefaultencoding('utf-8') 7 | 8 | import xlrd 9 | import xlwt 10 | from datetime import datetime 11 | import xlutils 12 | from xlutils.copy import copy 13 | 14 | # excel数据写入 15 | # 输入数据默认为二维数组 16 | def excel_write(fileName, data, path = "./file"): 17 | 18 | # 定义单元格格式 19 | style0 = xlwt.easyxf('font: name Times New Roman, color-index red, bold on', num_format_str='#,##0.00') 20 | style1 = xlwt.easyxf(num_format_str='D-MMM-YY') 21 | 22 | # 创建工作表 23 | wb = xlwt.Workbook() 24 | # sheetObj = wb.add_sheet('Sheet1') 25 | sheetObj = wb.sheet_by_name('Sheet1') 26 | 27 | # 获取写入数据的行数 28 | rowNum = len(data) 29 | 30 | # 写入数据 31 | # 插入超链接 32 | # link = 'HYPERLINK("#%s";"%s")' % (str(i), str(i)) 33 | # sheet_index.write(line, 0, xlwt.Formula(link)) 34 | for row in range(rowNum): 35 | values = [] 36 | colNum = len(data[row]) 37 | for col in range(colNum): 38 | if col == 1: 39 | # 对文章标题插入超链接 40 | # link = 'HYPERLINK("#%s";"%s")' % (data[row][col], data[row][col + 1]) 41 | link = 'HYPERLINK("%s";"%s")' % (data[row][col + 1], data[row][col]) 42 | sheetObj.write(row, col, xlwt.Formula(link)) 43 | elif col == 2: 44 | pass 45 | else: 46 | sheetObj.write(row, col, data[row][col]) 47 | 48 | # 文件存储 49 | filePath = os.path.join(path, fileName) 50 | wb.save(filePath) 51 | 52 | # excel数据读取 53 | def excel_read(fileName, path = "./file"): 54 | filePath = os.path.join(path, fileName) 55 | wb = xlrd.open_workbook(filePath) 56 | # 获取工作簿的个数 57 | sheetNum = wb.nsheets 58 | # 获取所有工作薄的名称 59 | sheetName = wb.sheet_names() 60 | # 获取指定工作薄(索引) 61 | sheetObj = wb.sheet_by_index(0) 62 | # 获取指定工作薄(按名称) 63 | #sheetObj = wb.sheet_by_name('Sheet1') 64 | # 获取指定工作薄的行数 65 | rowNum = sheetObj.nrows 66 | # 获取指定工作薄的列数 67 | colNum = sheetObj.ncols 68 | 69 | # 指定数据输出 70 | # data = [] 71 | # for row in range(rowNum): 72 | # values = [] 73 | # for col in range(colNum): 74 | # values.append(str(sheetObj.cell(row, col).value)) 75 | # print ','.join(values) 76 | # data.append(values) 77 | # return data 78 | 79 | # 仅返回指定行数,对象 80 | w_xls = copy(wb) 81 | return rowNum, colNum, w_xls 82 | 83 | 84 | # excel数据追加 85 | # 输入数据默认为二维数组 86 | def excel_add(fileName, data, path = "./file"): 87 | 88 | # 获取当前文件已有的行数,对象 89 | curRowNum, curColNum, w_xls = excel_read(fileName, path) 90 | print curRowNum 91 | sheet_write = w_xls.get_sheet(0) 92 | sheet_write.write(curRowNum, curColNum, 'class') 93 | 94 | # 定义单元格格式 95 | style0 = xlwt.easyxf('font: name Times New Roman, color-index red, bold on', num_format_str='#,##0.00') 96 | style1 = xlwt.easyxf(num_format_str='D-MMM-YY') 97 | 98 | # 创建工作表 99 | wb = xlwt.Workbook() 100 | sheetObj = wb.add_sheet('Sheet1') 101 | 102 | # 获取写入数据的行数 103 | rowNum = len(data) 104 | 105 | 106 | # 写入数据 107 | # 插入超链接 108 | # link = 'HYPERLINK("#%s";"%s")' % (str(i), str(i)) 109 | # sheet_index.write(line, 0, xlwt.Formula(link)) 110 | for row in range(rowNum): 111 | values = [] 112 | colNum = len(data[row]) 113 | for col in range(colNum): 114 | if col == 1: 115 | # 对文章标题插入超链接 116 | # link = 'HYPERLINK("#%s";"%s")' % (data[row][col], data[row][col + 1]) 117 | try: 118 | link = 'HYPERLINK("%s";"%s")' % (data[row][col + 1], data[row][col]) 119 | sheetObj.add(curRowNum + row, col, xlwt.Formula(link)) 120 | except: 121 | sheetObj.write(curRowNum + row, col, data[row][col]) 122 | sheetObj.write(curRowNum + row, col + 1, data[row][col + 1]) 123 | elif col == 2: 124 | pass 125 | else: 126 | sheetObj.write(curRowNum + row, col, data[row][col]) 127 | 128 | # 文件存储 129 | filePath = os.path.join(path, fileName) 130 | wb.save(filePath) 131 | 132 | 133 | 134 | def add_class(): 135 | wbk = xlwt.Workbook() 136 | workbook = xlrd.open_workbook('tag_record.xls') #r_xls 137 | sheet1 = workbook.sheet_by_index(0) #r_sheet 138 | rows = sheet1.row_values(0) 139 | cols = sheet1.col_values(20) 140 | #print len(cols) 141 | print cols[1] 142 | print type(cols[1]) 143 | print type('聚类-1') 144 | #rows_num = sheet1.nrows #50054 145 | w_xls = copy(workbook) 146 | sheet_write = w_xls.get_sheet(0) 147 | sheet_write.write(0,21,'class') 148 | for i in range(1, len(cols)): 149 | if cols[i] == u'聚类-1': 150 | sheet_write.write(i,21,1) 151 | if cols[i] == u'聚类-2' or cols[i] == u'聚类-4' or cols[i] == u'聚类-6' or cols[i] == u'聚类-11': 152 | sheet_write.write(i,21,2) 153 | if cols[i] == u'聚类-3' or cols[i] == u'聚类-5': 154 | sheet_write.write(i,21,3) 155 | if cols[i] == u'聚类-8': 156 | sheet_write.write(i,21,4) 157 | if cols[i] == u'聚类-9' or cols[i] == u'聚类-10': 158 | sheet_write.write(i,21,5) 159 | w_xls.save('tag_record.xls') 160 | 161 | 162 | def write_append(fileName, data, path): 163 | 164 | filePath = os.path.join(path, fileName) 165 | r_xls = xlrd.open_workbook(filePath) 166 | r_sheet = r_xls.sheet_by_index(0) 167 | rows = r_sheet.nrows 168 | w_xls = copy(r_xls) 169 | sheet_write = w_xls.get_sheet(0) 170 | 171 | for col in range(0, len(data)): 172 | # if col == 1: 173 | # # 对文章标题插入超链接 174 | # # link = 'HYPERLINK("#%s";"%s")' % (data[row][col], data[row][col + 1]) 175 | # try: 176 | # link = 'HYPERLINK("%s";"%s")' % (data[col + 1], data[col]) 177 | # sheet_write.write(rows, col, xlwt.Formula(link)) 178 | # except: 179 | # sheet_write.write(rows, col, data[col]) 180 | # sheet_write.write(rows, col + 1, data[col + 1]) 181 | # elif col == 2: 182 | # pass 183 | # else: 184 | sheet_write.write(rows, col, data[col]) 185 | # sheet_write.write(rows, i, data[i]) 186 | 187 | w_xls.save(filePath) 188 | 189 | 190 | if __name__ == "__main__": 191 | # excel_write('example.xls', '') 192 | # excel_read("example.xls") 193 | add_class() -------------------------------------------------------------------------------- /src/file_handle.py: -------------------------------------------------------------------------------- 1 | # encoding=utf-8 2 | 3 | from __future__ import unicode_literals 4 | import os 5 | import sys 6 | reload(sys) 7 | sys.setdefaultencoding('utf8') 8 | import codecs 9 | 10 | # 定义储存文件类型 11 | type = { 12 | u"商业": "business", 13 | u"证券": "securities", 14 | u"金融": "finance", 15 | u"投资": "investment", 16 | } 17 | 18 | #获取脚本文件的当前路径 19 | def cur_file_dir(): 20 | #获取脚本路径 21 | path = sys.path[0] 22 | #判断为脚本文件还是py2exe编译后的文件，如果是脚本文件，则返回的是脚本的目录，如果是py2exe编译后的文件，则返回的是编译后的文件路径 23 | if os.path.isdir(path): 24 | return path 25 | elif os.path.isfile(path): 26 | return os.path.dirname(path) 27 | 28 | # 检测字符串中是否包含中文字符 29 | def check_contain_chinese(check_str): 30 | for ch in check_str.decode('utf-8'): 31 | if u"\u4e00" <= ch <= u"\u9fff": 32 | return True 33 | return False 34 | 35 | # 获取指定文件夹下所有文件 36 | # 默认处理当前文件夹相对路径 37 | def get_file_list(path): 38 | curDir = cur_file_dir() 39 | filePath = os.path.join(curDir, path) 40 | print filePath 41 | fileList = [] 42 | files = os.listdir(filePath) 43 | for file in files: 44 | #f = f.decode() 45 | if (file[0] == '.'): 46 | pass 47 | else: 48 | fileList.append(file) 49 | return fileList 50 | 51 | # 获取指定文件(默认为lib下的文件) 52 | 53 | # 获取自定义文件 54 | def get_lib_file(fileName, path = 'lib'): 55 | dir = os.path.dirname(os.path.realpath(__file__)) 56 | filePath = os.path.join(path, fileName) 57 | return os.path.join(dir, filePath) 58 | 59 | 60 | # 获取文件指定行(第一行) 61 | def get_file_line_details(filename): 62 | curDir = cur_file_dir() 63 | filePath = os.path.join(curDir, filename) 64 | file = codecs.open(filePath, 'r', 'utf-8') 65 | text = file.readline() 66 | return str(text).strip() 67 | 68 | # 写文件操作(默认为追加) 69 | def write_file(filename, data, mode = 'a+'): 70 | curDir = cur_file_dir() 71 | filePath = os.path.join(curDir, filename) 72 | fileObject = codecs.open(filePath, mode, 'utf-8') 73 | fileObject.write(str(data)) 74 | fileObject.write('\n\n') 75 | fileObject.close() 76 | 77 | # 写入excel文件操作 78 | def write_excel_file(): 79 | pass 80 | 81 | 82 | if __name__ == "__main__": 83 | # 文件测试 84 | path = 'index_file/article.txt' 85 | #path = './corpus' 86 | details = get_file_line_details(path) 87 | details = '《' + details + '》' 88 | print details 89 | 90 | recordFileName = 'record.txt' 91 | fileList = get_file_list('corpus') 92 | for file in fileList: 93 | filePath = 'corpus/' + file 94 | details = get_file_line_details(filePath) 95 | details = '《' + details + '》' 96 | write_file(recordFileName, details) 97 | print filePath 98 | 99 | # recordFileName = 'record.txt' 100 | # write_file(recordFileName, details) 101 | -------------------------------------------------------------------------------- /src/html_handle.py: -------------------------------------------------------------------------------- 1 | # encoding=utf-8 2 | 3 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 4 | from __future__ import unicode_literals 5 | import json 6 | import os 7 | import sys 8 | # 操作中文必须语句，解决字符问题 9 | reload(sys) 10 | sys.setdefaultencoding('utf8') 11 | 12 | from bs4 import BeautifulSoup 13 | 14 | # 定义储存文件类型 15 | file_type = { 16 | u"金融": "finance", 17 | u"理财": "financing", 18 | u"基金": "fund", 19 | u"私募": "private", 20 | u"股票": "shares", 21 | u"保险": "insurance", 22 | u"今日投资": "investment", 23 | } 24 | 25 | def get_article_data(html_data): 26 | # Beautiful Soup处理 27 | soup = BeautifulSoup(html_data, 'html.parser') 28 | 29 | # 获取类型数据 30 | type_datas = soup.find_all("div", class_="main-mate") 31 | if len(type_datas) > 0: 32 | type_data = type_datas[0] 33 | try: 34 | type = type_data.span.get_text() 35 | except: 36 | return '' 37 | else: 38 | return '' 39 | 40 | # 直接进行数据筛选 41 | # if file_type.get(type): 42 | # pass 43 | # else: 44 | # return '' 45 | 46 | # 获取标题、副标题数据 47 | title_datas = soup.find_all("div", class_="article-header") 48 | if len(title_datas) > 0: 49 | title_data = title_datas[0] 50 | title = title_data.h1.get_text() 51 | try: 52 | sub_title = title_data.p.get_text() 53 | except: 54 | sub_title = '' 55 | else: 56 | title = '' 57 | sub_title = '' 58 | 59 | # 获取文章日期数据 60 | date_datas = soup.find("p", class_="info-s") 61 | if len(date_datas) > 0: 62 | for child in date_datas: 63 | try: 64 | if child['class'][0] == "date": 65 | date = child.get_text() 66 | break 67 | else: 68 | date = '' 69 | except: 70 | date = '' 71 | 72 | # 获取标签数据 73 | tag_datas = soup.find_all("a", class_="tags") 74 | tag_data = [] 75 | for child in tag_datas: 76 | tag_data.append(child.get_text()) 77 | tags = ','.join(tag_data) 78 | 79 | # 获取正文数据 80 | content_datas = soup.find_all("div", class_="article-content") 81 | content_data = [] 82 | for child in content_datas: 83 | content_data.append(child.get_text()) 84 | # 去除原文链接相关(后续) 85 | # print content_data 86 | # try: 87 | # content_data.pop() 88 | # except: 89 | # pass 90 | content = ' '.join(content_data) 91 | 92 | return type, title, sub_title, date, tags, content -------------------------------------------------------------------------------- /src/scrapy_handle.py: -------------------------------------------------------------------------------- 1 | #coding=utf-8 2 | 3 | import urllib 4 | import requests 5 | 6 | def getHtml(url): 7 | page = urllib.urlopen(url) 8 | html = page.read() 9 | return html 10 | 11 | #处理文本获取() 12 | def get_html_data(url): 13 | # 进行文本抓取 14 | response = requests.get(url) 15 | if response.status_code != 200: 16 | return False 17 | else: 18 | return response.text 19 | 20 | # 此下面的语句被import引入后不会执行 21 | if __name__ == "__main__": 22 | url = '' 23 | getHtml(url) 24 | # get_html_data(url) -------------------------------------------------------------------------------- /src/seg_handle.py: -------------------------------------------------------------------------------- 1 | # encoding=utf-8 2 | 3 | import os 4 | import jieba 5 | jieba.load_userdict("./dict_file/dict.txt.big") 6 | import jieba.posseg as pseg 7 | import sys 8 | import operator 9 | import dir_handle 10 | 11 | reload(sys) 12 | sys.setdefaultencoding('utf8') 13 | 14 | # 词性过滤文件(保留形容词、副形词、名形词、成语、简称略语、习用语、动词、动语素、副动词、名动词、名词) 15 | ALLOW_SPEECH_TAGS = ['a', 'ad', 'an', 'i', 'j', 'l', 'v', 'vg', 'vd', 'vn', 'n'] 16 | 17 | # 读入文章，分词，写入文件 18 | # flag：True 表明此文件后续会继续被处理，所以只有分词 False，则可以美一点 19 | # 返回分词的数量 20 | def seg_file(originalFilePath, segFilePath, flag = True): 21 | try: 22 | # 进行文章的读取 23 | fileObject = open(originalFilePath, 'r+') 24 | fileData = fileObject.read() 25 | 26 | # 进行文章的分词操作 27 | psegList = pseg.cut(fileData) 28 | 29 | # 进行分词文件的创建 30 | segFileObject = open(segFilePath, 'w') 31 | # 进行分词数量的记录 32 | wordCount = 0 33 | 34 | # 进行分词文件的记录 35 | for line in psegList: 36 | if line.flag == 'x': 37 | pass 38 | else: 39 | wordCount += 1 40 | if flag: 41 | segFileObject.write(line.word) 42 | segFileObject.write('\n') # 显式写入换行 43 | else: 44 | segFileObject.write(str(wordCount)) 45 | segFileObject.write('\t') 46 | segFileObject.write(line.word) 47 | segFileObject.write('\t') 48 | segFileObject.write(line.flag) 49 | segFileObject.write('\n') # 显式写入换行 50 | 51 | return wordCount 52 | 53 | finally: 54 | fileObject.close() 55 | segFileObject.close() 56 | 57 | 58 | 59 | # 分词后文件记录 60 | # flag:True 降序输出 False 升序输出 61 | def record_file(segFilePath, recordFilePath, totalCount, flag = True): 62 | try: 63 | # 计算词频 64 | segFileObject = open(segFilePath, 'r') # 进行分词文件的读取 65 | wordDatas = {} 66 | for line in segFileObject: 67 | word = line.strip('\n') # 去除换行符 68 | if wordDatas.has_key(word): 69 | wordDatas[word] = (wordDatas.get(word) + 1) 70 | else: 71 | wordDatas[word] = 1 72 | if flag: 73 | sortedWordDatas = sorted(wordDatas.iteritems(), key=lambda d: d[1], reverse=True) # 降序排列 74 | else: 75 | sortedWordDatas = sorted(wordDatas.items(), key=operator.itemgetter(1)) # 升序排列 76 | 77 | # 进行记录文件的创建 78 | recordFileObject = open(recordFilePath, 'w') 79 | recordFileObject.write("当前文章分词后共有单词数量为： ") 80 | recordFileObject.write(str(totalCount)) 81 | recordFileObject.write('\n') 82 | for line in sortedWordDatas: 83 | recordFileObject.write(line[0]) 84 | recordFileObject.write('\t') 85 | recordFileObject.write(str(line[1])) 86 | recordFileObject.write('\n') # 显示写入换行 87 | 88 | finally: 89 | segFileObject.close() 90 | segFileObject.close() 91 | 92 | 93 | # 文件分词记录集中函数 94 | def seg_handle(originalFileName): 95 | curDir = dir_handle.cur_file_dir() 96 | originalFilePath = os.path.join(curDir, originalFileName) 97 | # 根据原始文章名称自动进行分词文件和记录文件的命名 98 | segFilePath = originalFilePath.strip('.txt') + '_seg.txt' 99 | print segFilePath 100 | recordFilePath = originalFilePath.strip('.txt') + '_record.txt' 101 | wordCount = seg_file(originalFilePath, segFilePath) 102 | record_file(segFilePath, recordFilePath, wordCount) 103 | 104 | 105 | # 直接进行数据的分词记录 106 | def seg_data(contentData): 107 | # 加载停用词文件 108 | # jieba.analyse.set_stop_words('dict_file/stop_words.txt') 109 | stopWords = [line.strip().decode('utf-8') for line in open('dict_file/stop_words.txt').readlines()] 110 | # 进行文章的分词操作 111 | psegList = pseg.cut(contentData) 112 | wordDatas = {} 113 | for word in psegList: 114 | # 添加关键词长度限制,大于1 115 | if word.flag in set(ALLOW_SPEECH_TAGS) and word.word not in stopWords and len(word.word) > 1: 116 | if wordDatas.has_key(word.word): 117 | wordDatas[word.word] = (wordDatas.get(word.word) + 1) 118 | else: 119 | wordDatas[word.word] = 1 120 | 121 | sortedWordDatas = sorted(wordDatas.iteritems(), key=lambda d: d[1], reverse=True) # 降序排列 122 | return sortedWordDatas 123 | # 进行记录文件的创建 124 | 125 | 126 | if __name__ == "__main__": 127 | 128 | # 文件测试 129 | originalFileName = 'index_file/gold.txt' 130 | # seg_handle(originalFileName) 131 | 132 | contentData = u"2012年冬，北京马可波罗酒店门口，两个年轻人正在等车。一辆出租车停在门口，司机探出头，“哪位约的车？”滴滴出行CEO程维摆摆手，得意的看向身旁的美团CEO王兴。就在刚刚结束的饭局上，程维向王兴展示自己的作品“嘀嘀打车”，不料王兴只看了一眼，一盆冷水浇下来，“这个产品注册流程设计的太垃圾，你看看现在的互联网产品，哪里还有需要注册的。”这件旧事，在四年后的乌镇世界互联网大会期间，被重提。王兴已经记忆模糊，“我不习惯用垃圾两个字，当时说用户体验有很多需要改进的地方。”程维笑笑，“其实我也觉得那个设计挺垃圾的。”中国互联网圈王兴对产品很有洞见，之后的故事也佐证了这一点。事后外界才得知，这款被王兴视为“垃圾”的产品，是外包公司找一位山东的中专老师带着学生鼓捣出来的。也正是这个产品让早期的滴滴一时间陷入僵局，直到原百度技术牛人张博加入，并用了近一年时间重新研发打磨产品。两位看似毫无交集的男主角在之后的4年多时间里，上演了两场颇为相似的商战大戏。地推巷战、融资阻击、资本寒冬……最终以合并的方式扫清战场，堪称中国O2O战场的经典战役。2016年将过，这一年里他们完成了跑马圈地的加速狂奔，O2O战局趋稳，行业巨头的头部效应正在显露。但是，战场没有中场休整，下半场已经如约而至。正如王兴引用钱穆的话，“过去未去，未来已来”。没错，移动互联网和互联网是交织在一起的。2017年，王兴和程维又将重新站上“下半场”起跑线。如果说BAT这些互联网前辈已经完成人和信息、信息和信息的连接，搭建起互联网的“水电煤”生态。王兴等互联网“少壮派”完成人与交通工具、人与吃喝玩乐的物理连接后，他们的眼光已经投向“下半场”——技术创业、产业融合和国际化。一场触达传统产业链的化学反应正在发生。大逃杀 2010年，王兴创立美团，并在三年间从“千团大战”“百团大战”中杀出重围，坐稳团购网站头把交椅，随后成长为一个吃喝玩乐一站式服务平台。2012年，程维告别供职八年的阿里巴巴创立滴滴，并用四年时间打造国内最大的出行平台。战事过半，王兴和程维都刚从一场腥风血雨中险胜。回忆起过去的疯狂扩张，王兴不后悔，“快是必要的，竞争在某些时刻是非常残酷的。一个很受触动的片段是，舒马赫和阿隆索在一次最后对决的时候，双方长期齐驱并驾。经过长时间的僵持后，最后阿隆索胜出了。事后别人问他为什么，他说大家都不松的话，可能车毁人亡，他有小孩，我没小孩，他应该会让我。”程维对此高度认同，“双方轮流竞价到一定阶段后，这是一种必然。如果你并不能够靠一直踩油门把对手踩死，也并非一定要车毁人亡才能结束战争，也许还有第三种解决方式。”" 133 | # 对文章进行词频统计和记录 134 | wordFrequency = seg_data(contentData) 135 | # print wordFrequency 136 | # 对数据进行组织 137 | frequencyDatas = '' 138 | wordCount = 0 139 | for data in wordFrequency: 140 | if wordCount > 10: 141 | break 142 | tmpData = data[0] + '/' + str(data[1]) + ' ' 143 | frequencyDatas += tmpData 144 | wordCount += 1 145 | 146 | print frequencyDatas -------------------------------------------------------------------------------- /statisticsCount.py: -------------------------------------------------------------------------------- 1 | #encoding=utf-8 2 | 3 | # 词语统计特征值计算 4 | 5 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 6 | from __future__ import unicode_literals 7 | import os 8 | import json 9 | import jieba 10 | import jieba.posseg as pseg 11 | import sys 12 | reload(sys) 13 | sys.setdefaultencoding('utf8') 14 | import string 15 | from sklearn import feature_extraction 16 | from sklearn.feature_extraction.text import TfidfTransformer 17 | from sklearn.feature_extraction.text import CountVectorizer 18 | 19 | import textPreprocessing 20 | import fileHandle 21 | 22 | # 词语词性值权重分配 23 | pos = { 24 | 'a': 0.5, 25 | 'ad': 0.3, 26 | 'an': 0.6, 27 | 'i': 0.6, 28 | 'j': 0.7, 29 | 'l': 0.6, 30 | 'v': 0.3, 31 | 'vg': 0.2, 32 | 'vd': 0.4, 33 | 'vn': 0.6, 34 | 'n': 0.8 35 | } 36 | 37 | # 依据指定词性对于词语进行重新记录 38 | # 返回数据格式: 39 | # {'word': {loc, pos}, ...} 40 | def wordsStatistics(wordsStatisticsData): 41 | print '------当前进行词语词性权重统计操作------' 42 | # 进行单词词性标注统计 43 | for key in wordsStatisticsData: 44 | wordsStatisticsData[key][1] = pos.get(wordsStatisticsData[key][1]) 45 | return wordsStatisticsData 46 | 47 | 48 | # 对语料库所有文章进行tfidf计算 49 | def tfidf(): 50 | print '------当前进行词语TF-IDF统计值计算操作------' 51 | fileList = getCorpusFilelist() 52 | for file in fileList: 53 | print "Using jieba on " + file 54 | segFile(file) 55 | segFileNameList = getCorpusFilelist('segFile') 56 | keywordDatas = Tfidf(segFileNameList) 57 | return keywordDatas 58 | 59 | 60 | # 获取指定语料库文件列表 61 | def getCorpusFilelist(path = 'corpus'): 62 | filelist = [] 63 | files = os.listdir(path) 64 | for f in files: 65 | if (f[0] == '.'): 66 | pass 67 | else: 68 | filelist.append(f) 69 | return filelist 70 | 71 | 72 | # 对文档进行分词处理 73 | def segFile(segFileName, recordPath = 'segFile', filePath = 'corpus'): 74 | # 保存分词结果的目录 75 | if not os.path.exists(recordPath): 76 | os.mkdir(recordPath) 77 | # 读取文档 78 | segFilePath = os.path.join(filePath, segFileName) 79 | fileObj = open(segFilePath, 'r+') 80 | fileData = fileObj.read() 81 | fileObj.close() 82 | 83 | # 对文档进行分词处理，采用默认模式 84 | segFileData = jieba.cut(fileData, cut_all=True) 85 | 86 | # 对空格，换行符进行处理 87 | result = [] 88 | for data in segFileData: 89 | data = ''.join(data.split()) 90 | if (data != '' and data != "\n" and data != "\n\n"): 91 | result.append(data) 92 | 93 | # 将分词后的结果用空格隔开，保存至本地。 94 | recordFileName = segFileName.strip('.txt') + '_seg.txt' 95 | recordFilePath = os.path.join(recordPath, recordFileName) 96 | f = open(recordFilePath, "w+") 97 | f.write(' '.join(result)) 98 | f.close() 99 | 100 | 101 | # 读取已分词好的文档，进行TF-IDF计算 102 | def Tfidf(segFileNameList, count = 10, segFilePath = 'segFile'): 103 | # 保留分词结果 104 | segDatas = {} 105 | keywordDatas = {} 106 | # 存取100份文档的分词结果 107 | corpus = [] 108 | for fileName in segFileNameList: 109 | filePath = os.path.join(segFilePath, fileName) 110 | fileObj = open(filePath, 'r+') 111 | content = fileObj.read() 112 | fileObj.close() 113 | corpus.append(content) 114 | segDatas[fileName] = content 115 | 116 | vectorizer = CountVectorizer() 117 | transformer = TfidfTransformer() 118 | tfidf = transformer.fit_transform(vectorizer.fit_transform(corpus)) 119 | 120 | word = vectorizer.get_feature_names() # 所有文本的关键字 121 | weight = tfidf.toarray() # 对应的tfidf矩阵 122 | 123 | tfidfPath = 'tfidfFile' 124 | if not os.path.exists(tfidfPath): 125 | os.mkdir(tfidfPath) 126 | 127 | # 这里将每份文档词语的TF-IDF写入tfidffile文件夹中保存 128 | # 打印每类文本的tf-idf词语权重，第一个for遍历所有文本，第二个for便利某一类文本下的词语权重 129 | for i in range(len(weight)): 130 | print u"--------Writing all the tf-idf in the", i, u" file into --------" 131 | tfidfFileName = segFileNameList[i][:-8] + '_tfidf.txt' 132 | # 暂不进行文件的写入，只进行关键值的记录 133 | # tfidfFilePath = os.path.join(tfidfPath, tfidfFileName) 134 | # f = open(tfidfFilePath, 'w+') 135 | wordDatas = {} 136 | for j in range(len(word)): 137 | # 进行排序输出 138 | wordDatas[word[j]] = weight[i][j] 139 | # f.write(word[j] + " " + str(weight[i][j]) + "\n") 140 | sortedWordDatas = sorted(wordDatas.iteritems(), key=lambda d: d[1], reverse=True) # 降序排列 141 | 142 | # 提取指定个数的关键词 143 | keywordData = [] 144 | flag = 0 145 | for line in sortedWordDatas: 146 | if flag < count: 147 | keywordData.append(line[0]) 148 | # 文件写入 149 | # f.write(line[0]) 150 | # f.write('\t') 151 | # f.write(str(line[1])) 152 | # f.write('\n') # 显示写入换行 153 | flag += 1 154 | keywordDatas[segFileNameList[i][:-8]] = keywordData 155 | # f.close() 156 | return sortedWordDatas 157 | 158 | 159 | if __name__ == "__main__": 160 | pass 161 | keywordDatas = tfidf() 162 | print keywordDatas 163 | -------------------------------------------------------------------------------- /test.py: -------------------------------------------------------------------------------- 1 | # encoding=utf-8 2 | 3 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 4 | from __future__ import unicode_literals 5 | import sys 6 | import json 7 | import os 8 | 9 | # 操作中文必须语句，解决字符问题 10 | reload(sys) 11 | sys.setdefaultencoding('utf8') 12 | 13 | import textRank 14 | import fileHandle 15 | import excel_handle 16 | 17 | def record(): 18 | pass 19 | 20 | # 此下面的语句被import引入后不会执行 21 | if __name__ == "__main__": 22 | print 'hello' 23 | path = 'corpus/' 24 | fileName = '1000001.txt' 25 | keywords, keypharses, abstract = textRank.details(fileName, path) 26 | # 获取标题 27 | title = fileHandle.get_file_line_details(fileName, path) 28 | # 获取文章链接 29 | tag = fileHandle.get_file_third_line_details(fileName, path) 30 | 31 | # 获取文件列表 32 | fileList = fileHandle.get_file_list(path); 33 | for file in fileList: 34 | # 获取标题 35 | title = fileHandle.get_file_line_details(file, path) 36 | # 获取标签 37 | tag = fileHandle.get_file_third_line_details(file, path) 38 | # 获取关键词和关键短语 39 | keywords, keypharses, abstract = textRank.details(file, path) 40 | # 获取文章链接 41 | flag = str(file).strip('.txt') 42 | baseurl = 'http://www.jiemian.com/article/%d.html' % (int(flag)) 43 | 44 | fileData = [] 45 | fileData.append(title) 46 | fileData.append(baseurl) 47 | fileData.append(tag) 48 | fileData.append(keypharses) 49 | fileData.append(keywords) 50 | # print type(title) 51 | # print type(baseurl) 52 | # print type(tag) 53 | # print type(keypharses) 54 | # print type(keywords) 55 | excel_handle.write_append('tag_record.xls', fileData, '.') 56 | 57 | print "当前处理文本为：", file 58 | 59 | 60 | # 获取文章链接 61 | # baseurl = 'http://www.jiemian.com/article/%d.html' % (123124) -------------------------------------------------------------------------------- /textPreprocessing.py: -------------------------------------------------------------------------------- 1 | #encoding=utf-8 2 | 3 | # 文本预处理 4 | # 分词与词性标注 5 | # 词语过滤 6 | # 词语相关信息记录 7 | 8 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 9 | from __future__ import unicode_literals 10 | import os 11 | import json 12 | import sys 13 | # 操作中文必须语句，解决字符问题 14 | reload(sys) 15 | sys.setdefaultencoding('utf8') 16 | 17 | import jieba 18 | import jieba.posseg as pseg 19 | 20 | # 加载分词字典 21 | jieba.set_dictionary("dict_file/dict.txt.big") 22 | # 加载用户自定义词典 23 | jieba.load_userdict("dict_file/user_dict.txt") 24 | 25 | # 加载自定义模块 26 | import fileHandle 27 | 28 | # 词性过滤文件(保留形容词、副形词、名形词、成语、简称略语、习用语、动词、动语素、副动词、名动词、名词) 29 | ALLOW_SPEECH_TAGS = ['a', 'ad', 'an', 'i', 'j', 'l', 'v', 'vg', 'vd', 'vn', 'n'] 30 | 31 | # 词语位置 32 | Word_Location = {'title': 1, 'section-start': 2, 'section-end':3, 'content': 4} 33 | 34 | # 分词&词性标注 35 | # 去除停用词 36 | # 保留指定词性词语 37 | def word_segmentation(fileName, path): 38 | print '------当前进行分词&词性标注&去重停用词&保留指定词性词语操作------' 39 | # 加载停用词文件 40 | # jieba.analyse.set_stop_words('dict_file/stop_words.txt') 41 | stopWords = [line.strip().decode('utf-8') for line in open('dict_file/stop_words.txt').readlines()] 42 | 43 | # 获取文件数据 44 | fileData = fileHandle.get_file_data(fileName, path) 45 | # jieba分词&词性标注 46 | psegDataList = pseg.cut(fileData) 47 | 48 | # 词语集合 49 | wordsData = [] 50 | # 词语统计数据 51 | wordsStatisticsData= {} 52 | # 获取文章的标题信息 53 | title = fileHandle.get_file_line_details(fileName, path) 54 | # 词性过滤&停用词过滤 55 | for data in psegDataList: 56 | # 添加单词长度限制(至少为2) 57 | if data.flag in set(ALLOW_SPEECH_TAGS) and data.word not in stopWords and len(data.word) > 1: 58 | wordsData.append(data.word) 59 | # 进行词语位置&词性记录（此处还需补充段首,段尾） 60 | if data.word in title: 61 | wordDetail = [1, str(data.flag)] 62 | else: 63 | wordDetail = [0, str(data.flag)] 64 | # print data.word, data.flag 65 | wordsStatisticsData[data.word] = wordDetail 66 | # 对词语集合进行去重 67 | wordsData = list(set(wordsData)) 68 | return wordsStatisticsData, wordsData 69 | 70 | if __name__ == "__main__": 71 | pass 72 | curPath = fileHandle.get_cur_path() 73 | fileName = 'article2.txt' 74 | wordsStatisticsData, wordsData = word_segmentation(fileName, curPath) 75 | 76 | # 进行词语位置的查找测试 77 | # print json.dumps(wordsStatisticsData, ensure_ascii=False) 78 | print json.dumps(wordsData, ensure_ascii=False) 79 | 80 | # # 词语位置和词语词性 81 | # data = {'我': [], '你': {}} -------------------------------------------------------------------------------- /textRank.py: -------------------------------------------------------------------------------- 1 | #-*- encoding:utf-8 -*- 2 | 3 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 4 | from __future__ import unicode_literals 5 | import json 6 | import os 7 | import sys 8 | try: 9 | reload(sys) 10 | sys.setdefaultencoding('utf-8') 11 | except: 12 | pass 13 | 14 | import codecs 15 | from textrank4zh import TextRank4Keyword, TextRank4Sentence 16 | 17 | def details(fileName, path): 18 | filePath = os.path.join(path, fileName) 19 | file = codecs.open(filePath, 'a+', 'utf-8') 20 | text = file.read() 21 | 22 | # 添加自定义文件 23 | # 结束词、词性、分词标记均可自己定义 24 | 25 | # 词性过滤文件(保留形容词、副形词、名形词、成语、简称略语、习用语、动词、动语素、副动词、名动词、名词) 26 | ALLOW_SPEECH_TAGS = ['a', 'ad', 'an', 'i', 'j', 'l', 'v', 'vg', 'vd', 'vn', 'n'] 27 | 28 | # 关键词处理 29 | tr4w = TextRank4Keyword(None, ALLOW_SPEECH_TAGS) 30 | tr4w.analyze(text=text, lower=True, window=2) # py2中text必须是utf8编码的str或者unicode对象，py3中必须是utf8编码的bytes或者str对象 31 | keyWords = [] 32 | keywords = '' 33 | for item in tr4w.get_keywords(10, word_min_len=2): 34 | keyWords.append(item.word) 35 | # 对返回的关键词进行处理，便于后续写入 36 | keywords = ('\\').join(keyWords) 37 | 38 | # 关键短语处理 39 | keyPhrases = [] 40 | keypharses = '' 41 | for phrase in tr4w.get_keyphrases(keywords_num=10, min_occur_num=2): 42 | keyPhrases.append(phrase) 43 | # 对返回的关键短语进行处理，便于后续写入 44 | keypharses = ('\\').join(keyPhrases) 45 | 46 | # 文本摘要处理 47 | tr4s = TextRank4Sentence() 48 | tr4s.analyze(text=text, lower=True, source='all_filters') 49 | 50 | # 文本摘要提取 51 | keySentences = {} 52 | keysentences = [] 53 | abstract = '' 54 | for item in tr4s.get_key_sentences(num=3): 55 | keySentences[item.index] = item.sentence 56 | 57 | # 摘要合成处理(需要引入去重处理) 58 | # sortedKeySentences = sorted(keySentences.iteritems(), key=lambda d: d[1], reverse=True) # 降序排列 59 | keySentences = sortedDictValues(keySentences) 60 | for item in keySentences: 61 | keysentences.append(item) 62 | # 去重操作 63 | duplicated_keysentences = duplication(keysentences) 64 | # 对返回的关键短语进行处理，便于后续写入 65 | abstract = (',').join(duplicated_keysentences) 66 | 67 | # 数据返回(元组形式) 68 | return keywords, keypharses, abstract 69 | 70 | # dict数据sort排序（key） 71 | def sortedDictValues(adict): 72 | keys = adict.keys() 73 | keys.sort() 74 | return map(adict.get, keys) 75 | 76 | # dict数据去重 77 | def duplication(list): 78 | length = len(list) 79 | if length >= 2 : 80 | pass 81 | else: 82 | return list 83 | 84 | # 进行查询标记收集，记录那些重复的字符串index 85 | index_flag = [] 86 | for i in range(len(list)): 87 | flag = list[i] 88 | for j in range(len(list)): 89 | if (i != j) and (flag.find(list[j]) >= 0): 90 | index_flag.append(j) 91 | 92 | # 先进行index_flag去重 93 | if(len(index_flag) > 0): 94 | duplicated_index_flag = sorted(set(index_flag), key=index_flag.index) 95 | if (len(duplicated_index_flag) == len(list)): 96 | return list[0] 97 | else: 98 | for x in duplicated_index_flag: 99 | try: 100 | del list[x] 101 | except: 102 | pass 103 | else: 104 | pass 105 | 106 | return list 107 | 108 | if __name__ == "__main__": 109 | pass 110 | 111 | path = '' 112 | fileName = 'article2.txt' 113 | keywords, keypharses, abstract = details(fileName, path) 114 | print keywords 115 | print keypharses 116 | # path = file_handle.get_lib_file('stopwords.txt') 117 | # print(path) 118 | 119 | -------------------------------------------------------------------------------- /tfidf.py: -------------------------------------------------------------------------------- 1 | # encoding=utf-8 2 | 3 | # 解决cmd命令行下输出中文字符乱码问题(必须放置在文本最前面) 4 | from __future__ import unicode_literals 5 | import os 6 | import json 7 | import jieba 8 | import jieba.posseg as pseg 9 | import sys 10 | reload(sys) 11 | sys.setdefaultencoding('utf8') 12 | import string 13 | from sklearn import feature_extraction 14 | from sklearn.feature_extraction.text import TfidfTransformer 15 | from sklearn.feature_extraction.text import CountVectorizer 16 | 17 | 18 | # 获取文件列表（该目录下放着100份文档） 19 | def getCorpusFilelist(path = 'corpus'): 20 | filelist = [] 21 | files = os.listdir(path) 22 | for f in files: 23 | if (f[0] == '.'): 24 | pass 25 | else: 26 | # filelist.append(os.path.join(path, f)) 27 | filelist.append(f) 28 | return filelist 29 | 30 | 31 | # 对文档进行分词处理 32 | def segFile(segFileName, recordPath = 'segFile', filePath = 'corpus'): 33 | # 保存分词结果的目录 34 | if not os.path.exists(recordPath): 35 | os.mkdir(recordPath) 36 | # 读取文档 37 | segFilePath = os.path.join(filePath, segFileName) 38 | fileObj = open(segFilePath, 'r+') 39 | fileData = fileObj.read() 40 | fileObj.close() 41 | 42 | # 对文档进行分词处理，采用默认模式 43 | segFileData = jieba.cut(fileData, cut_all=True) 44 | 45 | # 对空格，换行符进行处理 46 | result = [] 47 | for data in segFileData: 48 | data = ''.join(data.split()) 49 | if (data != '' and data != "\n" and data != "\n\n"): 50 | result.append(data) 51 | 52 | # 将分词后的结果用空格隔开，保存至本地。比如"我来到北京清华大学"，分词结果写入为："我 来到 北京 清华大学" 53 | #f = open(sFilePath + "/" + filename + "-seg.txt", "w+") 54 | recordFileName = segFileName.strip('.txt') + '_seg.txt' 55 | recordFilePath = os.path.join(recordPath, recordFileName) 56 | f = open(recordFilePath, "w+") 57 | f.write(' '.join(result)) 58 | f.close() 59 | 60 | 61 | # 读取100份已分词好的文档，进行TF-IDF计算 62 | def Tfidf(segFileNameList, count = 10, segFilePath = 'segFile'): 63 | # 保留分词结果 64 | segDatas = {} 65 | keywordDatas = {} 66 | # 存取100份文档的分词结果 67 | corpus = [] 68 | for fileName in segFileNameList: 69 | filePath = os.path.join(segFilePath, fileName) 70 | fileObj = open(filePath, 'r+') 71 | content = fileObj.read() 72 | fileObj.close() 73 | corpus.append(content) 74 | segDatas[fileName] = content 75 | 76 | vectorizer = CountVectorizer() 77 | transformer = TfidfTransformer() 78 | tfidf = transformer.fit_transform(vectorizer.fit_transform(corpus)) 79 | 80 | word = vectorizer.get_feature_names() # 所有文本的关键字 81 | weight = tfidf.toarray() # 对应的tfidf矩阵\ 82 | 83 | tfidfPath = 'tfidfFile' 84 | if not os.path.exists(tfidfPath): 85 | os.mkdir(tfidfPath) 86 | 87 | # 这里将每份文档词语的TF-IDF写入tfidffile文件夹中保存 88 | # 打印每类文本的tf-idf词语权重，第一个for遍历所有文本，第二个for便利某一类文本下的词语权重 89 | for i in range(len(weight)): 90 | print u"--------Writing all the tf-idf in the", i, u" file into --------" 91 | tfidfFileName = segFileNameList[i][:-8] + '_tfidf.txt' 92 | # 暂不进行文件的写入，只进行关键值的记录 93 | # tfidfFilePath = os.path.join(tfidfPath, tfidfFileName) 94 | # f = open(tfidfFilePath, 'w+') 95 | wordDatas = {} 96 | for j in range(len(word)): 97 | # 进行排序输出 98 | wordDatas[word[j]] = weight[i][j] 99 | # f.write(word[j] + " " + str(weight[i][j]) + "\n") 100 | sortedWordDatas = sorted(wordDatas.iteritems(), key=lambda d: d[1], reverse=True) # 降序排列 101 | 102 | # 提取指定个数的关键词 103 | keywordData = [] 104 | # 进行文件存储 105 | flag = 0 106 | for line in sortedWordDatas: 107 | if flag < count: 108 | keywordData.append(line[0]) 109 | # f.write(line[0]) 110 | # f.write('\t') 111 | # f.write(str(line[1])) 112 | # f.write('\n') # 显示写入换行 113 | flag += 1 114 | keywordDatas[segFileNameList[i][:-8]] = keywordData 115 | # f.close() 116 | return keywordDatas, segDatas 117 | 118 | if __name__ == "__main__": 119 | # (allfile, path) = getFilelist(sys.argv) 120 | # for ff in allfile: 121 | # print "Using jieba on " + ff 122 | # fenci(ff, path) 123 | # Tfidf(allfile) 124 | # fileList = getCorpusFilelist() 125 | # for file in fileList: 126 | # print "Using jieba on " + file 127 | # segFile(file) 128 | segFileNameList = getCorpusFilelist('segFile') 129 | keywordDatas, segDatas = Tfidf(segFileNameList) 130 | print keywordDatas 131 | print keywordDatas.get('financing_1224323') --------------------------------------------------------------------------------