构建围绕新华字典展开的汉字网络

一. 问题假设

我们开始学习汉字之初，都是学习的“一”，“二”，“大”，“小”等字，为什么我们会挑选这些字来作为学习汉字的呢？因为这些字都长得比较简单，正规一点讲，也就是这些字的字形比较简单。这好像已经普遍成为了人们对学习汉字的一种认知：从字形简单的字开始学，然后由易到难。

然而，为什么我们不换个角度去思考，我们能否按照字义的复杂度由易到难去学习汉字呢？

对于刚开始接触汉字的小孩子来说，如果让他学习一些汉字，当他理解了这些汉字的意思之后，又能去利用已经学到的汉字去解释未学习过的汉字，这样不就可以让孩子围绕一些核心的汉字然后一直去探索未知到汉字，直到掌握所有的汉字吗？

二. 思路实现

如果要实现用字义由易到难去学习汉字，我们其实应该能想到将这些字构成一个相互之间有关联的网络，我们很自然地想到图论，将每一个字作为一个结点放在图中。然后字与字之间用单向边连接起来。
那么我们最开始应该先去学习哪些字呢？我们称这些最开始学习的字为核心汉字，核心汉字应该满足以下几点要求：

1）既然是最开始学习的汉字，其本身的字义应该简单。
2）既然能这些核心汉字能够较好地解释其他的字，那么这些字应该很频繁地存在于外面的字地解释中，而不会被很多外面的字解释。
3）这些字在整个新华字典中的解释中出现的频率，也就是字频应该是比较高的一些字。

如果用某个汉字作为结点，它指向每一个它的解释中的字（用邻接链表储存），第一点的实现方法就是看这个字的解释长度，第二点的实现方法就是看这个字的出度和入度之比要尽可能地大，第三点的实现方法就是统计字频咯。

然后我们分别赋给这三项一定的权重，计算出总的权重，排序比较，根据权重大小来选择出一定量核心汉字。

这些核心汉字作为一个集合，集合外的数也就是他们需要去解释的字。

所以我们的初步学习的就是这写核心汉字。

当我们学习完了核心汉字之后呢？

那就需要去探索学习路径了，所以我们可以用字典将集合内的核心汉字指向集合外的每一个它们能够解释的字，统计集合外的字的入度，入度越大则肯定越容易被核心汉字解释，得到了入度之后，就将集合内的字指向集合外的入度相对大的并且是它可以解释一些字。然后再把图转换成一个字典，用一个字典存储图中字和它可以解释的字。

写一个广度优先搜索，这样就可以搜索出合适的学习路径。

学习路径可以自己定义字的起点和路径长度。

三. 代码实现

新华字典的json格式文件可以在github上面去下载。

先将json格式的新华字典转化成python对象，然后提取出需要的对象。

# 引入json包
import json
# 这是json文件存放的位置
from collections import Counter, namedtuple, dequejson_filename = 'E:/github/Xinhuazidian/chinese-xinhua/Xinhua/word.json'
# 这是保存txt文件的位置
txt_filename = 'E:/github/Xinhuazidian/chinese-xinhua/Xinhua/word.txt'# 将文件截断为零长度或创建文本文件进行写入，流位于文件的开头
file = open(txt_filename, 'w')# 创建一个字典
dict = {}# 创建一个专门存储解释的列表
explain_list = []# 用一个列表存储所有的字
words = []# 用一个字典记录完整的字和其对应的意思
dict_complete = {}# 用一个字典记录字和其对应的拼音
dict_pinyin = {}# 将json文件打开  称为f
with open(json_filename, 'rb') as f:# 将f转化为Python对象pop_data = json.load(f)# 循环  提取出pop_data文件中的数据for pop_dict in pop_data:# 每一次循环的赋值  根据键获得值word = pop_dict['word']# 加到words列表中words.append(word)# 提取出字对饮的拼音pinyin = pop_dict['pinyin']# 将拼音加入到对应的字典中dict_pinyin[str(word)] = str(pinyin)# 提取出字的对应解释explanation = pop_dict['explanation']# 将字和对应解释按照对应关系写入文件temp = str(word) + ": "# 用列表记录解释中的每一个字 方便于字典的建立temp1 = []# 建立完整的字典dict_complete[str(word)] = str(explanation)# 将汉字提取出来for ch in explanation:# 通过正则表达式判断是否是中文汉字且必须与键不重复if u'\u4e00' <= ch <= u'\u9fff' and str(ch) != str(word):temp +=str(ch)temp1.append(ch)else:continue# 加上换行符temp += "\n\n"# 将字和对应的解释加入到字典中dict[word] = temp1# 将temp变量存入文件之中file.write(temp + '\n\n\n')# 写入列表explain_list.append(temp1)# 循环结束关闭文件file.close()

