数据链接：DiseaseKG:基于cnSchma常见疾病信息知识图谱 - 图谱 - 开放知识图谱 数据下载：GitHub - nuolade/disease-kb: 常见疾病相关信息构建knowledge graph

知识图谱学习笔记 4_落霞孤雾的博客-CSDN博客_medical.json

数据分析

1
2
3
4
5
6
7
8
9
10
11
diseaseKB
├── data
│   └── medical.json 结构化疾病医疗知识
├── prepare_data
│   ├── build_data.py 数据处理到数据库
│   ├── data_spider.py 爬取数据
│   └── max_cut.py 根据给定的词典对文本进行前向、后向和双向最大匹配
├── dict 各种类别的词典
├── build_medicalgraph.py 利用结构化的数据建立Neo4j知识图谱 
├── build_medicalgraph_from_json.py 利用实体和关系json文件据建立知识图谱 
└── build_json.py 利用爬取的数据生成提炼的实体和关系json文件

/data/下存放所有数据的数据

image.png

在 dict 中存放处理好的对应数据

image.png

数据载入

image.png
image.png

代码分析

基于原理和提供的代码，我增加了注释和修改了顺序，有些语法也重新写了。

导包

首先是导入需要的包

1
2
3
4
import py2neo  
import os  
import json  
import logging    # 可以不用

如果使用 logging 进行信息输出，需要在这之后加上

1
logging.getLogger().setLevel(logging.INFO)   # 使得在pycharm中显示logging.info

定义 main

1
2
3
4
5
if __name__ == '__main__':  
    handler = MedicalGraph()  
    handler.clean()        # 清楚所有节点和关系
    handler.create_graph_nodes()     # 建立节点
    handler.create_graph_relationship()     # 建立关系

定义 MedicalGraph 类

定义__init__()函数

1
2
3
4
5
def __init__(self):  
	# os.path.abspath(__file__)返回当前脚本的绝对路径,windows使用\\分割  
    cur_dir = '\\'.join(os.path.abspath(__file__).split('\\')[:-1])    
    self.data_path = os.path.join(cur_dir,'data\\medical.json')  
    self.clinet = py2neo.Graph("http://127.0.0.1:7474", user='neo4j', password='12345678', name='neo4j')

定义 clean() 函数

1
2
3
def clean(self):  
    logging.info("================正在删除所有节点和关系================")  
    self.clinet.run("match (n) detach delete (n)")

定义读取 json 文件函数

