本帖最后由 为人生而奋斗 于 2019-10-15 16:19 编辑
结巴分词在SEO中可以应用于分析/提取文章关键词、关键词归类、标题重写、文章伪原创等等方面，用处非常多。
具体结巴分词项目：https://github.com/fxsjy/jieba
安装方法：
以mac系统为例(因为自己用mac系统)：
在终端输入：
[Asm] 纯文本查看 复制代码pip3 install jieba -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
image.png (138.97 KB, 下载次数: 0)
2019-10-15 10:48 上传
这样就安装完成，然后就可以用coderunner软件开始写python3使用了
常用方法使用示例
1. 分词常用方法
jieba.cut 方法接受三个输入参数: 需要分词的字符串；cut_all 参数用来控制是否采用全模式；HMM 参数用来控制是否使用 HMM 模型
jieba.cut_for_search 方法接受两个参数：需要分词的字符串；是否使用 HMM 模型。该方法适合用 于搜索引擎构建倒排索引的分词，粒度比较细 待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意：不建议直接输入 GBK 字符串， 可能无法预料地错误解码成 UTF-8
jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器，可用于同时使用不同词典。 jieba.dt 为默认分词器，所有全局分词相关函数都是该分词器的映射。(一般使用默认的就可以了)
代码测试：
[Asm] 纯文本查看 复制代码#!/usr/bin/env python3# -*- coding: utf-8 -*-
import jieba
ret1 = jieba.cut('我来到北京清华大学', cut_all=True)
ret2 = jieba.cut('我来到北京清华大学', cut_all=False)
ret3 = jieba.cut_for_search('我来到北京清华大学')
print('/'.join(ret1))
print('/'.join(ret2))
print('/'.join(ret3))
image.png (402.44 KB, 下载次数: 0)
2019-10-15 10:50 上传
开始应用：
分类海量关键词(用于专题页、tag标签等)
假如我们用之前的关键词挖掘工具挖掘出了一堆关键词，看起来不仅杂乱无章，并且还要花大量的时间来进行过滤和归类。那么，就教大家用结巴分词来对关键词进行归类，几千个关键词1秒完成，几万关键词1分钟也能搞定。最后可以得到下图两种结果。这个可以用来干嘛呢？我们在做SEO的时候是不是可以根据分类将同一类的词做成专题页或者tag标签的聚合页？
第一种：json格式
第二种：Excel 格式
提取文章关键词
假如我们需要了解一篇文章内，关于该行业的关键词的表现如何(文章中包含了多少关键词，TF_IDF值是多 少，或者是TextRank的值是多少)等，我们都需要对文章进行分词处理，但是由于每个行业都有自己的专业 名词，所以仅仅使用python默认的词典的话那么就很难获取到准确的数据，数据得出来也不是我们想要的。 这个时候一般的做法就是添加自己的行业关键词字典，让结巴分词更准确。
主要步骤：
找到行业的相关关键词，保存到TXT文件里面
将所有的词都设置为相同的自定义词性，比如kws
在程序中导入自定义词典
使用TF-IDF算法提取文章的关键词，在词性过滤参数里面添加自定义词性，打印结果分析行业词的情 况。
该方法在实际用得比较少，主要就分析一下竞争对手内容中关键词的部署情况，实际的参考意义对于SEO来说 不是很大。
二、关键词归类|标题重写|文章伪原创
通过余弦相似度算法计算两个字符串之间的相关度，来对关键词进行归类、重写标题、文章伪原创等功能， 让你目瞪口呆。以下案例使用的母词文件均为txt文件，两种格式：一种内容是纯关键词的txt，每行一个关键词就好；另一种是关键词加指数的txt，关键词和指数之前用tab键分隔，一行一对关键词。
余弦相似度算法实现
[Asm] 纯文本查看 复制代码# -*- coding: utf-8 -*-from jieba import posseg
import math
import time
def simicos(str1, str2):
# 对两个要计算的字符串进行分词, 使用隐马尔科夫模型(也可不用)
# 由于不同的分词算法, 所以分出来的结果可能不一样
# 也会导致相似度会有所误差, 但是一般影响不大
cut_str1 = [w for w, t in posseg.lcut(str1) if 'n' in t or 'v' in t]
cut_str2 = [w for w, t in posseg.lcut(str2) if 'n' in t or 'v' in t]
# 列出所有词
all_words = set(cut_str1 + cut_str2)
# 计算词频
freq_str1 = [cut_str1.count(x) for x in all_words]
freq_str2 = [cut_str2.count(x) for x in all_words]
# 计算相似度
sum_all = sum(map(lambda z, y: z * y, freq_str1, freq_str2))
sqrt_str1 = math.sqrt(sum(x ** 2 for x in freq_str1))
sqrt_str2 = math.sqrt(sum(x ** 2 for x in freq_str2))
return sum_all / (sqrt_str1 * sqrt_str2)
if __name__ == '__main__':
case1 = "SEO"
case2 = "SEO培训网"
start = time.time()
similarity = simicos(case1, case2)
end = time.time()
print()
print("耗时: %.3fs" % (end - start))
print("相似度: %.3f" % similarity)
image.png (531.48 KB, 下载次数: 0)
2019-10-15 10:53 上传
结果：
[Asm] 纯文本查看 复制代码耗时: 0.751s相似度: 0.707
相似度在0.707，说明“SEO” 和“SEO培训网”这两个词相似度还是很高的。
2.关键词自动归类实现
实现思路：
将所有待分类的关键词放入到一个TXT文件中，程序将所有关键词读取到列表里面
将第一个词作为母词分别与其它词进行相似度计算，相似度大于0.3的就认为与该词同类。将对他 们放到一个新的列表中，并从原来的关键词列表中删除。
直到该词与列表中所有的词计算完毕，然后接着重复以上的操作，直到所有的词分类完毕。
算法缺陷：由于需要多次进行循环计算，因此时间复杂度比较高。不利于大批量的关键词快速归类, 而且如果关键词越驳杂，那么得到的分类就越多。
具体实现代码：
[Asm] 纯文本查看 复制代码# -*- coding: utf-8 -*-from jieba import posseg
import math
import json
import time
# 结果保存字典
result = {}
# Cache 缓存
cache = {}
def simicos(str1, str2):
"""
字符串余弦相似度算法实现, 添加缓存存储，减少分词带来的时间消耗
提高计算效率
:param str1: 要比较的字符串1
:param str2: 要比较的字符串2
:return: 相似度值0.0-1.0
"""
global cache
if cache.get(str1): # 或者用key in cache 方法也可以
cut_str1 = cache[str1]
else:
cut_str1 = [w for w, t in posseg.cut(str1) if 'n' in t or 'v' in t]
cache[str1] = cut_str1
if cache.get(str2):
cut_str2 = cache[str2]
else:
cut_str2 = [w for w, t in posseg.cut(str2) if 'n' in t or 'v' in t]
cache[str2] = cut_str2
all_words = set(cut_str1 + cut_str2)
freq_str1 = [cut_str1.count(x) for x in all_words]
freq_str2 = [cut_str2.count(x) for x in all_words]
sum_all = sum(map(lambda z, y: z * y, freq_str1, freq_str2))
sqrt_str1 = math.sqrt(sum(x ** 2 for x in freq_str1))
sqrt_str2 = math.sqrt(sum(x ** 2 for x in freq_str2))
try:
return sum_all / (sqrt_str1 * sqrt_str2)
except ZeroDivisionError:
return 0.0
def calculate(keyword_list):
"""
使用递归的方式进行计算和分类
优点：代码简单，容易理解
缺点：python默认最大的递归深度为1000，超过之后就会出错
:param keyword_list: 要分类的关键词列表
:return: None
"""
filter_word = []
# 获取第一个词作为母词
muci = keyword_list.pop(0)
# 用该词作为分类
result[muci] = []
print(len(keyword_list))
while keyword_list:
# 提取列表中的下一个词
kw = keyword_list.pop(0)
simi = simicos(muci, kw)
if simi >= 0.3:
result[muci].append(kw)
else:
filter_word.append(kw)
# 如果列表中还有词，就递归计算
if filter_word:
calculate(filter_word)
def classify(keyword_list):
"""
使用while循环的方法计算和分类
:param keyword_list: 要分类的关键词队列
:return: None
"""
muci = keyword_list.pop(0) # 第一个词
result[muci] = {"total": 0, "list": []}
last = keyword_list[-1] # 最后一个词
total_classify = 0
remain = len(keyword_list)
while keyword_list:
# 提取列表中的下一个词
kw = keyword_list.pop(0)
simi = simicos(muci, kw)
if simi >= 0.3:
result[muci]["list"].append(kw)
result[muci]["total"] += 1
remain -= 1
else:
keyword_list.append(kw)
if kw == last and keyword_list: # 如果已经是最后一个了
total_classify += 1
print("Has been classified %d, remain %d" % (total_classify, remain))
muci = keyword_list.pop(0)
remain -= 1
result[muci] = {"total": 0, "list": []}
if keyword_list:
last = keyword_list[-1]
else:
break
def result_filter(result_dict, bigthan=10):
"""
结果过滤筛选函数
由于使用该方法会等到很多的分类，有些分类是没有关键词的或者只有少数的相关词
那么对于这些分类就可能不需要了，我们就直接把他们过滤掉就好了
:param result_dict: 要筛选的分类结果
:param bigthan: 相关词数量大于等于该数的分类将保存
:return: 过滤后的结果
"""
retfilter = {}
for item, values in result_dict.items():
if values["total"] > bigthan:
retfilter[item] = values
return retfilter
if __name__ == "__main__":
t_start = time.time()
print("start....")
keywords = [key.strip() for key in open("baidumobilekey.txt", encoding='utf-8')]
classify(keywords)
filtered = result_filter(result)
# 结果保存在json中
f = open("result3.json", "w", encoding='utf-8')
f.write(json.dumps(filtered, ensure_ascii=False))
f.close()
print("done, consume %.3f" % (time.time() - t_start))
结果：
结果保存为json文件
因为上面的算法都是通过纯python写的，因此算法的速度是比较慢的，经测试，几万的关键词可能都需要十几分 钟，因此的话不适宜用来分类大量的关键词，同时如果要求的相似度越高，那么得出来的分类就越多。因此也不是 很好的一种解决办法。
还有一种就是使用编辑距离的算法，这个算法有别人用c语言写好的，而且不用分词，因此速度上比上面的算法会快很多，但是分类效果没那么好。一些不相关的词也可能会被分类到同一个分类下。
使用Levenshtein模块分类
代码实现： 需要安装Levenshtein模块，安装方法 pip install python-Levenshtein
[Asm] 纯文本查看 复制代码# -*- coding: utf-8 -*-import json
import time
import Levenshtein
result = {}
def classify(keyword_list):
"""
使用while循环的方法计算和分类
:param keyword_list: 要分类的关键词队列
:return: None
"""
muci = keyword_list.pop(0) # 第一个词
result[muci] = {"total": 0, "list": []}
last = keyword_list[-1] # 最后一个词
total_classify = 0
remain = len(keyword_list)
while keyword_list:
# 提取列表中的下一个词
kw = keyword_list.pop(0)
simi = Levenshtein.jaro_winkler(kw, muci)
if simi >= 0.8:
result[muci]["list"].append(kw)
result[muci]["total"] += 1
remain -= 1
else:
keyword_list.append(kw)
if kw == last and keyword_list: # 如果已经是最后一个了
total_classify += 1
print("Has been classified %d, remain %d" % (total_classify, remain))
muci = keyword_list.pop(0)
remain -= 1
result[muci] = {"total": 0, "list": []}
if keyword_list:
last = keyword_list[-1]
else:
break
def result_filter(result_dict, bigthan=10):
"""
结果过滤筛选函数
由于使用该方法会等到很多的分类，有些分类是没有关键词的或者只有少数的相关词
那么对于这些分类就可能不需要了，我们就直接把他们过滤掉就好了
:param result_dict: 要筛选的分类结果
:param bigthan: 相关词数量大于等于该数的分类将保存
:return: 过滤后的结果
"""
retfilter = {}
for item, values in result_dict.items():
if values["total"] > bigthan:
retfilter[item] = values
return retfilter
if __name__ == "__main__":
t_start = time.time()
print("start....")
keywords = [key.strip() for key in open("baidumobilekey.txt", encoding='utf-8')]
# keywords = [key.strip() for key in open("004.txt", encoding='utf-8')]
# calculate(keywords)
classify(keywords)
filtered = result_filter(result)
# 结果保存在json中
f = open("result4.json", "w", encoding='utf-8')
f.write(json.dumps(filtered, ensure_ascii=False))
f.close()
print("done, consume %.3f" % (time.time() - t_start))
得到的结果也是一个json文件。
结巴分词关键词分类
以上的算法速度是快了，但是的话效果也不是很好，而且分类也比较多。
这里还有一种比较折中的办法，那就是通过结巴将所有的关键词进行分词，然后根据TF-IDF算法，提取出里面前N 个名词或动词作为分类。然后根据包含的方式将所有的关键词归类。
该方法可以快速的将大量的关键词归类，但是会有一部分的关键词是获取不到归类的。至于选择哪种方式，由自己决定。
具体代码：
[Asm] 纯文本查看 复制代码# -*- coding: utf-8 -*-"""
python结巴关键词分类脚本，算法二
1. 通过TF_IDF算法提取出前N个词性的词作为分类
2. 遍历整个关键词列表，假如关键词中包含分类名，则将词放入到分类中
3. 如果都没有，则将词放入到其它分类
"""
import codecs
import csv
import time
from jieba import analyse
result = {}
def init(group):
for g in group:
result[g] = {"total": 0, "keys": []}
result["其它"] = {"total": 0, "keys": []}
def classsify(kw_list, group):
index = 0
total = len(kw_list)
while index < total:
flag = 0
for g in group:
if g in kw_list[index][0]:
flag = 1
result[g]["total"] += int(keyword_list[index][1])
result[g]["keys"].append(kw_list[index])
if not flag:
result["其它"]["total"] += int(keyword_list[index][1])
result["其它"]["keys"].append(kw_list[index])
index += 1
def write_to_file(group):
savefile = open("result.csv", "w", encoding='utf-8')
csvwriter = csv.writer(savefile)
fields = []
group.append("其它")
for g in group:
fields.append(g)
fields.append(result[g]["total"])
csvwriter.writerow(fields)
maxline = max(len(item["keys"]) for item in result.values())
cols = len(fields)
for row in range(maxline):
rowfield = ["" for _ in range(cols)]
gix = 0
kwitem = []
for col in range(cols):
if result.get(group[gix])["keys"]:
if col % 2 == 0:
kwitem = result.get(group[gix])["keys"].pop(0)
rowfield[col] = kwitem[0]
if col % 2 == 1:
gix += 1
rowfield[col] = kwitem[1]
csvwriter.writerow(rowfield)
savefile.close()
if __name__ == "__main__":
print("start.....")
t_start = time.time()
keyword_list = [k.strip().split('\t') for k in open("003.txt", encoding='utf-8')]
groups = analyse.extract_tags(" ".join(item[0] for item in keyword_list),
topK=20, allowPOS=('ns', 'n', 'vn', 'v', 'nr'))
groups = [g for g in groups]
init(groups)
classsify(keyword_list, groups)
write_to_file(groups)
print("done, consume %.3f" % (time.time() - t_start))
结果：每一列为一个类别，例如第一列是“考研”这个类别的所有词语分类。
结果存为Excel 格式
4526
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