然后构建一个节点类和图类，构成一个邻接链表用来储存结点以及结点与结点之间的关系。

# 构建表的结点 Vertex代表一个结点
class Vertex(object):# 初始化顶点def __init__(self, key):#初始化顶点的键self.id = key#初始化顶点的值self.connectedTo = {}# 添加邻顶点，参数key是邻顶点的键，默认权重为0def addNeighbor(self, key, weight=0):self.connectedTo[key] = weight# 重写print函数打印出来的内容  打印每一个结点 及其所连接的全部结点def __str__(self):return str(self.id) + ' connectedTo: ' + str([x.id for x in self.connectedTo])# 获取该顶点的键所对应的值  也就是所有邻结点的键def getConnections(self):return self.connectedTo.keys()# 获取顶点的键def getId(self):return self.id# 获取到某邻结点的权重def getWeight(self, nbr):return self.connectedTo[nbr]# 结点构建好了之后开始   构建图中的一个表示方法: 邻接表
class Graph(object):# 初始化图def __init__(self):# 初始化邻接表self.vertList = {}# 初始化顶点数self.numVertices = 0# 添加结点def addVertex(self, key):# 新建一个结点newVertex = Vertex(key)# 将新顶点添加到邻接表中self.vertList[key] = newVertex# 邻接表中顶点数+1self.numVertices += 1# 返回该顶点return newVertex# 获取顶点def getVertex(self, n):# 若待查询结点在邻接表中，则返回该顶点if n in self.vertList:return self.vertList[n]# 否则返回空else:return None# Python3中字典用def __contains__(self, n)取代了has_key:# 在其中就返回True 不在就返回False# 重写in方法  in 和 not in操作的时候会自动调用这个函数def __contains__(self, n):return n in self.vertList# 添加边，参数f为起始顶点，t为目标顶点，weight两点之间边上的权重def addEdge(self, begin, target, weight=0):# 起始顶点不在邻接表中if begin not in self.vertList:#添加起始顶点self.addVertex(begin)# 目标顶点不在邻接表中if target not in self.vertList:# 添加目标顶点self.addVertex(target)# 在邻接表中添加起始点的目标点及权重self.vertList[begin].addNeighbor(self.vertList[target], weight)# 获取邻接表中所有顶点的键def getVertices(self):return self.vertList.keys()# __iter__(self)迭代器 迭代显示邻接表的每个顶点的邻结点def __iter__(self):return iter(self.vertList.values())# 实例化图类
graph = Graph()# 给邻接表添加边及权重
# 第一层循环  循环每个汉字
for ch in dict.keys():# 第二层循环 循环每个汉字对应的解释中的每一个字for ch1 in dict[ch]:# 暂时不设置权值  只添加边  构建一个网络graph.addEdge(ch, ch1)

统计每个字的入度和出度，用来作为是否是核心汉字的评判标准

# 统计每一个字的出度和入度
dict_out = {}
dict_in = {}# 循环每个顶点
for g in graph:# 循环每个顶点的所有邻居节点for w in g.getConnections():# 打印顶点和其邻居节点的键# print("(%s, %s)" % (g.getId(), w.getId()))# 将每个字的出度记录下来if g.getId() in dict_in:dict_in[g.getId()] += 1else:dict_in[g.getId()] = 1# 将每个字的入度记录下来if w.getId() in dict_out:dict_out[w.getId()] += 1else:dict_out[w.getId()] = 1# 计算出出度和入读之比
dict_out_in = {}# 第一层循环  循环每个汉字
for ch in dict.keys():# 判断一下是否存在if ch in dict_in and ch in dict_out:# 开始计算出出度和入度之比dict_out_in[ch] = dict_out[ch]/dict_in[ch]else:continue