同时构建节点和节点间的关系，后面不论是构建节点还是定义关系都会重新使用 read_json () 这个独立函数.

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
def read_json(self):  
    # 1 建立实体节点list，共8类节点  
    drugs = []  # 药品  
    foods = []  # 食物  
    checks = []  # 检查  
    departments = []  # 科室名称  
    producers = []  # 药品大类  
    diseases = []  # 疾病名称  
    symptoms = []  # 症状  
    cures = []  # 治疗方法  
  
    # 2 建立实体节点之间关系list  
    rels_department = []  # 科室－科室关系（前小后大）  
    rels_noteat = []  # 疾病－忌吃食物关系  
    rels_doeat = []  # 疾病－宜吃食物关系  
    rels_recommandeat = []  # 疾病－推荐吃食物关系  
    rels_commonddrug = []  # 疾病－通用药品关系  
    rels_recommanddrug = []  # 疾病－热门药品关系  
    rels_check = []  # 疾病－检查关系  
    rels_drug_producer = []  # 厂商－药物关系  
    rels_cureway = []  # 疾病-治疗方式关系  
    rels_symptom = []  # 疾病-症状关系  
    rels_acompany = []  # 疾病并发关系  
    rels_category = []  # 疾病-科室之间的关系  
  
    # 3 建立疾病存储字典  
    disease_infos = []  # 疾病信息  
  
    # 4 读取文件  
    for data in open(self.data_path,'rb'):  
        data_json = json.loads(data)      # json.loads(data)可用于解析有效的JSON字符串并将其转换为Python字典  
  
        diseases.append(data_json['name'])  # 加入疾病名称list中  
  
        # 构建一个病毒字典，存储当前病毒的所有信息  
        disease_dict = {}  
  
        disease_name = data_json['name']    # 因为后面反复使用,所有设置变量访问更快  
        disease_dict['name'] = disease_name  
        disease_dict['desc'] = ''  
        disease_dict['prevent'] = ''  
        disease_dict['cause'] = ''  
        disease_dict['easy_get'] = ''  
        disease_dict['cure_department'] = ''  
        disease_dict['cure_way'] = ''  
        disease_dict['cure_lasttime'] = ''  
        disease_dict['symptom'] = ''  
        disease_dict['cured_prob'] = ''  
  
        # 4.1 必须有的字段  
        if 'desc' in data_json:  
            disease_dict['desc'] = data_json['desc']  
  
        if 'prevent' in data_json:  
            disease_dict['prevent'] = data_json['prevent']  
  
        if 'cause' in data_json:  
            disease_dict['cause'] = data_json['cause']  
  
        if 'easy_get' in data_json:  
            disease_dict['easy_get'] = data_json['easy_get']  
  
        if 'cure_department' in data_json:     # 所属科室  
            cure_department = data_json['cure_department']  
            if len(cure_department)==1:     # 疾病-科室之间的关系  
                rels_category.append([disease_name,cure_department[0]])  
            if len(cure_department)==2:     # 科室－科室关系（前小后大） 疾病-科室之间的关系  
                big = cure_department[0]  
                small = cure_department[1]  
                rels_department.append([small,big])  
                rels_category.append([disease_name,cure_department[0]])  
            departments += cure_department    # list的添加可以用append,也可以用+  
  
        if 'cure_way' in data_json:    # 疾病治疗方法  
            cure_way = data_json['cure_way']  
            for cure in cure_way:  
                rels_cureway.append([disease_name,cure])  
            cures += cure_way  
  
        if 'cure_lasttime' in data_json:    # 治疗周期  
            disease_dict['cure_lasttime'] = data_json['cure_lasttime']  
  
        if 'symptom' in data_json:      # 疾病症状  
            for symptom in data_json['symptom']:  
                rels_symptom.append([disease_name, symptom])  
            symptoms += data_json['symptom']  
  
        if 'cured_prob' in data_json:     # 治愈概率  
            disease_dict['cured_prob'] = data_json['cured_prob']  
  
        # 4.2 还有其他可能有的字段  
        if 'get_prob' in data_json:  
            disease_dict['get_prob'] = data_json['get_prob']  
  
        if 'easy_get' in data_json:  
            disease_dict['easy_get'] = data_json['easy_get']  
  
        # 4.3 建立关系  
        if 'acompany' in data_json:  
            for acompany in data_json['acompany']:  
                rels_acompany.append([disease_name, acompany])  
  
        if 'common_drug' in data_json:  
            common_drug = data_json['common_drug']  
            for drug in common_drug:  
                rels_commonddrug.append([disease_name, drug])  
            drugs += common_drug  
  
        if 'recommand_drug' in data_json:  
            recommand_drug = data_json['recommand_drug']  
            drugs += recommand_drug      # 药品名称增加  
            for drug in recommand_drug:  
                rels_recommanddrug.append([disease_name, drug])  
  
        if 'not_eat' in data_json:  
            not_eat = data_json['not_eat']  
            for _not in not_eat:  
                rels_noteat.append([disease_name,_not])  
            foods += not_eat  
  
        if 'do_eat' in data_json:  
            do_eat = data_json['do_eat']  
            for _do in do_eat:  
                rels_doeat.append([disease_name,_do])  
            foods += do_eat  
  
        if 'recommand_eat' in data_json:  
            recommand_eat = data_json['recommand_eat']  
            for _recommand in recommand_eat:  
                rels_recommandeat.append([disease_name, _recommand])  
            foods += recommand_eat  
  
        if 'check' in data_json:     # 检查项目  
            check = data_json['check']  
            for _check in check:  
                rels_check.append([disease_name, _check])  
            checks += check  
  
        if 'drug_detail' in data_json:    # 药品详情  
            drug_detail = data_json['drug_detail']  
            producer = [i.split('(')[0] for i in drug_detail]     # 得到药品的名称,i.split('(')表示根据(将其分开,[0]表示取(之前的内容  
            # print(producer)  
            rels_drug_producer += [[i.split('(')[0], i.split('(')[-1].replace(')', '')] for i in drug_detail]   # 对每个药物,构建其名称和所属类型的对应关系  
            producers += producer  
        # print(rels_drug_producer)  
  
        # 4.4 存入将当前疾病及其信息存入disease_infos字典中  
        disease_infos.append(disease_dict)  
  
    # 5 返回数据  
    return set(drugs), set(foods), set(checks), set(departments), set(producers), set(symptoms), set(diseases), set(  
        cures), disease_infos,rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug, \  
           rels_symptom, rels_acompany, rels_category, rels_cureway     # 返回节点和关系(节点使用set会自动删除重复元素,关系是二元组不能直接用set去重)

