企业数据清洗项目实践day3

封装昨天的生成json方法，生成标准字段方法以及生成最终文件的方法。

  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：\n",layer1)
 46     #
 47     # layer2 = dict['A']['01']
 48     # print("第二层 01农业：\n", layer2)
 49     #
 50     # layer3 = dict['A']['01']["011"]
 51     # print("第三层 ：\n", 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表的行数：\n",len(df.index.values))
 77     # print("测试字典：\n",new_dict)
 78     # print(df.loc[80].values)
 79     # print("一个单元格数据的数据类型：\n",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("数据格式：\n",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("门类：\n",layer_0)
198             # print("门类名称:\n",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("大类编码（两位）：\n",layer_10[0])
211                 #进入A对应的{ }
212                 for layer_11 in layer_10[1].items():        #这个for循环已经进入了 第二层 {} 里面格式是 （大类名称：{ }）
213                     # print("大类：\n",layer_11)
214                     big_class = layer_11[0]
215                     # print("大类名称：\n",big_class)
216                     """
217                     ---------------------------------------
218                     """
219                     # 递归调用补全缺失值
220                     if(len(qb03)==2 and qb03==layer_10[0]):
221                         print("缺失值补全：\n", 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("大类直接分到小类：\n",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("中类：\n",layer_21)
245                                 medium_class = layer_21[0]
246                                 # print("中类名称:\n",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("小类名称：\n",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)