统计字频

# 记录每一个字的列表
word_lst = []
# 记录每一个字和字频的字典
word_dict = {}# 需要去除的标点符号
exclude_str = "，。！？、（）()【】<>《》=：+:-*—“”…"# 打开文件和存入文件
with open("E:/github/Xinhuazidian/chinese-xinhua/Xinhua/word.txt", "r") as fileIn, open("E:/github/Xinhuazidian/chinese-xinhua/Xinhua/dictfrequency.txt", 'w') as fileOut:# 遍历txt文件的每一行for line in fileIn:# 遍历每一行的每一个字for char in line:# 去掉：# if(char != ":"):# 将字添加到存储字的列表中word_lst.append(char)# 用字典统计每个字出现的个数for char in word_lst:# 去掉标点符号字符if char not in exclude_str:# strip去除各种空白  char.strip()去除字符串首位的空格if char.strip() not in word_dict:# 第一次出现就将字频赋值为1word_dict[char] = 1else:# 每出现一次将字频加1word_dict[char] += 1

统计每个字的解释的长度

# 统计字义的长度的字典
exp_length = {}
# 统计字频的字典
word_fre = {}# 第一层循环  循环每个汉字
for ch in dict.keys():# 记录字意的复杂度exp_length[ch] = len(dict[ch])# 加上一个判断条件if ch in word_dict:# 统计字频word_fre[ch] = word_dict[ch]

计算每个字最终的权重

# 现在  每个字的  出度比入度  字频  和  字意长度  都有了
# 分配权重  也就是字义复杂度
dict_power = {}# 定义三个常量
out_in = 100.0
fre = 10.0
length = 10.0# 第一层循环  循环每个汉字
for ch in dict.keys():# 给定判断条件if ch in dict_out_in and ch in word_fre and ch in exp_length:# 计算权重dict_power[ch] = dict_out_in[ch] * out_in + word_fre[ch] * fre + exp_length[ch] * length# 返回一个列表，按照dict的value从大到小排序
dict_power = Counter(dict_power).most_common()

区分集合内和集合外的字

# 建立两个集合 分别存储集合内和集合外的字
set_in = []
set_out = []for temp in dict_power[:300]:set_in.append(temp[0])for temp in dict_power[200:]:set_out.append(temp[0])# 首先学习两百个核心的字
print("首先学习最核心的三百个字: ")
for ch in set_in:# 打印出字和其对应的解释print(ch, dict_pinyin[ch])

构建这个汉字之间的网络：

# 新建一个图
graph1 = Graph()# 用一个字典记录集合外的字的出度
dict_set_out = {}# 初始化字典
for ch in set_out:dict_set_out[ch] = 0# 遍历集合内的字
for ch in set_in:# 遍历集合外的字for ch1 in set_out:# 如果集合外的字是集合内的字的解释if ch1 in dict[ch]:# 记录集合外的字的入度dict_set_out[ch1] += 1# 遍历集合外的字
for ch in set_in:# 遍历集合外的字for ch1 in set_out:# 如果两个字不同且一个字在另外一个字的解释中if ch != ch1 and ch1 in dict[ch] and dict_set_out[ch1] >= 15:# 也增加一条单向边graph1.addEdge(ch, ch1)# 最终的存储字典
dict_final = {}# 遍历该图  然后将字典所有的键确定
for g in graph1:dict_final[g.getId()] = []# 循环每个顶点
for g in graph1:# 循环每个顶点的所有邻居节点for w in g.getConnections():# 打印顶点和其邻居节点的键# print("(%s, %s)" % (g.getId(), w.getId()))dict_final[g.getId()].append(w.getId())# 至此 整个汉字网络构建完成
print(dict_final)

BFS：

