1 import pandas as pd
2 import xlwt
3 """
4 rank的一系列变量是生成json字符串需要的标志
5 由于json结构是循环遍历生成的，所以在每一层都要留下标记，以便于下一层的构建
6 """
7
8 rank10="" #A 门类编号
9 rank11="" #A 门类名字
10 rank20="" #01 大类编号
11 rank21="" # 大类名字
12 rank30="" #012 中类编号
13 rank31="" # 中类名字
14 rank40="" #0121小类编号
15 rank41="" # 小类名字
16 #finalstr
17 finalstr=""
18
19 """
20 ------------------------------------------------------------------------------------------------------------------------
21 """
22
23 def get_json(filepwd):
24 """
25 :param filepwd:
26 :return: 标准行业维度json
27 """
28 """
29 filepwd 国标文件格式
30 A 农、林、牧、渔业
31 A 农、林、牧、渔业
32 01 农业
33 011 谷物种植
34 0111 稻谷种植
35 0112 小麦种植
36 0113 玉米种植
37 """
38 # dict={"A":{"01":{"011":"谷物种植","0111":"稻谷种植"} ,
39 # "02":{"021":"林木育种和育苗","0211":"林木育种"}},
40 #
41 # "B":{"06":{ "0610":"烟煤和无烟煤开采洗选","0620":"褐煤开采洗选"},
42 # "07":{"0710":"石油开采","0720":"天然气开采"}}
43 # }
44 # layer1=dict['A']
45 # print("第一层 A：
",layer1)
46 #
47 # layer2 = dict['A']['01']
48 # print("第二层 01农业：
", layer2)
49 #
50 # layer3 = dict['A']['01']["011"]
51 # print("第三层 ：
", layer3)
52 #读取标准文件 df默认不读取第一行数据
53 df = pd.read_excel(filepwd)
54 #首先寻找第一层大写字母层的数据 定位行loc[] 定位
55 # print(df.columns.values[0]) #A
56
57 my_dict={"A":{}} #最终生成的字典
58 new_dict={"A":
59 {"农、林、牧、渔业":
60 {"01":
61 {"农业":
62 {"001":
63 {"谷物种植":
64 {
65 "0111":"稻谷种植","0112":"小麦种植"
66 }
67 }
68 }
69 }
70 }
71 }
72 }
73 # new_dict["A"].update(
74 # {df.loc[0].values[0]:df.loc[0].values[1]}
75 # )
76 # print("excel表的行数：
",len(df.index.values))
77 # print("测试字典：
",new_dict)
78 # print(df.loc[80].values)
79 # print("一个单元格数据的数据类型：
",type(df.loc[0].values[0]))
80
81 #测试完毕 开始构建行业领域分类字典
82 #开始遍历表格 0 - 1423
83 for i in range(len(df.index.values)):
84 #由于表格的第一列数据的数字被判定为int型 所以要转化成str
85 temp=df.loc[i].values
86 #转化字符串 为了保险起见 两列统一化处理 均转化为字符串
87 # one 就是编码 two就是编码对应的行业名称
88 one = str(temp[0])
89 # print(len(one))
90 two = str(temp[1])
91 # print("数据格式：
",type(temp[0]))
92 #通过判断values[0]（数字编码）的字符串的长度判断处于字典的哪一层 如果长度是1 那么在第一层门类 如果长度是2那么在第二层大类 如果长度是3那么在第三层中类
93 if(len(one)==1):
94 #rank10保存编码 rank11保存行业名称 后面类似
95 global rank10
96 global rank11
97 rank10=one
98 rank11=two
99 my_dict.update({rank10:{rank11:{}}})
100 if(len(one)==2):
101 global rank20
102 global rank21
103 rank20 = one
104 rank21 = two
105 my_dict[rank10][rank11].update({rank20:{rank21:{}}})
106 if (len(one) == 3):
107 global rank30
108 global rank31
109 rank30 = one
110 rank31 = two
111 #虽然会出现21 ， 2111 中间没有210的情况出现 但是可以优先生成所有的中类三位数的json结构 这一层会保留最后一个三位数中类 可以在后面进行判断
112 my_dict[rank10][rank11][rank20][rank21].update({rank30:{rank31:{}}})
113 #这里做了代码的前三位字符串切分，为了判断一下有没有小类跳过中类的情况，需要直接跨过中类存储，少了一层字典{}
114 if (len(one) == 4):
115 global rank40
116 global rank41
117 rank40 = one
118 rank41 = two
119 #把编码分片 只取前三位 然后和距离这个编码最近的那个三位数中类做比较 如果相同则可以放到该中类的下一层字典 如果不同则该四位编码自成一个字典
120 divide_rank40=rank40[:3]
121 # print(divide_rank40,rank30)
122 #判等
123 if(divide_rank40==rank30):
124 # print("!!!!!~~~~~~~~~~~~")
125 #相等 -> 放入该中类的下一层字典
126 my_dict[rank10][rank11][rank20][rank21][rank30][rank31].update({rank40:rank41})
127 else:
128 #不等 -> 自己成为一个字典 在大类里直接自成一个字典
129 my_dict[rank10][rank11][rank20][rank21].update({rank40: rank41})
130 #得到最终的字典my_dict
131 # print(my_dict.keys())
132 # print(my_dict)
133 return my_dict
134 """
135 最终生成的json文件
136
137 'A': {
138 '农、林、牧、渔业': {
139 '01': {
140 '农业': {
141 '011': {
142 '谷物种植': {
143 '0111': '稻谷种植',
144 '0112': '小麦种植',
145 '0113': '玉米种植',
146 '0119': '其他谷物种植'
147 }
148 },
149 '012': {
150 '豆类、油料和薯类种植': {
151 '0121': '豆类种植',
152 '0122': '油料种植',
153 '0123': '薯类种植'
154 }
155 },
156 '013': {
157 '棉、麻、糖、烟草种植': {
158 '0131': '棉花种植',
159 '0132': '麻类种植',
160 '0133': '糖料种植',
161 '0134': '烟草种植'
162 }
163 },
164 '014': {
165
166 """
167
168
169 """
170 ------------------------------------------------------------------------------------------------------------------------
171 """
172
173 def ger_stdstr(qb03):
174 """
175 :param qb03:
176 :return: str 标准行业维度字符串 行业代码·门类名称·大类名称·中类名称·小类名称
177 """
178 global finalstr
179 #设置个标记，初始值False 说明默认找不到这个编码 如果找到了则设为True 如果最终是False则重新分割字符串，回调函数
180 flag = False
181 #获取字典
182 my_dict={}
183 my_dict.update(get_json())
184 # print(my_dict)
185
186 category="" #门类 名字
187
188 big_class="" #大类 名字
189
190 medium_class="" #中类 名字
191
192 small_class="" #小类 名字
193 # for 遍历第一层 门类
194 for items in my_dict.items():
195 res = "" # 定义该方法最终要返回的标准化行业维度字符串
196 for layer_0 in items[1].items(): #这个for循环已经进入了 第一层 {} 里面格式是 （门类名称：{ }）
197 # print("门类：
",layer_0)
198 # print("门类名称:
",layer_0[0])
199 category=layer_0[0] #门类名称[0]
200 """
201 -------------------------------------------------------------------
202 """
203 # 遍历第二层大类
204 """
205 每进入一层遍历，第一个for循环是进入一个这样格式的数据 （ 编码：{ } ） [0]是名称 [1]是字典
206 之后第二个for循环进入那个字典{ }
207 字典构建的方式是 上一层是key 下一层是对应的value 同时它作为下一层的key
208 """
209 for layer_10 in layer_0[1].items():
210 # print("大类编码（两位）：
",layer_10[0])
211 #进入A对应的{ }
212 for layer_11 in layer_10[1].items(): #这个for循环已经进入了 第二层 {} 里面格式是 （大类名称：{ }）
213 # print("大类：
",layer_11)
214 big_class = layer_11[0]
215 # print("大类名称：
",big_class)
216 """
217 ---------------------------------------
218 """
219 # 递归调用补全缺失值
220 if(len(qb03)==2 and qb03==layer_10[0]):
221 print("缺失值补全：
", finalstr)
222 flag=True
223 res = finalstr + "·" + category + "·" + big_class + "·" + big_class + "·" + big_class
224 # print(res)
225 return res
226 """
227 ---------------------------------------
228 """
229 #进入大类（01，{ }）
230 for layer_20 in layer_11[1].items():#这个for循环已经进入了 第三层 {} 里面格式是 （中类名称：{ }）或者不正常的跨过中类的四位编码
231 # 这个分支的意思是有的类别只到了大类，没有经过中类直接分到了四位数的小类，所以必须分开遍历
232 #判断第二层下一级的编码是三位还是四位，如果是三位那么是正常的中类划分，如果是四位，那么是跳过了中类划分到了小类
233 if(len(layer_20[0])==4):
234 small_class=layer_20[1]
235 # print("大类直接分到小类：
",small_class)
236 #判断字符串
237 if(qb03==layer_20[0]):
238 print("跨过中类的小类，判断成功！",qb03)
239 flag=True
240 res = qb03+ "·"+ category + "·" + big_class + "·"+small_class+ "·"+small_class
241 return res
242 else:
243 for layer_21 in layer_20[1].items(): #这个for循环已经进入了 第三层正常的中类 {} 里面格式是 （中类名称：{ }）
244 # print("中类：
",layer_21)
245 medium_class = layer_21[0]
246 # print("中类名称:
",medium_class)
247 # 这里是个大坑，我的遍历是进入值的那一层，编码在上一级的遍历 layer_20[0]
248 if (qb03 == layer_20[0]):
249 print("三位中类判断成功！", qb03)
250 flag=True
251 res = qb03 + "·" + category + "·" + big_class + "·" + medium_class+ "·" + medium_class
252 return res
253 #继续划分到小类
254 for layer_30 in layer_21[1].items(): #这个for循环已经进入了 第四层 {} 里面格式是 （小类名称：{ }）
255 #这个layer_30就是最后一层的四位数数据了 格式： ('0111', '稻谷种植') 是一个tuple 索引0是编码1是名称
256 small_class=layer_30[1]
257 # print("小类名称：
",small_class)
258 #--------------------------------------------------------------------------------
259 # 判断字符串
260 if (qb03 == layer_30[0]):
261 print("正常四位小类判断成功！", qb03)
262 flag=True
263 res=qb03+"·"+category+"·"+big_class+"·"+medium_class+"·"+small_class
264 return res
265 #这里是对没有找到的编码进行二次寻找，主要是通过对传入的参数编码进行字符串切分，只保留前两位字符。
266 if(flag==False):
267 finalstr = qb03
268 new_qb03=qb03[:2]
269 return ger_stdstr(new_qb03) #递归调用自身
270
271 """
272 ------------------------------------------------------------------------------------------------------------------------
273 """
274
275 def do_clean(filepwd,newfilepwd):
276 """
277 1、读取源数据表格
278 2、逐个把数据传入get_stdstr(qb03)方法获得返回值存回excel表格
279 参数：需要清洗的行业编码，单列数据
280 :return:None
281 """
282
283 """
284 待清洗的文件格式：filepwd
285 QB03
286 2812
287 3511
288 3071
289 3434
290 2614
291 3620
292 2613
293 2614
294 3512
295
296 清洗完毕的文件格式：newfilepwd
297 data
298 2812·制造业·化学纤维制造业·纤维素纤维原料及纤维制造·人造纤维（纤维素纤维）制造
299 3511·制造业·专用设备制造业·采矿、冶金、建筑专用设备制造·矿山机械制造
300 3071·制造业·非金属矿物制品业·陶瓷制品制造·卫生陶瓷制品制造
301 3434·制造业·通用设备制造业·物料搬运设备制造·连续搬运设备制造
302 2614·制造业·化学原料和化学制品制造业·基础化学原料制造·有机化学原料制造
303 3620·制造业·汽车制造业·改装汽车制造·改装汽车制造
304 2613·制造业·化学原料和化学制品制造业·基础化学原料制造·无机盐制造
305 2614·制造业·化学原料和化学制品制造业·基础化学原料制造·有机化学原料制造
306 3512·制造业·专用设备制造业·采矿、冶金、建筑专用设备制造·石油钻采专用设备制造
307 3599·制造业·专用设备制造业·环保、社会公共服务及其他专用设备制造·其他专用设备制造
308 511·批发和零售业·批发业·农、林、牧产品批发·农、林、牧产品批发
309 3821·制造业·电气机械和器材制造业·输配电及控制设备制造·变压器、整流器和电感器制造
310 6520·信息传输、软件和信息技术服务业·软件和信息技术服务业·信息系统集成服务·信息系统集成服务
311 7330·科学研究和技术服务业·研究和试验发展·农业科学研究和试验发展·农业科学研究和试验发展
312 2922·制造业·橡胶和塑料制品业·塑料制品业·塑料板、管、型材制造
313 """
314 df=pd.read_excel(filepwd)
315 # print(df.loc[0].values)
316 res=[]
317 temp_res=""
318 #range(len(df.index.values))
319 for i in range(len(df.index.values)):
320 # print(df.loc[i].values[0])
321 temp_res=ger_stdstr(str(df.loc[i].values[0]))
322 print(temp_res)
323 if(temp_res!=None):
324 res.append(temp_res)
325 else:
326 res.append(str(df.loc[i].values[0]))
327 # print(res)
328 #把结果存储到excel表
329 workbook = xlwt.Workbook(encoding='utf-8')
330 sheet = workbook.add_sheet('sheet1', cell_overwrite_ok=True)
331 sheet.col(0).width=256*100
332 sheet.write(0, 0, "data")
333 for i in range(len(res)):
334 sheet.write(i+1, 0, res[i])
335 workbook.save(newfilepwd)
336 return None
337 if __name__ == '__main__':
338 # print()
339 #311 2662 610
340 # res=ger_stdstr("610")
341 # print("----------------------")
342 # print(res)
343 # print("----------------------")
344 # do_clean()
345 #封装方法getjson()
346 """
347 1、封装构建json的方法 getjson() , 方法有一个参数 参数是文件路径
348 文件的格式是两列，由于读取文件不包括表头，如果表头数据有需要的话 需要复制一行表头数据
349 第一列是行业编码 第二列是行业名称
350 """
351 #测试调用
352 filename="GBT4754-2011.xlsx"
353 get_json(filename)
354 """
355 --------------------------------------------------------------
356 """
357 #封装方法do_clean(filepwd,newfilepwd)
358 # 测试调用
359 filepwd="2013_year_data.xlsx" #需要处理的文件路径
360 newfilepwd="2013_res_data.xls" #处理完毕转存的文件路径
361 do_clean(filepwd,newfilepwd)