回答編集履歴
4
    
        answer	
    CHANGED
    
    | @@ -5,29 +5,29 @@ | |
| 5 5 | 
             
            import json
         | 
| 6 6 |  | 
| 7 7 | 
             
            csv_data = '''
         | 
| 8 | 
            -
            階層1,階層2,階層3,所有者
         | 
| 8 | 
            +
            階層1,階層2,階層3,階層4,所有者
         | 
| 9 | 
            -
            果物,赤,りんご,A
         | 
| 9 | 
            +
            果物,赤,りんご,,A
         | 
| 10 | 
            -
            果物,赤,いちご,A
         | 
| 10 | 
            +
            果物,赤,いちご,甘い,A
         | 
| 11 | 
            -
            果物,黄色,ばなな,B
         | 
| 11 | 
            +
            果物,黄色,ばなな,,B
         | 
| 12 | 
            -
            果物,黄色,れもん,C
         | 
| 12 | 
            +
            果物,黄色,れもん,酸っぱい,C
         | 
| 13 | 
            -
            野菜,赤,にんじん,C
         | 
| 13 | 
            +
            野菜,赤,にんじん,,C
         | 
| 14 | 
            -
            野菜,赤,とまと,A
         | 
| 14 | 
            +
            野菜,赤,とまと,甘い,A
         | 
| 15 | 
            -
            野菜,緑,きゅうり,B
         | 
| 15 | 
            +
            野菜,緑,きゅうり,,B
         | 
| 16 | 
            -
            野菜,緑,せろり,A
         | 
| 16 | 
            +
            野菜,緑,せろり,,A
         | 
| 17 | 
            -
            その他,赤,,B
         | 
| 17 | 
            +
            その他,赤,,,B
         | 
| 18 | 
            -
            その他,黄色,,A
         | 
| 18 | 
            +
            その他,黄色,,,A
         | 
| 19 19 | 
             
            '''
         | 
| 20 | 
            -
            df = pd.read_csv(io.StringIO(csv_data))
         | 
| 21 20 |  | 
| 22 21 | 
             
            #
         | 
| 23 22 | 
             
            def nested_dict(df):
         | 
| 24 23 | 
             
                l = len(df.columns)
         | 
| 25 24 | 
             
                if l == 1:
         | 
| 26 | 
            -
                    return df.values[0][0]
         | 
| 25 | 
            +
                    return df.values[0][0] #if df.values.size == 1 else df.values.squeeze()
         | 
| 27 26 | 
             
                if df.values[0][0] is np.nan:
         | 
| 27 | 
            +
                    idx = df.iloc[0].first_valid_index()
         | 
| 28 | 
            -
                    if  | 
| 28 | 
            +
                    if idx == df.columns[-1]:
         | 
| 29 | 
            -
                        return df.values[0][1]
         | 
| 29 | 
            +
                        return df.values[0][-1]
         | 
| 30 | 
            -
                    df = df. | 
| 30 | 
            +
                    df = df.loc[:,idx:]
         | 
| 31 31 | 
             
                grp = df.groupby(df.columns[0], sort=False, dropna=False)
         | 
| 32 32 | 
             
                return {k: nested_dict(g.iloc[:,1:]) for k, g in grp}
         | 
| 33 33 |  | 
| @@ -39,17 +39,23 @@ | |
| 39 39 | 
             
            #   "果物": {
         | 
| 40 40 | 
             
            #     "赤": {
         | 
| 41 41 | 
             
            #       "りんご": "A",
         | 
| 42 | 
            +
            #       "いちご": {
         | 
| 42 | 
            -
            # | 
| 43 | 
            +
            #         "甘い": "A"
         | 
| 44 | 
            +
            #       }
         | 
| 43 45 | 
             
            #     },
         | 
| 44 46 | 
             
            #     "黄色": {
         | 
| 45 47 | 
             
            #       "ばなな": "B",
         | 
| 48 | 
            +
            #       "れもん": {
         | 
| 46 | 
            -
            # | 
| 49 | 
            +
            #         "酸っぱい": "C"
         | 
| 50 | 
            +
            #       }
         | 
| 47 51 | 
             
            #     }
         | 
| 48 52 | 
             
            #   },
         | 
| 49 53 | 
             
            #   "野菜": {
         | 
| 50 54 | 
             
            #     "赤": {
         | 
| 51 55 | 
             
            #       "にんじん": "C",
         | 
| 56 | 
            +
            #       "とまと": {
         | 
| 52 | 
            -
            # | 
| 57 | 
            +
            #         "甘い": "A"
         | 
| 58 | 
            +
            #       }
         | 
| 53 59 | 
             
            #     },
         | 
| 54 60 | 
             
            #     "緑": {
         | 
| 55 61 | 
             
            #       "きゅうり": "B",
         | 
| @@ -61,4 +67,4 @@ | |
| 61 67 | 
             
            #     "黄色": "A"
         | 
| 62 68 | 
             
            #   }
         | 
| 63 69 | 
             
            # }
         | 
| 64 | 
            -
            ```
         | 
| 70 | 
            +
            ```
         | 
3
    
        answer	
    CHANGED
    
    | @@ -27,8 +27,7 @@ | |