# 开始节点  目标节点 图字典
def bfs(start_node, num, graph):# 使用namedtuple定义节点，用于存储前置节点 node是结点 name, from node 为它的来源的结点的名字node = namedtuple('node', 'name, from_node')# 使用双端队列，这里当作队列使用，根据先进先出获取下一个遍历的节点search_queue = deque()# 存储队列中已有的节点名称name_search = deque()# 存储已经访问过的节点visited = {}# 填入初始节点，从队列后面加入search_queue.append(node(start_node, None))# 填入初始节点名称name_search.append(start_node)# 用户回溯路径path = []# 打印标记print('开始搜索...')# 只要搜索队列中有数据就一直遍历下去while search_queue:if len(visited) >= num:break# 打印标记print('待遍历节点: ', name_search)# 从队列前边获取节点，即先进先出，这是BFS的核心current_node = search_queue.popleft()# 将名称也相应弹出name_search.popleft()# 当前节点是否被访问过if current_node.name not in visited:# 打印标记print('当前节点: ', current_node.name, end=' | ')# 如果没有找到目标节点，将节点设为已访问，并将相邻节点加入搜索队列，继续找下去visited[current_node.name] = current_node# 遍历相邻节点，判断相邻节点是否已经在搜索队列for node_name in graph[current_node.name]:# 如果相邻节点不在搜索队列则进行添加if node_name not in name_search and node_name in words:search_queue.append(node(node_name, current_node.name))name_search.append(node_name)print("推荐路径结束")last = []for key in visited:last.append(key[0])# 打印搜索结果print('学习路径为:', last)print('\n\n')输入条件，开始推荐路径：
starting_point = input("请输入学习起点: ")learning_length = int(input("请输入大概的学习长度: "))# 执行搜索
bfs(starting_point, learning_length, dict_final)

下面贴上完整代码：