回到 main 函数，可以看到我们需要定义 create_graph_nodes() 函数和 create_graph_relationship() 函数

定义创建节点函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 创建实体节点  
def create_graph_nodes(self):  
    # 1 获取需要读取的文件信息  
    Drugs, Foods, Checks, Departments, Producers, Symptoms, Diseases, Cures, disease_infos, rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug, rels_symptom, rels_acompany, rels_category, rels_cureway = self.read_json()  
  
    # 2 创建疾病节点  
    self.create_diseases_nodes(disease_infos)  
  
    # 3 创建其他类型节点,只有name属性  
    self.create_simple_nodes('Drug', Drugs)    # 药品  
    self.create_simple_nodes('Food', Foods)    # 食物  
    self.create_simple_nodes('Check', Checks)   # 检查项目  
    self.create_simple_nodes('Department', Departments)    # 科目  
    self.create_simple_nodes('Producer', Producers)     # 在售药品  
    self.create_simple_nodes('Symptom', Symptoms)     # 疾病症状  
    self.create_simple_nodes('Cure', Cures)      # 治疗方法

这里定义疾病节点和其他节点不同，疾病节点由多个属性组成，而普通节点只有 name 属性。

定义创建疾病节点函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def create_diseases_nodes(self,disease_infos):  
    logging.info("================正在创建疾病实体节点================")  
    sum = len(disease_infos)  
    count = 0  
    for disease_dict in disease_infos:  
        node = py2neo.Node("Disease",name=disease_dict['name'], desc=disease_dict['desc'],  
                    prevent=disease_dict['prevent'] ,cause=disease_dict['cause'],  
                    easy_get=disease_dict['easy_get'],cure_lasttime=disease_dict['cure_lasttime'],  
                    cured_prob=disease_dict['cured_prob'])  
        self.clinet.create(node)  
        count += 1  
        if count % 2000==0:  
            logging.info("已经创建%d个节点,总共%d个节点",count,sum)  
    logging.info("已创建完成,共创建%d个节点", count)  
    return

定义创建普通节点函数

1
2
3
4
5
6
7
8
9
10
11
def create_simple_nodes(self,label,nodes):  
    logging.info("================正在创建%s实体节点================",label)  
    count = 0  
    sum = len(nodes)  
    for node_name in nodes:  
        node = py2neo.Node(label,name=node_name)  
        self.clinet.create(node)  
        count += 1  
        if count%2000==0:  
            logging.info("已经创建%d个节点,总共%d个节点", count, sum)  
    logging.info("已创建完成,共创建%d个节点", count)

定义创建关系函数

对每个关系分别调用关系创建函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建实体关系  
def create_graph_relationship(self):  
    # 1 获取需要读取的文件信息  
    Drugs, Foods, Checks, Departments, Producers, Symptoms, Diseases, Cures, disease_infos, rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug, rels_symptom, rels_acompany, rels_category, rels_cureway = self.read_json()  
  
    # 2 依次建立关系  
    self.create_relationship('Disease', 'Food', rels_recommandeat, 'recommand_eat', '推荐食谱')  
    self.create_relationship('Disease', 'Food', rels_noteat, 'no_eat', '忌吃')  
    self.create_relationship('Disease', 'Food', rels_doeat, 'do_eat', '宜吃')  
    self.create_relationship('Department', 'Department', rels_department, 'belongs_to', '属于')  
    self.create_relationship('Disease', 'Drug', rels_commonddrug, 'common_drug', '常用药品')  
    self.create_relationship('Producer', 'Drug', rels_drug_producer, 'drugs_of', '生产药品')  
    self.create_relationship('Disease', 'Drug', rels_recommanddrug, 'recommand_drug', '好评药品')  
    self.create_relationship('Disease', 'Check', rels_check, 'need_check', '诊断检查')  
    self.create_relationship('Disease', 'Symptom', rels_symptom, 'has_symptom', '症状')  
    self.create_relationship('Disease', 'Disease', rels_acompany, 'acompany_with', '并发症')  
    self.create_relationship('Disease', 'Department', rels_category, 'belongs_to', '所属科室')  
    self.create_relationship('Disease', 'Cure', rels_cureway, 'cure_way','治疗方法')

定义关系创建函数

