zoukankan      html  css  js  c++  java
  • 企业数据清洗项目实践day2

    进度

    今天完整地进行了行业维度的清洗分析,把行业代码根据国家标准清洗出格式为  “编码·门类·大类·中类·小类”  的数据格式

    过程

    1、先把国家标准编码转化为json数据

    2、根据原始数据编码逐层遍历json数据,补全缺失数据和问题数据。

    代码

      1 import pandas as pd
      2 import xlwt
      3 rank10=""    #A
      4 rank11=""    #A的名字
      5 rank20=""
      6 rank21=""
      7 rank30=""
      8 rank31=""
      9 rank40=""
     10 rank41=""
     11 finalstr=""
     12 def std_excel():
     13     # dict={"A":{"01":{"011":"谷物种植","0111":"稻谷种植"} ,
     14     #            "02":{"021":"林木育种和育苗","0211":"林木育种"}},
     15     #
     16     #       "B":{"06":{ "0610":"烟煤和无烟煤开采洗选","0620":"褐煤开采洗选"},
     17     #            "07":{"0710":"石油开采","0720":"天然气开采"}}
     18     #       }
     19 
     20     # layer1=dict['A']
     21     # print("第一层 A:
    ",layer1)
     22     #
     23     # layer2 = dict['A']['01']
     24     # print("第二层 01农业:
    ", layer2)
     25     #
     26     # layer3 = dict['A']['01']["011"]
     27     # print("第三层 :
    ", layer3)
     28     #读取标准文件
     29     df = pd.read_excel('GBT4754-2011.xlsx')
     30     #首先寻找第一层大写字母层的数据 定位行loc[] 定位
     31     # print(df.columns.values[0]) #A
     32     my_dict={"A":{}}
     33     new_dict={"A":
     34                   {"农、林、牧、渔业":
     35                        {"01":
     36                             {"农业":
     37                                  {"001":
     38                                       {"谷物种植":
     39                                           {
     40                                             "0111":"稻谷种植","0112":"小麦种植"
     41                                           }
     42                                        }
     43                                   }
     44                              }
     45                         }
     46                    }
     47               }
     48     # new_dict["A"].update(
     49     #     {df.loc[0].values[0]:df.loc[0].values[1]}
     50     # )
     51     # print("excel表的行数:
    ",len(df.index.values))
     52     # print("测试字典:
    ",new_dict)
     53     # print(df.loc[80].values)
     54     # print("一个单元格数据的数据类型:
    ",type(df.loc[0].values[0]))
     55 
     56     #测试完毕 开始构建行业领域分类字典
     57     industry_json={}
     58     #开始遍历表格 0 - 1423
     59     for i in range(len(df.index.values)):
     60         #由于表格的第一列数据被判定为int型 所以要转化成str
     61         temp=df.loc[i].values
     62         one = str(temp[0])
     63         # print(len(one))
     64         two = str(temp[1])
     65         # print("数据格式:
    ",type(temp[0]))
     66         #通过判断values[0]的字符串的长度判断处于字典的哪一层 如果长度是1 那么在第一层门类 如果长度是2那么在第二层大类 如果长度是3那么在第三层中类
     67         if(len(one)==1):
     68             global rank10
     69             global rank11
     70             rank10=one
     71             rank11=two
     72             my_dict.update({rank10:{rank11:{}}})
     73         if(len(one)==2):
     74             global rank20
     75             global rank21
     76             rank20 = one
     77             rank21 = two
     78             my_dict[rank10][rank11].update({rank20:{rank21:{}}})
     79         if (len(one) == 3):
     80             global rank30
     81             global rank31
     82             rank30 = one
     83             rank31 = two
     84             my_dict[rank10][rank11][rank20][rank21].update({rank30:{rank31:{}}})
     85         #这里做了代码的前三位字符串切分,为了判断一下有没有小类跳过中类的情况,需要直接跨过中类存储,少了一层字典{}
     86         if (len(one) == 4):
     87             global rank40
     88             global rank41
     89             rank40 = one
     90             rank41 = two
     91             divide_rank40=rank40[:3]
     92             # print(divide_rank40,rank30)
     93             if(divide_rank40==rank30):
     94                 # print("!!!!!~~~~~~~~~~~~")
     95                 my_dict[rank10][rank11][rank20][rank21][rank30][rank31].update({rank40:rank41})
     96             else:
     97                 my_dict[rank10][rank11][rank20][rank21].update({rank40: rank41})
     98     #得到最终的字典my_dict
     99     # print(my_dict.keys())
    100     # print(my_dict)
    101     return my_dict
    102 def is_excit(qb03):
    103     global finalstr
    104     #设置个标记,初始值False 说明默认找不到这个编码 如果找到了则设为 True 如果最终是False则重新分割字符串回调函数
    105     flag = False
    106     #获取字典
    107     my_dict={}
    108     my_dict.update(std_excel())
    109     # print(my_dict)
    110     #门类KEY
    111     category=""
    112     #大类
    113     big_class=""
    114     #中类
    115     medium_class=""
    116     #小类
    117     small_class=""
    118     # 遍历第一层 门类
    119 
    120     for items in my_dict.items():
    121         res = ""
    122         for layer_0 in items[1].items():
    123             # print("门类:
    ",layer_0)
    124             # print("门类名称:
    ",layer_0[0])
    125             category=layer_0[0]
    126             """
    127             --------------------------------------------------
    128             """
    129             # 遍历第二层大类
    130             """
    131             每进入一层遍历第一个for循环是进入一个这样格式的数据 ( 编码:{  } )
    132             之后第二个for循环进入那个字典{ }
    133             字典构建的方式是 上一层是key 下一层是对应的value 同时它作为下一层的key
    134             
    135             """
    136             #进入第一层(A:{ } )
    137             for layer_10 in layer_0[1].items():
    138                 # print("大类编码(两位):
    ",layer_10[0])
    139                 #进入A对应的{ }
    140                 for layer_11 in layer_10[1].items():
    141                     # print("大类:
    ",layer_11)
    142                     big_class = layer_11[0]
    143                     # 自己调用自己补全缺失值
    144                     if(len(qb03)==2 and qb03==layer_10[0]):
    145                         print("缺失值补全:
    ", finalstr)
    146                         flag=True
    147                         res = finalstr + "·" + category + "·" + big_class + "·" + big_class + "·" + big_class
    148                         # print(res)
    149                         return res
    150                     # print("大类名称:
    ",big_class)
    151                     """
    152                     --------------------------------------------------
    153                     """
    154                     #进入大类(01,{ })
    155                     for layer_20 in layer_11[1].items():
    156                         #进入01对应的 { }
    157                         #判断第二层下一级的名称是三位还是四位,如果是三位那么是正常的中类划分,如果是四位,那么是跳过了中类划分到了小类
    158                         if(len(layer_20[0])==4):
    159                             small_class=layer_20[1]
    160                             # print("大类直接分到小类:
    ",small_class)
    161                             #判断字符串
    162                             if(qb03==layer_20[0]):
    163                                 print("跨过中类的小类,判断成功!",qb03)
    164                                 flag=True
    165                                 res = qb03+ "·"+ category + "·" + big_class + "·"+small_class+ "·"+small_class
    166                                 return res
    167                         else:
    168                             #这个分支的意思是有的类别只到了大类,没有中类直接分到了四位数的小类,所以必须分开遍历,字符串不能按字典遍历
    169                             for layer_21 in layer_20[1].items():
    170                                 # print("中类:
    ",layer_21)
    171                                 medium_class = layer_21[0]
    172                                 # print("中类名称:
    ",medium_class)
    173                                 # 这里是个大坑,我的遍历是进入值的那一层,编码在上一级的遍历 layer_20[0]
    174                                 if (qb03 == layer_20[0]):
    175                                     print("三位中类判断成功!", qb03)
    176                                     flag=True
    177                                     res = qb03 + "·" + category + "·" + big_class + "·" + medium_class+ "·" + medium_class
    178                                     return res
    179                                 #继续划分到小类
    180                                 for layer_30 in layer_21[1].items():
    181                                     #这个layer_30就是最后一层的四位数数据了 格式: ('0111', '稻谷种植') 是一个tuple 索引0是编码1是名称
    182                                     small_class=layer_30[1]
    183                                     # print("小类名称:
    ",small_class)
    184                                     #--------------------------------------------------------------------------------
    185                                     # 判断字符串
    186                                     if (qb03 == layer_30[0]):
    187                                         print("正常四位小类判断成功!", qb03)
    188                                         flag=True
    189                                         res=qb03+"·"+category+"·"+big_class+"·"+medium_class+"·"+small_class
    190                                         return res
    191     if(flag==False):
    192         finalstr = qb03
    193         new_qb03=qb03[:2]
    194         return is_excit(new_qb03)
    195 def clean():
    196     """
    197     1、读取源数据表格
    198     2、逐个把数据传入is_exist()方法获得返回值存回excel表格
    199     :return:
    200     """
    201     df=pd.read_excel("2013_year_data.xlsx")
    202     # print(df.loc[0].values)
    203     res=[]
    204     temp_res=""
    205     #range(len(df.index.values))
    206     for i in range(len(df.index.values)):
    207         # print(df.loc[i].values[0])
    208         temp_res=is_excit(str(df.loc[i].values[0]))
    209         print(temp_res)
    210         if(temp_res!=None):
    211             res.append(temp_res)
    212         else:
    213             res.append(str(df.loc[i].values[0]))
    214     # print(res)
    215     #把结果存储到excel表
    216     workbook = xlwt.Workbook(encoding='utf-8')
    217     sheet = workbook.add_sheet('sheet1', cell_overwrite_ok=True)
    218     sheet.col(0).width=256*100
    219     sheet.write(0, 0, "data")
    220     for i in range(len(res)):
    221         sheet.write(i+1, 0, res[i])
    222     workbook.save('2013_res_data.xls')
    223     return None
    224 if __name__ == '__main__':
    225     # print()
    226     #311 2662 610
    227     # res=is_excit("610")
    228     # print("----------------------")
    229     # print(res)
    230     # print("----------------------")
    231 
    232     clean()

    部分json数据(格式)

     1 {
     2     'A': {
     3         '农、林、牧、渔业': {
     4             '01': {
     5                 '农业': {
     6                     '011': {
     7                         '谷物种植': {
     8                             '0111': '稻谷种植',
     9                             '0112': '小麦种植',
    10                             '0113': '玉米种植',
    11                             '0119': '其他谷物种植'
    12                         }
    13                     },
    14                     '012': {
    15                         '豆类、油料和薯类种植': {
    16                             '0121': '豆类种植',
    17                             '0122': '油料种植',
    18                             '0123': '薯类种植'
    19                         }
    20                     },
    21                     '013': {
    22                         '棉、麻、糖、烟草种植': {
    23                             '0131': '棉花种植',
    24                             '0132': '麻类种植',
    25                             '0133': '糖料种植',
    26                             '0134': '烟草种植'
    27                         }
    28                     },
    29                     '014': {
    30                         '蔬菜、食用菌及园艺作物种植': {
    31                             '0141': '蔬菜种植',
    32                             '0142': '食用菌种植',
    33                             '0143': '花卉种植',
    34                             '0149': '其他园艺作物种植'
    35                         }
    36                     },
    37                     '015': {
    38                         '水果种植': {
    39                             '0151': '仁果类和核果类水果种植',
    40                             '0152': '葡萄种植',
    41                             '0153': '柑橘类种植',
    42                             '0154': '香蕉等亚热带水果种植',
    43                             '0159': '其他水果种植'
    44                         }
    45                     },
    46                     '016': {
    47                         '坚果、含油果、香料和饮料作物种植': {
    48                             '0161': '坚果种植',
    49                             '0162': '含油果种植',
    50                             '0163': '香料作物种植',
    51                             '0169': '茶及其他饮料作物种植'
    52                         }
    53                     },
    54                     '0170': '中药材种植',
    55                     '0190': '其他农业'
    56                 }
    57             },
    58             '02': {
    59                 '林业': {
    60                     '021': {
    61                         '林木育种和育苗': {
    62                             '0211': '林木育种',
    63                             '0212': '林木育苗'
    64                         }
    65                     },
    66                     '0220': '造林和更新',
    67                     '0230': '森林经营和管护',
    68                     '024': {
    69                         '木材和竹材采运': {
    70                             '0241': '木材采运',
    71                             '0242': '竹材采运'
    72                         }
    73                     },
    74                     '025': {
    75                         '林产品采集': {
    76                             '0251': '木竹材林产品采集',
    77                             '0252': '非木竹材林产品采集'
    78                         }
    79                     }
    80                 }
    81             },
  • 相关阅读:
    CSS的Flex弹性布局概念
    配置不同二级域名访问不同端口的应用
    JAVA调用FFMpeg进行转码等操作
    python获取页面文字信息
    gradle配置多个代码仓库repositories
    转载:微信小程序源码提取反编译
    Maven相关:mvn的配置和简单命令
    Spring Data JPA简单查询接口方法速查
    tomcat server.xml详解
    mysql批量插入优化
  • 原文地址:https://www.cnblogs.com/rainbow-1/p/15449397.html
Copyright © 2011-2022 走看看