# 引入json包
import json
# 这是json文件存放的位置
from collections import Counter, namedtuple, dequejson_filename = 'E:/github/Xinhuazidian/chinese-xinhua/Xinhua/word.json'
# 这是保存txt文件的位置
txt_filename = 'E:/github/Xinhuazidian/chinese-xinhua/Xinhua/word.txt'# 将文件截断为零长度或创建文本文件进行写入，流位于文件的开头
file = open(txt_filename, 'w')# 创建一个字典
dict = {}# 创建一个专门存储解释的列表
explain_list = []# 用一个列表存储所有的字
words = []# 用一个字典记录完整的字和其对应的意思
dict_complete = {}# 用一个字典记录字和其对应的拼音
dict_pinyin = {}# 将json文件打开  称为f
with open(json_filename, 'rb') as f:# 将f转化为Python对象pop_data = json.load(f)# 循环  提取出pop_data文件中的数据for pop_dict in pop_data:# 每一次循环的赋值  根据键获得值word = pop_dict['word']# 加到words列表中words.append(word)# 提取出字对饮的拼音pinyin = pop_dict['pinyin']# 将拼音加入到对应的字典中dict_pinyin[str(word)] = str(pinyin)# 提取出字的对应解释explanation = pop_dict['explanation']# 将字和对应解释按照对应关系写入文件temp = str(word) + ": "# 用列表记录解释中的每一个字 方便于字典的建立temp1 = []# 建立完整的字典dict_complete[str(word)] = str(explanation)# 将汉字提取出来for ch in explanation:# 通过正则表达式判断是否是中文汉字且必须与键不重复if u'\u4e00' <= ch <= u'\u9fff' and str(ch) != str(word):temp +=str(ch)temp1.append(ch)else:continue# 加上换行符temp += "\n\n"# 将字和对应的解释加入到字典中dict[word] = temp1# 将temp变量存入文件之中file.write(temp + '\n\n\n')# 写入列表explain_list.append(temp1)# 循环结束关闭文件file.close()# 构建表的结点 Vertex代表一个结点
class Vertex(object):# 初始化顶点def __init__(self, key):#初始化顶点的键self.id = key#初始化顶点的值self.connectedTo = {}# 添加邻顶点，参数key是邻顶点的键，默认权重为0def addNeighbor(self, key, weight=0):self.connectedTo[key] = weight# 重写print函数打印出来的内容  打印每一个结点 及其所连接的全部结点def __str__(self):return str(self.id) + ' connectedTo: ' + str([x.id for x in self.connectedTo])# 获取该顶点的键所对应的值  也就是所有邻结点的键def getConnections(self):return self.connectedTo.keys()# 获取顶点的键def getId(self):return self.id# 获取到某邻结点的权重def getWeight(self, nbr):return self.connectedTo[nbr]# 结点构建好了之后开始   构建图中的一个表示方法: 邻接表
class Graph(object):# 初始化图def __init__(self):# 初始化邻接表self.vertList = {}# 初始化顶点数self.numVertices = 0# 添加结点def addVertex(self, key):# 新建一个结点newVertex = Vertex(key)# 将新顶点添加到邻接表中self.vertList[key] = newVertex# 邻接表中顶点数+1self.numVertices += 1# 返回该顶点return newVertex# 获取顶点def getVertex(self, n):# 若待查询结点在邻接表中，则返回该顶点if n in self.vertList:return self.vertList[n]# 否则返回空else:return None# Python3中字典用def __contains__(self, n)取代了has_key:# 在其中就返回True 不在就返回False# 重写in方法  in 和 not in操作的时候会自动调用这个函数def __contains__(self, n):return n in self.vertList# 添加边，参数f为起始顶点，t为目标顶点，weight两点之间边上的权重def addEdge(self, begin, target, weight=0):# 起始顶点不在邻接表中if begin not in self.vertList:#添加起始顶点self.addVertex(begin)# 目标顶点不在邻接表中if target not in self.vertList:# 添加目标顶点self.addVertex(target)# 在邻接表中添加起始点的目标点及权重self.vertList[begin].addNeighbor(self.vertList[target], weight)# 获取邻接表中所有顶点的键def getVertices(self):return self.vertList.keys()# __iter__(self)迭代器 迭代显示邻接表的每个顶点的邻结点def __iter__(self):return iter(self.vertList.values())# 实例化图类
graph = Graph()# 给邻接表添加边及权重
# 第一层循环  循环每个汉字
for ch in dict.keys():# 第二层循环 循环每个汉字对应的解释中的每一个字for ch1 in dict[ch]:# 暂时不设置权值  只添加边  构建一个网络graph.addEdge(ch, ch1)# 统计每一个字的出度和入度
dict_out = {}
dict_in = {}# 循环每个顶点
for g in graph:# 循环每个顶点的所有邻居节点for w in g.getConnections():# 打印顶点和其邻居节点的键# print("(%s, %s)" % (g.getId(), w.getId()))# 将每个字的出度记录下来if g.getId() in dict_in:dict_in[g.getId()] += 1else:dict_in[g.getId()] = 1# 将每个字的入度记录下来if w.getId() in dict_out:dict_out[w.getId()] += 1else:dict_out[w.getId()] = 1# 计算出出度和入读之比
dict_out_in = {}# 第一层循环  循环每个汉字
for ch in dict.keys():# 判断一下是否存在if ch in dict_in and ch in dict_out:# 开始计算出出度和入度之比dict_out_in[ch] = dict_out[ch]/dict_in[ch]else:continue# 记录每一个字的列表
word_lst = []
# 记录每一个字和字频的字典
word_dict = {}# 需要去除的标点符号
exclude_str = "，。！？、（）()【】<>《》=：+:-*—“”…"# 打开文件和存入文件
with open("E:/github/Xinhuazidian/chinese-xinhua/Xinhua/word.txt", "r") as fileIn, open("E:/github/Xinhuazidian/chinese-xinhua/Xinhua/dictfrequency.txt", 'w') as fileOut:# 遍历txt文件的每一行for line in fileIn:# 遍历每一行的每一个字for char in line:# 去掉：# if(char != ":"):# 将字添加到存储字的列表中word_lst.append(char)# 用字典统计每个字出现的个数for char in word_lst:# 去掉标点符号字符if char not in exclude_str:# strip去除各种空白  char.strip()去除字符串首位的空格if char.strip() not in word_dict:# 第一次出现就将字频赋值为1word_dict[char] = 1else:# 每出现一次将字频加1word_dict[char] += 1# 统计字义的长度的字典
exp_length = {}
# 统计字频的字典
word_fre = {}# 第一层循环  循环每个汉字
for ch in dict.keys():# 记录字意的复杂度exp_length[ch] = len(dict[ch])# 加上一个判断条件if ch in word_dict:# 统计字频word_fre[ch] = word_dict[ch]# 现在  每个字的  出度比入度  字频  和  字意长度  都有了
# 分配权重  也就是字义复杂度
dict_power = {}# 定义三个常量
out_in = 100.0
fre = 10.0
length = 10.0# 第一层循环  循环每个汉字
for ch in dict.keys():# 给定判断条件if ch in dict_out_in and ch in word_fre and ch in exp_length:# 计算权重dict_power[ch] = dict_out_in[ch] * out_in + word_fre[ch] * fre + exp_length[ch] * length# 返回一个列表，按照dict的value从大到小排序
dict_power = Counter(dict_power).most_common()# 建立两个集合 分别存储集合内和集合外的字
set_in = []
set_out = []for temp in dict_power[:300]:set_in.append(temp[0])for temp in dict_power[200:]:set_out.append(temp[0])# 首先学习两百个核心的字
print("首先学习最核心的三百个字: ")
for ch in set_in:# 打印出字和其对应的解释print(ch, dict_pinyin[ch])# 新建一个图
graph1 = Graph()# 用一个字典记录集合外的字的出度
dict_set_out = {}# 初始化字典
for ch in set_out:dict_set_out[ch] = 0# 遍历集合内的字
for ch in set_in:# 遍历集合外的字for ch1 in set_out:# 如果集合外的字是集合内的字的解释if ch1 in dict[ch]:# 记录集合外的字的入度dict_set_out[ch1] += 1# 遍历集合外的字
for ch in set_in:# 遍历集合外的字for ch1 in set_out:# 如果两个字不同且一个字在另外一个字的解释中if ch != ch1 and ch1 in dict[ch] and dict_set_out[ch1] >= 15:# 也增加一条单向边graph1.addEdge(ch, ch1)# 最终的存储字典
dict_final = {}# 遍历该图  然后将字典所有的键确定
for g in graph1:dict_final[g.getId()] = []# 循环每个顶点
for g in graph1:# 循环每个顶点的所有邻居节点for w in g.getConnections():# 打印顶点和其邻居节点的键# print("(%s, %s)" % (g.getId(), w.getId()))dict_final[g.getId()].append(w.getId())# 至此 整个汉字网络构建完成
print(dict_final)# 开始节点  目标节点 图字典
def bfs(start_node, num, graph):# 使用namedtuple定义节点，用于存储前置节点 node是结点 name, from node 为它的来源的结点的名字node = namedtuple('node', 'name, from_node')# 使用双端队列，这里当作队列使用，根据先进先出获取下一个遍历的节点search_queue = deque()# 存储队列中已有的节点名称name_search = deque()# 存储已经访问过的节点visited = {}# 填入初始节点，从队列后面加入search_queue.append(node(start_node, None))# 填入初始节点名称name_search.append(start_node)# 用户回溯路径path = []# 打印标记print('开始搜索...')# 只要搜索队列中有数据就一直遍历下去while search_queue:if len(visited) >= num:break# 打印标记print('待遍历节点: ', name_search)# 从队列前边获取节点，即先进先出，这是BFS的核心current_node = search_queue.popleft()# 将名称也相应弹出name_search.popleft()# 当前节点是否被访问过if current_node.name not in visited:# 打印标记print('当前节点: ', current_node.name, end=' | ')# 如果没有找到目标节点，将节点设为已访问，并将相邻节点加入搜索队列，继续找下去visited[current_node.name] = current_node# 遍历相邻节点，判断相邻节点是否已经在搜索队列for node_name in graph[current_node.name]:# 如果相邻节点不在搜索队列则进行添加if node_name not in name_search and node_name in words:search_queue.append(node(node_name, current_node.name))name_search.append(node_name)print("推荐路径结束")last = []for key in visited:last.append(key[0])# 打印搜索结果print('学习路径为:', last)print('\n\n')starting_point = input("请输入学习起点: ")learning_length = int(input("请输入大概的学习长度: "))# 执行搜索
bfs(starting_point, learning_length, dict_final)

展示结果：