这里需要注意：在 json 中存在 '（单引号），所以如果在命令语句中的 %s 左右被 '' 包裹，可能会出现错误情况，所以需要用 ""。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def create_relationship(self,start_node,end_node,edges_list,rel_type,rel_name):    # 此处关联是用rel_type，但是会给它一个中文名称rel_name  
    logging.info("================正在构建%s关系================", rel_name)  
    # 1 去重操作  
    set_edges = []  
    # 1.1 先将二元组拼接为一个字符串  
    for edge in edges_list:    # 对于每一对二元组  
        set_edges.append('###'.join(edge))     #每一对二元组都转为一个字符串再存入set_edges列表中  
    # 1.2 set去重  
    set_edges = set(set_edges)  
    # 1.3 将每个字符串还原成二元组  
    for edge in set_edges:  
        edge = edge.split('###')  
        p_name = edge[0]  
        q_name = edge[1]  
        cmd = """match (p:%s {name:"%s"}),(q:%s {name:"%s"}) create (p)-[rel:%s {name:"%s"}]->(q)""" % (start_node,p_name,end_node,q_name,rel_type,rel_name)  
        self.clinet.run(cmd)

完整代码

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
import py2neo  
import os  
import json  
import logging  
  
logging.getLogger().setLevel(logging.INFO)   # 使得在pycharm中显示logging.info  
  