| 27 27 | 
             
                if df.values[0][0] is np.nan:
         | 
| 28 28 | 
             
                    if l == 2:
         | 
| 29 29 | 
             
                        return df.values[0][1]
         | 
| 30 | 
            -
                    if l > 2:
         | 
| 31 | 
            -
             | 
| 30 | 
            +
                    df = df.iloc[:,1:]
         | 
| 32 31 | 
             
                grp = df.groupby(df.columns[0], sort=False, dropna=False)
         | 
| 33 32 | 
             
                return {k: nested_dict(g.iloc[:,1:]) for k, g in grp}
         | 
| 34 33 |  | 
2
    
        answer	
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 | 
            -
            ※ 「その他」の部分が「期待する結果」とは異なります
         | 
| 2 1 | 
             
            ```python
         | 
| 3 2 | 
             
            import io
         | 
| 4 3 | 
             
            import pandas as pd
         | 
| 4 | 
            +
            import numpy as np
         | 
| 5 5 | 
             
            import json
         | 
| 6 6 |  | 
| 7 7 | 
             
            csv_data = '''
         | 
| @@ -21,12 +21,18 @@ | |
| 21 21 |  | 
| 22 22 | 
             
            #
         | 
| 23 23 | 
             
            def nested_dict(df):
         | 
| 24 | 
            -
                 | 
| 24 | 
            +
                l = len(df.columns)
         | 
| 25 | 
            +
                if l == 1:
         | 
| 25 | 
            -
                    return df.values[0][0] | 
| 26 | 
            +
                    return df.values[0][0]
         | 
| 27 | 
            +
                if df.values[0][0] is np.nan:
         | 
| 28 | 
            +
                    if l == 2:
         | 
| 29 | 
            +
                        return df.values[0][1]
         | 
| 30 | 
            +
                    if l > 2:
         | 
| 31 | 
            +
                        df = df.iloc[:,1:]
         | 
| 26 32 | 
             
                grp = df.groupby(df.columns[0], sort=False, dropna=False)
         | 
| 27 33 | 
             
                return {k: nested_dict(g.iloc[:,1:]) for k, g in grp}
         | 
| 28 34 |  | 
| 29 | 
            -
            dic = nested_dict(df | 
| 35 | 
            +
            dic = nested_dict(df)
         | 
| 30 36 | 
             
            js = json.dumps(dic, ensure_ascii=False, indent=2)
         | 
| 31 37 | 
             
            print(js)
         | 
| 32 38 |  | 
| @@ -52,12 +58,8 @@ | |
| 52 58 | 
             
            #     }
         | 
| 53 59 | 
             
            #   },
         | 
| 54 60 | 
             
            #   "その他": {
         | 
| 55 | 
            -
            #     "赤": {
         | 
| 56 | 
            -
            # | 
| 61 | 
            +
            #     "赤": "B",
         | 
| 57 | 
            -
            #     },
         | 
| 58 | 
            -
            #     "黄色": {
         | 
| 59 | 
            -
            # | 
| 62 | 
            +
            #     "黄色": "A"
         | 
| 60 | 
            -
            #     }
         | 
| 61 63 | 
             
            #   }
         | 
| 62 64 | 
             
            # }
         | 
| 63 | 
            -
            ```
         | 
| 65 | 
            +
            ```
         | 
1
    
        answer	
    CHANGED
    
    | @@ -1,11 +1,8 @@ | |
| 1 1 | 
             
            ※ 「その他」の部分が「期待する結果」とは異なります
         | 
| 2 | 
            -
             | 
| 3 2 | 
             
            ```python
         | 
| 4 3 | 
             
            import io
         | 
| 5 4 | 
             
            import pandas as pd
         | 
| 6 | 
            -
            import numpy as np
         | 
| 7 5 | 
             
            import json
         | 
| 8 | 
            -
            from functools import reduce
         | 
| 9 6 |  | 
| 10 7 | 
             
            csv_data = '''
         | 
| 11 8 | 
             
            階層1,階層2,階層3,所有者
         | 
| @@ -23,14 +20,14 @@ | |
| 23 20 | 
             
            df = pd.read_csv(io.StringIO(csv_data))
         | 
| 24 21 |  | 
| 25 22 | 
             
            #
         | 
| 26 | 
            -
             | 
| 23 | 
            +
            def nested_dict(df):
         | 
| 27 | 
            -
             | 
| 24 | 
            +
                if len(df.columns) == 1:
         | 
| 28 | 
            -
                    . | 
| 25 | 
            +
                    return df.values[0][0] 
         | 
| 29 | 
            -
             | 
| 26 | 
            +
                grp = df.groupby(df.columns[0], sort=False, dropna=False)
         | 
| 30 | 
            -
             | 
| 27 | 
            +
                return {k: nested_dict(g.iloc[:,1:]) for k, g in grp}
         | 
| 31 28 |  | 
| 32 | 
            -
             | 
| 29 | 
            +
            dic = nested_dict(df.ffill(axis=1))
         | 
| 33 | 
            -
             | 
| 30 | 
            +
            js = json.dumps(dic, ensure_ascii=False, indent=2)
         | 
| 34 31 | 
             
            print(js)
         | 
| 35 32 |  | 
| 36 33 | 
             
            # {
         | 