class MedicalGraph:  
    def __init__(self):  
        cur_dir = '\\'.join(os.path.abspath(__file__).split('\\')[:-1])    # os.path.abspath(__file__)返回当前脚本的绝对路径,windows使用\\分割  
        self.data_path = os.path.join(cur_dir,'data\\medical.json')  
        self.clinet = py2neo.Graph("http://127.0.0.1:7474", user='neo4j', password='12345678', name='neo4j')  
  
    def clean(self):  
        logging.info("================正在删除所有节点和关系================")  
        self.clinet.run("match (n) detach delete (n)")  
  
    def read_json(self):  
        # 1 建立实体节点list，共8类节点  
        drugs = []  # 药品  
        foods = []  # 食物  
        checks = []  # 检查  
        departments = []  # 科室名称  
        producers = []  # 药品大类  
        diseases = []  # 疾病名称  
        symptoms = []  # 症状  
        cures = []  # 治疗方法  
  
        # 2 建立实体节点之间关系list  
        rels_department = []  # 科室－科室关系（前小后大）  
        rels_noteat = []  # 疾病－忌吃食物关系  
        rels_doeat = []  # 疾病－宜吃食物关系  
        rels_recommandeat = []  # 疾病－推荐吃食物关系  
        rels_commonddrug = []  # 疾病－通用药品关系  
        rels_recommanddrug = []  # 疾病－热门药品关系  
        rels_check = []  # 疾病－检查关系  
        rels_drug_producer = []  # 厂商－药物关系  
        rels_cureway = []  # 疾病-治疗方式关系  
        rels_symptom = []  # 疾病-症状关系  
        rels_acompany = []  # 疾病并发关系  
        rels_category = []  # 疾病-科室之间的关系  
  
        # 3 建立疾病存储字典  
        disease_infos = []  # 疾病信息  
  
        # 4 读取文件  
        for data in open(self.data_path,'rb'):  
            data_json = json.loads(data)      # json.loads(data)可用于解析有效的JSON字符串并将其转换为Python字典  
  
            diseases.append(data_json['name'])  # 加入疾病名称list中  
  
            # 构建一个病毒字典，存储当前病毒的所有信息  
            disease_dict = {}  
  
            disease_name = data_json['name']    # 因为后面反复使用,所有设置变量访问更快  
            disease_dict['name'] = disease_name  
            disease_dict['desc'] = ''  
            disease_dict['prevent'] = ''  
            disease_dict['cause'] = ''  
            disease_dict['easy_get'] = ''  
            disease_dict['cure_department'] = ''  
            disease_dict['cure_way'] = ''  
            disease_dict['cure_lasttime'] = ''  
            disease_dict['symptom'] = ''  
            disease_dict['cured_prob'] = ''  
  
            # 4.1 必须有的字段  
            if 'desc' in data_json:  
                disease_dict['desc'] = data_json['desc']  
  
            if 'prevent' in data_json:  
                disease_dict['prevent'] = data_json['prevent']  
  
            if 'cause' in data_json:  
                disease_dict['cause'] = data_json['cause']  
  
            if 'easy_get' in data_json:  
                disease_dict['easy_get'] = data_json['easy_get']  
  
            if 'cure_department' in data_json:     # 所属科室  
                cure_department = data_json['cure_department']  
                if len(cure_department)==1:     # 疾病-科室之间的关系  
                    rels_category.append([disease_name,cure_department[0]])  
                if len(cure_department)==2:     # 科室－科室关系（前小后大） 疾病-科室之间的关系  
                    big = cure_department[0]  
                    small = cure_department[1]  
                    rels_department.append([small,big])  
                    rels_category.append([disease_name,cure_department[0]])  
                departments += cure_department    # list的添加可以用append,也可以用+  
  
            if 'cure_way' in data_json:    # 疾病治疗方法  
                cure_way = data_json['cure_way']  
                for cure in cure_way:  
                    rels_cureway.append([disease_name,cure])  
                cures += cure_way  
  
            if 'cure_lasttime' in data_json:    # 治疗周期  
                disease_dict['cure_lasttime'] = data_json['cure_lasttime']  
  
            if 'symptom' in data_json:      # 疾病症状  
                for symptom in data_json['symptom']:  
                    rels_symptom.append([disease_name, symptom])  
                symptoms += data_json['symptom']  
  
            if 'cured_prob' in data_json:     # 治愈概率  
                disease_dict['cured_prob'] = data_json['cured_prob']  
  
            # 4.2 还有其他可能有的字段  
            if 'get_prob' in data_json:  
                disease_dict['get_prob'] = data_json['get_prob']  
  
            if 'easy_get' in data_json:  
                disease_dict['easy_get'] = data_json['easy_get']  
  
            # 4.3 建立关系  
            if 'acompany' in data_json:  
                for acompany in data_json['acompany']:  
                    rels_acompany.append([disease_name, acompany])  
  
            if 'common_drug' in data_json:  
                common_drug = data_json['common_drug']  
                for drug in common_drug:  
                    rels_commonddrug.append([disease_name, drug])  
                drugs += common_drug  
  
            if 'recommand_drug' in data_json:  
                recommand_drug = data_json['recommand_drug']  
                drugs += recommand_drug      # 药品名称增加  
                for drug in recommand_drug:  
                    rels_recommanddrug.append([disease_name, drug])  
  
            if 'not_eat' in data_json:  
                not_eat = data_json['not_eat']  
                for _not in not_eat:  
                    rels_noteat.append([disease_name,_not])  
                foods += not_eat  
  
            if 'do_eat' in data_json:  
                do_eat = data_json['do_eat']  
                for _do in do_eat:  
                    rels_doeat.append([disease_name,_do])  
                foods += do_eat  
  
            if 'recommand_eat' in data_json:  
                recommand_eat = data_json['recommand_eat']  
                for _recommand in recommand_eat:  
                    rels_recommandeat.append([disease_name, _recommand])  
                foods += recommand_eat  
  
            if 'check' in data_json:     # 检查项目  
                check = data_json['check']  
                for _check in check:  
                    rels_check.append([disease_name, _check])  
                checks += check  
  
            if 'drug_detail' in data_json:    # 药品详情  
                drug_detail = data_json['drug_detail']  
                producer = [i.split('(')[0] for i in drug_detail]     # 得到药品的名称,i.split('(')表示根据(将其分开,[0]表示取(之前的内容  
                # print(producer)  
                rels_drug_producer += [[i.split('(')[0], i.split('(')[-1].replace(')', '')] for i in drug_detail]   # 对每个药物,构建其名称和所属类型的对应关系  
                producers += producer  
            # print(rels_drug_producer)  
  
            # 4.4 存入将当前疾病及其信息存入disease_infos字典中  
            disease_infos.append(disease_dict)  
  
        # 5 返回数据  
        return set(drugs), set(foods), set(checks), set(departments), set(producers), set(symptoms), set(diseases), set(  
            cures), disease_infos,rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug, \  
               rels_symptom, rels_acompany, rels_category, rels_cureway     # 返回节点和关系(节点使用set会自动删除重复元素,关系是二元组不能直接用set去重)  
  
    def create_diseases_nodes(self,disease_infos):  
        logging.info("================正在创建疾病实体节点================")  
        sum = len(disease_infos)  
        count = 0  
        for disease_dict in disease_infos:  
            node = py2neo.Node("Disease",name=disease_dict['name'], desc=disease_dict['desc'],  
                        prevent=disease_dict['prevent'] ,cause=disease_dict['cause'],  
                        easy_get=disease_dict['easy_get'],cure_lasttime=disease_dict['cure_lasttime'],  
                        cured_prob=disease_dict['cured_prob'])  
            self.clinet.create(node)  
            count += 1  
            if count % 2000==0:  
                logging.info("已经创建%d个节点,总共%d个节点",count,sum)  
        logging.info("已创建完成,共创建%d个节点", count)  
        return  
  
    def create_simple_nodes(self,label,nodes):  
        logging.info("================正在创建%s实体节点================",label)  
        count = 0  
        sum = len(nodes)  
        for node_name in nodes:  
            node = py2neo.Node(label,name=node_name)  
            self.clinet.create(node)  
            count += 1  
            if count%2000==0:  
                logging.info("已经创建%d个节点,总共%d个节点", count, sum)  
        logging.info("已创建完成,共创建%d个节点", count)  
  
    def create_relationship(self,start_node,end_node,edges_list,rel_type,rel_name):    # 此处关联是用rel_type，但是会给它一个中文名称rel_name  
        logging.info("================正在构建%s关系================", rel_name)  
        # 1 去重操作  
        set_edges = []  
        # 1.1 先将二元组拼接为一个字符串  
        for edge in edges_list:    # 对于每一对二元组  
            set_edges.append('###'.join(edge))     #每一对二元组都转为一个字符串再存入set_edges列表中  
        # 1.2 set去重  
        set_edges = set(set_edges)  
        # 1.3 将每个字符串还原成二元组  
        for edge in set_edges:  
            edge = edge.split('###')  
            p_name = edge[0]  
            q_name = edge[1]  
            cmd = """match (p:%s {name:"%s"}),(q:%s {name:"%s"}) create (p)-[rel:%s {name:"%s"}]->(q)""" % (start_node,p_name,end_node,q_name,rel_type,rel_name)  
            self.clinet.run(cmd)  
  
    # 创建实体节点  
    def create_graph_nodes(self):  
        # 1 获取需要读取的文件信息  
        Drugs, Foods, Checks, Departments, Producers, Symptoms, Diseases, Cures, disease_infos, rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug, rels_symptom, rels_acompany, rels_category, rels_cureway = self.read_json()  
  
        # 2 创建疾病节点  
        self.create_diseases_nodes(disease_infos)  
  
        # 3 创建其他类型节点,只有name属性  
        self.create_simple_nodes('Drug', Drugs)    # 药品  
        self.create_simple_nodes('Food', Foods)    # 食物  
        self.create_simple_nodes('Check', Checks)   # 检查项目  
        self.create_simple_nodes('Department', Departments)    # 科目  
        self.create_simple_nodes('Producer', Producers)     # 在售药品  
        self.create_simple_nodes('Symptom', Symptoms)     # 疾病症状  
        self.create_simple_nodes('Cure', Cures)      # 治疗方法  
  
    # 创建实体关系  
    def create_graph_relationship(self):  
        # 1 获取需要读取的文件信息  
        Drugs, Foods, Checks, Departments, Producers, Symptoms, Diseases, Cures, disease_infos, rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug, rels_symptom, rels_acompany, rels_category, rels_cureway = self.read_json()  
  
        # 2 依次建立关系  
        self.create_relationship('Disease', 'Food', rels_recommandeat, 'recommand_eat', '推荐食谱')  
        self.create_relationship('Disease', 'Food', rels_noteat, 'no_eat', '忌吃')  
        self.create_relationship('Disease', 'Food', rels_doeat, 'do_eat', '宜吃')  
        self.create_relationship('Department', 'Department', rels_department, 'belongs_to', '属于')  
        self.create_relationship('Disease', 'Drug', rels_commonddrug, 'common_drug', '常用药品')  
        self.create_relationship('Producer', 'Drug', rels_drug_producer, 'drugs_of', '生产药品')  
        self.create_relationship('Disease', 'Drug', rels_recommanddrug, 'recommand_drug', '好评药品')  
        self.create_relationship('Disease', 'Check', rels_check, 'need_check', '诊断检查')  
        self.create_relationship('Disease', 'Symptom', rels_symptom, 'has_symptom', '症状')  
        self.create_relationship('Disease', 'Disease', rels_acompany, 'acompany_with', '并发症')  
        self.create_relationship('Disease', 'Department', rels_category, 'belongs_to', '所属科室')  
        self.create_relationship('Disease', 'Cure', rels_cureway, 'cure_way','治疗方法')  
  
if __name__ == '__main__':  
    handler = MedicalGraph()  
    handler.clean()  
    handler.create_graph_nodes()  
    handler.create_graph_relationship()