精华内容
下载资源
问答
  • 分层/多级索引在处理复杂的数据分析和数据操作方面为开发者奠定了基础,尤其是在处理高纬度数据处理上。本质上,它使您能够在较低维度的数据结构(如Series(1d)和DataFrame(2d))中存储和操作任意维数的数据。 1. ...

    分层/多级索引在处理复杂的数据分析和数据操作方面为开发者奠定了基础,尤其是在处理高纬度数据处理上。本质上,它使您能够在较低维度的数据结构(如 Series(1d)和DataFrame (2d))中存储和操作任意维数的数据。

    1. 使用MultiIndex.from_tuples()创建多级索引和分层索引对象 

     输出:

    2. 使用MultiIndex.from_product()方法可以在两个迭代器中对每个元素进行配对

     输出:

     3. 使用MultiIndex.from_frame()方法直接将一个DataFrame对象构造一个多索引

     输出:

    4. 为了方便,还可以将数组列表直接传递到SeriesDataFrame中,从而自动构造一个MultiIndex 

     输出:

     5. 重构层次标签,get_level_values()方法将返回特定级别每个位置的标签向量

     输出:

     

    展开全文
  • 本文对pandas的常用操作,如数据的筛选、拼接、多级索引、数据透视进行简介,并提供了相关的操作方法

    在python中,我们常用的数据分析库莫过于pandas,而数据分析中,我们常用的方法莫过于筛选、拼接、多级列表和数据透视了,下面我将通过四个板块对这四个方面进行介绍。

    目录

    1. 筛选
    2. 拼接(连接)
    3. 多级列表
    4. 数据透视
    5. 完整代码

    首先创建一个10*6的Dataframe,用到的库有pandas、numpy

    import pandas as pd
    import numpy as np
    df=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    df
    

    在这里插入图片描述

    一、 筛选

    对于excel的常用就是对某列进行筛选操作了,那么我们在pandas中如何进行呢?其实pandas给我们提供了多个方法,不过最常用的还是lociloc,这两个方法的筛选逻辑不一样,简单的理解来说就是:loc是关注于列的筛选,iloc关注的行的筛选,两者的功能没有区别下面我分别介绍两种方法。

    1.1、loc

    上面已经创建好了df,下面我们开始利用df进行讲解
    df.loc[a,b]
    a表示行,b表示列,注意b只能为字符或者列表,不能为数字,否则报错,下面是相关的方法运用。

    单列数据筛选

    >>> df.loc[:,"A"]
    0    77
    1    84
    2    56
    3    90
    4    55
    5    52
    6    57
    7    93
    8    78
    9    81
    Name: A, dtype: int32
    

    多列数据筛选

     df.loc[:,["A","B"]] 
        A   B
    0  77  96
    1  84  93
    2  56  92
    3  90  66
    4  55  74
    5  52  79
    6  57  99
    7  93  77
    8  78  99
    9  81  68
    

    也可以用:来进行引用,如下

    >>> df.loc[:,"A":"E"]   
        A   B   C   D   E
    0  77  96  72  92  92
    1  84  93  51  62  68
    2  56  92  79  61  52
    3  90  66  87  79  83
    4  55  74  90  75  55
    5  52  79  81  74  89
    6  57  99  90  56  63
    7  93  77  85  54  62
    8  78  99  54  62  57
    9  81  68  97  58  90
    

    上面简单的介绍了loc方法筛选列,下面来介绍筛选行
    对多行的单列值进行筛选:

    >>> df.loc[df['B']==99] 
        A   B   C   D   E   F
    6  57  99  90  56  63  69
    8  78  99  54  62  57  91
    

    对B列进行筛选筛选其值等于99的数据。
    对多行数据的多列值进行筛选:

    
    >>> df.loc[(df['B']==99)&(df['C']==90)] #注意细节,这里需要加(),否则会报错
        A   B   C   D   E   F
    6  57  99  90  56  63  69
    

    这里有个细节,对列的数据进行并列筛选时,注意细节,这里需要加(),否则会报错

    1.2、iloc

    下面来介绍iloc,用法大概如下
    df.iloc[a,b]
    这个地方a和b都必须是intege。iloc的列参数只能是整数;
    a代表的行,b代表的列
    列筛选:

    >>> df.iloc[2,:] 
    A    56
    B    92
    C    79
    D    61
    E    52
    F    84
    Name: 2, dtype: int32
    >>> df.iloc[2,3:5] 
    D    61
    E    52
    Name: 2, dtype: int32
    

    如果发现这个取数的格式不是我们想的那样,想要如df格式那样,如下:

    >>> df.iloc[2:3,3:5] 
        D   E
    2  61  52
    

    这里进行总结一下,loc和iloc的主要区别有两个

    1、两者参数都是[行,列],但是loc的列参数不能为数字,必须为columns,否则会报错
    iloc的参数为数字,否则也会报错
    2、:   loc的带:参数实行的左闭右闭规则,但是iloc实行的是左闭右开规则,所以取数逻辑不一样。
    

    二、拼接

    拼接,又称作连接,对于df的绘制非常的重要,一般常用的有append、merge、concat,在这里,主要讲解merge和concat

    2.1、merge

    merge的产生主要如下:

    pd.merge(left, right, 
    		how='inner', 
    		on=None, 
    		left_on=None, 
    		right_on=None,
            left_index=False, 
            right_index=False, sort=True,
            suffixes=('_x', '_y'), 
            copy=True, 
            indicator=False,
             validate=None)
    

    我们在拼接过程中常用的是on、how,我也只准备从这两个方面展开:

    on: 要加入的列或索引级别名称。 必须在左侧和右侧DataFrame对象中找到。
     如果未传递且left_index和right_index为False,
     则DataFrame中的列的交集将被推断为**连接键。**
     how: 参数有4个。**inner是取交集,left,right,outer取并集。没有同时出现的会将缺失的部分添加缺失值。**
    

    下面是相关的实例:
    outer

    >>> df1=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    >>> df1
        A   B   C   D   E   F
    0  66  69  84  87  76  51
    1  60  50  75  80  93  78
    2  55  57  92  91  88  60
    3  89  77  68  92  53  75
    4  93  64  58  55  67  68
    5  85  85  50  56  70  82
    6  93  56  74  58  73  82
    7  57  83  77  91  72  73
    8  90  78  67  58  95  84
    9  96  96  67  50  78  72
    >>> df2=pd.DataFrame(np.random.randint(50,100,(10,5)),columns=['F',"M",'N','X','Y'])
    >>> df2
        F   M   N   X   Y
    0  77  96  67  75  65
    1  57  55  61  98  89
    2  80  51  68  64  53
    3  66  68  88  71  76
    4  59  58  89  65  99
    5  75  81  82  61  64
    6  50  55  97  57  81
    7  91  96  83  59  82
    8  89  87  67  88  72
    9  91  86  82  83  55
    >>> pd.merge(df1,df2,on="F",how="outer")
           A     B     C     D     E   F     M     N     X     Y
    0   66.0  69.0  84.0  87.0  76.0  51   NaN   NaN   NaN   NaN
    1   60.0  50.0  75.0  80.0  93.0  78   NaN   NaN   NaN   NaN
    2   55.0  57.0  92.0  91.0  88.0  60   NaN   NaN   NaN   NaN
    3   89.0  77.0  68.0  92.0  53.0  75  81.0  82.0  61.0  64.0
    4   93.0  64.0  58.0  55.0  67.0  68   NaN   NaN   NaN   NaN
    5   85.0  85.0  50.0  56.0  70.0  82   NaN   NaN   NaN   NaN
    6   93.0  56.0  74.0  58.0  73.0  82   NaN   NaN   NaN   NaN
    7   57.0  83.0  77.0  91.0  72.0  73   NaN   NaN   NaN   NaN
    8   90.0  78.0  67.0  58.0  95.0  84   NaN   NaN   NaN   NaN
    9   96.0  96.0  67.0  50.0  78.0  72   NaN   NaN   NaN   NaN
    10   NaN   NaN   NaN   NaN   NaN  77  96.0  67.0  75.0  65.0
    11   NaN   NaN   NaN   NaN   NaN  57  55.0  61.0  98.0  89.0
    12   NaN   NaN   NaN   NaN   NaN  80  51.0  68.0  64.0  53.0
    13   NaN   NaN   NaN   NaN   NaN  66  68.0  88.0  71.0  76.0
    14   NaN   NaN   NaN   NaN   NaN  59  58.0  89.0  65.0  99.0
    15   NaN   NaN   NaN   NaN   NaN  50  55.0  97.0  57.0  81.0
    16   NaN   NaN   NaN   NaN   NaN  91  96.0  83.0  59.0  82.0
    17   NaN   NaN   NaN   NaN   NaN  91  86.0  82.0  83.0  55.0
    18   NaN   NaN   NaN   NaN   NaN  89  87.0  67.0  88.0  72.0
    

    inner

    >>> df1=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    >>> df1
        A   B   C   D   E   F
    0  91  55  73  66  77  93
    1  82  88  67  57  93  80
    2  51  58  56  81  62  75
    3  63  85  93  99  50  85
    4  98  92  58  63  72  66
    5  93  79  85  76  64  86
    6  67  69  86  57  73  69
    7  94  69  84  79  78  84
    8  62  83  68  70  61  78
    9  88  84  98  76  85  87
    >>> df2=pd.DataFrame(np.random.randint(50,100,(10,5)),columns=['F',"M",'N','X','Y'])
    >>> df2
        F   M   N   X   Y
    0  94  95  71  71  68
    1  71  94  63  89  97
    2  50  95  80  70  82
    3  79  83  87  72  99
    4  87  93  70  66  95
    5  91  78  90  59  87
    6  58  63  67  81  70
    7  64  77  67  64  86
    8  76  89  94  62  52
    9  67  79  51  63  61
    >>> pd.merge(df1,df2,on="F",how="inner")
        A   B   C   D   E   F   M   N   X   Y
    0  88  84  98  76  85  87  93  70  66  95
    
    两者的区别可以总结如下
    1、inner取拼接列的共有值(交集),将两边的列进行组合
    2、outer取拼接列的所有值(并集),将两边的列进行组合,对于多出来的列值,用NaN填充
    

    2.2、concat

    concat的参数如下

    pd.concat(objs, 
    			axis=0, 
    			join='outer', 
    			join_axes=None, 
    			ignore_index=False,
            	keys=None, levels=None, 
            	names=None, 
            	verify_integrity=False,
            	copy=True)
    

    主要参数简介

    objs:一般为列表,表示要拼接的df,形如[df1,df2,df3]
    join:拼接的类型,如merge的参数
    axis:拼接的类型,纵向拼接还是横向拼接
    ignore_index:是否对新表的index进行重构,重新排序
    

    实例如下
    纵向连接,作用与merge的outer一样

    >>> df1=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    >>> df1
        A   B   C   D   E   F
    0  97  58  92  71  56  64
    1  81  68  90  70  83  84
    2  79  56  52  94  68  80
    3  76  70  69  79  63  77
    4  81  63  67  65  76  63
    5  86  98  85  92  76  79
    6  99  96  56  78  53  84
    7  53  79  99  65  86  81
    8  55  60  66  66  61  61
    9  66  56  59  56  98  84
    >>> df2=pd.DataFrame(np.random.randint(50,100,(10,5)),columns=['F',"M",'N','X','Y'])
    >>> df2
        F   M   N   X   Y
    0  59  56  61  57  54
    1  72  53  74  53  51
    2  65  93  83  96  79
    3  95  56  50  85  97
    4  95  70  57  70  52
    5  50  92  76  66  88
    6  81  85  80  54  51
    7  65  62  60  77  79
    8  53  81  66  87  59
    9  59  94  57  95  55
    >>> # pd.merge(df1,df2,on="F",how="inner")
    >>> 
    >>> pd.concat([df1,df2],axis=0)
          A     B     C     D     E   F     M     N     X     Y
    0  97.0  58.0  92.0  71.0  56.0  64   NaN   NaN   NaN   NaN
    1  81.0  68.0  90.0  70.0  83.0  84   NaN   NaN   NaN   NaN
    2  79.0  56.0  52.0  94.0  68.0  80   NaN   NaN   NaN   NaN
    3  76.0  70.0  69.0  79.0  63.0  77   NaN   NaN   NaN   NaN
    4  81.0  63.0  67.0  65.0  76.0  63   NaN   NaN   NaN   NaN
    5  86.0  98.0  85.0  92.0  76.0  79   NaN   NaN   NaN   NaN
    6  99.0  96.0  56.0  78.0  53.0  84   NaN   NaN   NaN   NaN
    7  53.0  79.0  99.0  65.0  86.0  81   NaN   NaN   NaN   NaN
    8  55.0  60.0  66.0  66.0  61.0  61   NaN   NaN   NaN   NaN
    9  66.0  56.0  59.0  56.0  98.0  84   NaN   NaN   NaN   NaN
    0   NaN   NaN   NaN   NaN   NaN  59  56.0  61.0  57.0  54.0
    1   NaN   NaN   NaN   NaN   NaN  72  53.0  74.0  53.0  51.0
    2   NaN   NaN   NaN   NaN   NaN  65  93.0  83.0  96.0  79.0
    3   NaN   NaN   NaN   NaN   NaN  95  56.0  50.0  85.0  97.0
    4   NaN   NaN   NaN   NaN   NaN  95  70.0  57.0  70.0  52.0
    5   NaN   NaN   NaN   NaN   NaN  50  92.0  76.0  66.0  88.0
    6   NaN   NaN   NaN   NaN   NaN  81  85.0  80.0  54.0  51.0
    7   NaN   NaN   NaN   NaN   NaN  65  62.0  60.0  77.0  79.0
    8   NaN   NaN   NaN   NaN   NaN  53  81.0  66.0  87.0  59.0
    9   NaN   NaN   NaN   NaN   NaN  59  94.0  57.0  95.0  55.0
    

    横向拼接

    >>> df1=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    >>> df1
        A   B   C   D   E   F
    0  75  68  84  82  77  62
    1  65  50  95  79  87  98
    2  64  56  79  83  85  91
    3  98  67  90  60  81  93
    4  79  66  91  66  94  81
    5  64  56  91  85  99  88
    6  77  53  58  73  52  85
    7  76  82  54  92  81  81
    8  79  66  69  83  79  54
    9  99  62  76  95  74  63
    >>> df2=pd.DataFrame(np.random.randint(50,100,(10,5)),columns=['F',"M",'N','X','Y'])
    >>> df2
        F   M   N   X   Y
    0  93  68  87  87  63
    1  96  93  79  88  73
    2  69  62  81  75  89
    3  52  57  88  96  76
    4  80  51  85  61  74
    5  94  87  59  79  86
    6  74  76  71  59  95
    7  80  81  55  61  59
    8  95  63  72  57  85
    9  76  88  83  80  95
    >>> # pd.merge(df1,df2,on="F",how="inner")
    >>> 
    >>> pd.concat([df1,df2],axis=1)
        A   B   C   D   E   F   F   M   N   X   Y
    0  75  68  84  82  77  62  93  68  87  87  63
    1  65  50  95  79  87  98  96  93  79  88  73
    2  64  56  79  83  85  91  69  62  81  75  89
    3  98  67  90  60  81  93  52  57  88  96  76
    4  79  66  91  66  94  81  80  51  85  61  74
    5  64  56  91  85  99  88  94  87  59  79  86
    6  77  53  58  73  52  85  74  76  71  59  95
    7  76  82  54  92  81  81  80  81  55  61  59
    8  79  66  69  83  79  54  95  63  72  57  85
    9  99  62  76  95  74  63  76  88  83  80  95
    

    三、多级索引

    先来解释下多级索引:多级索引也称为层次化索引(hierarchical indexing),是指数据在一个轴上(行或者列)拥有多个(两个以上)索引级别。之所以引入多级索引,在于它可以使用户能以低维度形式处理高维度数据。
    pandas 的多级索引,主要是通过pd.MultiIndex的方法来创建的,具体创建方式有三种,我们介绍其中的两种类型from_product、from_tuples

    3.1、from_product

    from_product主要有两个参数list1和list2

    MultiIndex.from_product:
    	mul_col = pd.MultiIndex.from_product([[list1,list2])
    该方法用于创建list1*list2的2级索引,list1为1级,list2为2级
    

    下面我们来实际看一下:

    >>> df1=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    >>> df1
        A   B   C   D   E   F
    0  74  75  85  60  94  59
    1  93  69  64  66  80  88
    2  94  73  60  80  68  67
    3  50  87  95  69  70  78
    4  81  65  63  93  61  50
    5  92  89  65  92  52  72
    6  61  50  76  57  82  64
    7  70  65  53  57  74  70
    8  99  69  53  69  63  78
    9  60  66  89  54  90  94
    >>> col=pd.MultiIndex.from_product([["A","B"], ['x','y','z']])
    >>> col
    MultiIndex([('A', 'x'),
                ('A', 'y'),
                ('A', 'z'),
                ('B', 'x'),
                ('B', 'y'),
                ('B', 'z')],
               )
    >>> df1.columns=col
    >>> df1
        A           B
        x   y   z   x   y   z
    0  74  75  85  60  94  59
    1  93  69  64  66  80  88
    2  94  73  60  80  68  67
    3  50  87  95  69  70  78
    4  81  65  63  93  61  50
    5  92  89  65  92  52  72
    6  61  50  76  57  82  64
    7  70  65  53  57  74  70
    8  99  69  53  69  63  78
    9  60  66  89  54  90  94
    

    多级列表2

    >>> df1
       考试1  考试2  考试3  考试4  考试5  考试6
    0   63   93   50   86   81   99
    1   75   73   87   77   66   60
    2   98   58   79   62   91   74
    3   81   92   57   64   54   61
    4   81   96   81   61   73   97
    5   64   91   75   82   90   90
    6   58   86   55   56   87   52
    7   71   89   71   90   77   97
    8   80   71   55   78   81   81
    9   68   74   54   63   54   88
    >>> # col=pd.MultiIndex.from_product([["A","B"], ['x','y','z']])
    >>> # col
    >>> # df1.columns=col
    >>> # df1
    >>>
    >>> index=pd.MultiIndex.from_product([["小明","小龙"],["科目1","科目2","科目3","科目4","科目5"]],names=["姓名","科目"])
    >>> df1.index=index
    >>> df1
            考试1  考试2  考试3  考试4  考试5  考试6
    姓名 科目
    小明 科目1   63   93   50   86   81   99
       科目2   75   73   87   77   66   60
       科目3   98   58   79   62   91   74
       科目4   81   92   57   64   54   61
       科目5   81   96   81   61   73   97
    小龙 科目1   64   91   75   82   90   90
       科目2   58   86   55   56   87   52
       科目3   71   89   71   90   77   97
       科目4   80   71   55   78   81   81
       科目5   68   74   54   63   54   88
    

    3.2、from_tuples

    from_tuples的格式大概如下,my_tup是一个list,list的每一个数据都是一个tuple,因此叫from_tuples

    pd.MultiIndex.from_tuples([list], names = ['Obj', 'time'])
    pd.MultiIndex.from_tuples
    		pd.MultiIndex.from_tuples(my_tup, names = ['Obj', 'time'])  
    	my_tup是个list,里面包含多级索引信息,以tuple中的第一个值为1级,第二个值为2级
    

    案例如下:

    >>> my_index = pd.MultiIndex.from_tuples(my_tup, names = ['Obj', 'time'])  
    >>> pd.DataFrame(np.random.randint(60,100, (4,3)), 
    ...              index = my_index,
    ...             columns = [*'ABC'])  
                  A   B   C
    Obj    time
    Python 期中    71  92  71
           期末    87  98  73
    Java   期中    73  62  76
           期末    94  93  84
    >>>
    

    四、数据透视

    pandas中,进行数据透视的主要方法是pivot_table

    pivot_table(data,    # DataFrame
                values=None,    # 值
                index=None,    # 分类汇总依据
                columns=None,    # 列
                aggfunc='mean',    # 聚合函数
                fill_value=None,    # 对缺失值的填充
                margins=False,    # 是否启用总计行/列
                dropna=True,    # 删除缺失
                margins_name='All'   # 总计行/列的名称
               )
    

    由于本人时间的缘故,就先写到此,详细了了解pandas 的数据透视操作,参考 链接

    本文全部代码

    import pandas as pd
    import numpy as np
    
    df=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    df
    # 筛选
    # loc
    df.loc[:,"A"]
    df.loc[df['A']==55] #取A列都是55的行数据
    df.loc[:,['A','B']] #取A B两列的数据
    df.loc[(df['B']==99)&(df['C']==90)] #注意细节,这里需要加(),否则会报错
    
    # iloc
    # 为了方便记忆,记住i是integer的意思。iloc的列参数只能是整数;loc的列参数不能是整数。这是本质区别。注意,这里所指的是列参数。
    df.iloc[0,:]
    # 连接
    df1=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['A',"B",'C','D','E','F'])
    df1
    df2=pd.DataFrame(np.random.randint(50,100,(10,5)),columns=['F',"M",'N','X','Y'])
    df2
    # pd.merge(df1,df2,on="F",how="inner")
    pd.concat([df1,df2],axis=1)
    
    # 多级索引
    df1=pd.DataFrame(np.random.randint(50,100, (10, 6)),columns=['考试1',"考试2",'考试3','考试4','考试5','考试6'])
    df1
    # col=pd.MultiIndex.from_product([["A","B"], ['x','y','z']])
    # col
    # df1.columns=col
    # df1
    index=pd.MultiIndex.from_product([["小明","小龙"],["科目1","科目2","科目3","科目4","科目5"]],names=["姓名","科目"])
    df1.index=index
    df1
    my_tup = [('Python', '期中'),('Python', '期末'),('Java', '期中'),('Java', '期末')]
    my_index = pd.MultiIndex.from_tuples(my_tup, names = ['Obj', 'time'])  
    pd.DataFrame(np.random.randint(60,100, (4,3)), 
                 index = my_index,
                columns = [*'ABC'])  
    

    本文参考了以下链接

    https://blog.csdn.net/brucewong0516/article/details/82707492
    https://blog.csdn.net/qq_21840201/article/details/80727504
    https://blog.csdn.net/zzpdbk/article/details/79232661
    https://blog.csdn.net/anshuai_aw1/article/details/83510345
    https://www.jianshu.com/p/d30fdfbeb312
    https://www.cnblogs.com/shanger/p/13245669.html
    https://www.cnblogs.com/onemorepoint/p/8425300.html

    展开全文
  • 多级索引的Series数据类型2.多级索引Series对象和DataFrame对象的相互转化3.带多级索引的DataFrame数据类型4.多级索引的创建方法5.多级行索引和多级列索引举例之前的几集里,我们使用了Series数据类型表示一维数据...

    微信公众号: python数据科学家

    【要点抢先看】

    1.带多级索引的Series数据类型

    2.多级索引Series对象和DataFrame对象的相互转化

    3.带多级索引的DataFrame数据类型

    4.多级索引的创建方法

    5.多级行索引和多级列索引举例

    之前的几集里,我们使用了Series数据类型表示一维数据(即仅有一个索引列),用DataFrame类型数据表示二维数据(即包含行索引和列索引这两维索引数据)。

    但是如果是下面这种情况呢?比如我们用Series来表示美国不同的州、不同年份的人口数据,这对Series来说就相当于有了两个索引值:即(州,人口)二维索引,第一反应我们尝试使用元组来表示索引信息:

    import pandas as pd

    import numpy as np

    index = [('California', 2008), ('California', 2018),

    ('New York', 2008), ('New York', 2018),

    ('Texas', 2008), ('Texas', 2018)]

    population = [33870000, 37250000,

    18970000, 19370000,

    20850000, 25140000]

    pop = pd.Series(population, index=index)

    print(pop)

    (California, 2008) 33870000

    (California, 2018) 37250000

    (New York, 2008) 18970000

    (New York, 2018) 19370000

    (Texas, 2008) 20850000

    (Texas, 2018) 25140000

    dtype: int64

    这是我们第一直觉所采取的方法,但是这种形式在数据的操作上很不方便,比如我们要拿出所有2018年的数据,似乎比较繁琐。

    不用着急,Pandas为我们提供了更好、更直观的解决方法,他提供了一个MultiIndex类型,专门用来处理这种多级索引的问题。

    我们尝试用这种方法做一个示范:

    import pandas as pd

    import numpy as np

    index = [('California', 2008), ('California', 2018),

    ('New York', 2008), ('New York', 2018),

    ('Texas', 2008), ('Texas', 2018)]

    mul_index = pd.MultiIndex.from_tuples(index)

    print(mul_index)

    MultiIndex(levels=[['California', 'New York', 'Texas'], [2008, 2018]],

    labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]])

    我们生成了一个MultiIndex类型的对象,其中levels属性的两个列表元素表示两个索引列里的值,labels里则表示每一个索引列每个位置上对应的是levels相应列表里的第几个元素。

    我们用这种方式,重新来构建一个带有多维索引的Series类型数据:

    import pandas as pd

    import numpy as np

    index = [('California', 2008), ('California', 2018),

    ('New York', 2008), ('New York', 2018),

    ('Texas', 2008), ('Texas', 2018)]

    mul_index = pd.MultiIndex.from_tuples(index)

    population = [33870000, 37250000,

    18970000, 19370000,

    20850000, 25140000]

    pop = pd.Series(population, index=mul_index)

    print(pop)

    California 2008 33870000

    2018 37250000

    New York 2008 18970000

    2018 19370000

    Texas 2008 20850000

    2018 25140000

    dtype: int64

    在结果中,我们可以看到,前面两列表示Series的多级索引,第三列是我们的数据,那么回到刚刚的问题,如果此时我们想获取2018年的所有数据,做法就相当简单了:

    print(pop[:, 2018])

    California 37250000

    New York 19370000

    Texas 25140000

    dtype: int64

    简简单单用二维的切片方式就可以处理了。

    【妹子说】二维的Series,怎么感觉和DataFrame其实是一回事儿呢?

    没错,其实我们把其中的一维索引放到行的位置上,可不就成了一个普通的二维DataFrame对象嘛,而且Pandas里还提供了方法让这二者互相转化。我们还是沿用上面的二维Series对象pop来举个例子:

    df_pop = pop.unstack()

    print(df_pop)

    print(df_pop.stack())

    2008 2018

    California 33870000 37250000

    New York 18970000 19370000

    Texas 20850000 25140000

    California 2008 33870000

    2018 37250000

    New York 2008 18970000

    2018 19370000

    Texas 2008 20850000

    2018 25140000

    dtype: int64

    unstack( )方法可以使一个带有多级索引的Series转化为一个普通的DataFrame对象,而stack( )方法实现的则是相反方向的操作。

    【妹子说】既然二维Sereis可以用DataFrame来表示,那干嘛还要费劲去了解这个多级索引?

    很简单,因为还有更高维的数据,既然我们可以用一维Sereis来表示二维的数据,那么也可以用Sereis、DataFrame来表示三维甚至是更高维的数据。

    比如,我们要表示上述三个州,2008/2018,总人口/18岁以下的人口,我们看到这是三维信息了,怎么样,是不是最终还是逃不掉多级索引?

    这次我们使用DataFrame来表示三级索引,用我们之前讲过的DataFrame构造的方法,用字典列表来进行构造:

    import pandas as pd

    import numpy as np

    index = [('California', 2008), ('California', 2018),

    ('New York', 2008), ('New York', 2018),

    ('Texas', 2008), ('Texas', 2018)]

    mul_index = pd.MultiIndex.from_tuples(index)

    population = [33870000, 37250000,18970000, 19370000, 20850000, 25140000]

    under_18_pop = [9267089, 9284094, 4687374, 4318033, 5906301, 6879014]

    pop = pd.Series(population, index=mul_index)

    pop_df = pd.DataFrame({'total':pop,

    'under18':under_18_pop})

    print(pop_df)

    total under18

    California 2008 33870000 9267089

    2018 37250000 9284094

    New York 2008 18970000 4687374

    2018 19370000 4318033

    Texas 2008 20850000 5906301

    2018 25140000 6879014

    这种有多级索引的DataFrame,同样也是运用类似pop_df['total]这种字典键的形式来获取列信息。

    print(pop_df['under18'])

    print(pop_df['under18']/pop_df['total'])

    California 2008 9267089

    2018 9284094

    New York 2008 4687374

    2018 4318033

    Texas 2008 5906301

    2018 6879014

    Name: under18, dtype: int64

    California 2008 0.273608

    2018 0.249237

    New York 2008 0.247094

    2018 0.222924

    Texas 2008 0.283276

    2018 0.273628

    dtype: float64

    我们还可以看出,在含有多级索引的Series和DataFrame数据类型中,除了多级索引之外,其他的包括创建、数据访问等部分的操作都是一样的。

    因此最核心的就是多级索引的创建,下面我们来总结一下几种常见的创建的方法:

    第一种方式,我们提供一个嵌套列表,其中每一个元素都是一个列表,分别对应一个完整的索引列表。

    import pandas as pd

    import numpy as np

    mul_index = pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'],[1,2,1,2]])

    print(mul_index)

    MultiIndex(levels=[['a', 'b'], [1, 2]],

    labels=[[0, 0, 1, 1], [0, 1, 0, 1]])

    第二种是我们前面用过的,利用一个元组列表来生成多级索引,其中每一个元组都表示多级索引中一一对应的两项:

    import pandas as pd

    import numpy as np

    mul_index = pd.MultiIndex.from_tuples([('a', 1), ('a', 0), ('b', 1), ('b', 0)])

    print(mul_index)

    MultiIndex(levels=[['a', 'b'], [0, 1]],

    labels=[[0, 0, 1, 1], [1, 0, 1, 0]])

    第三种方式是直接传入levels和labels标签进行构造:

    import pandas as pd

    import numpy as np

    mul_index = pd.MultiIndex(levels=[['a', 'b'], [0, 1]],

    labels=[[0, 0, 1, 1], [1, 0, 1, 0]])

    print(mul_index)

    MultiIndex(levels=[['a', 'b'], [0, 1]],

    labels=[[0, 0, 1, 1], [1, 0, 1, 0]])

    第四种是一种所谓“相乘”的形式,写法上比较简单,实现两两索引按顺序分别组合:

    import pandas as pd

    import numpy as np

    mul_index = pd.MultiIndex.from_product([[2008,2018],[1,2]])

    print(mul_index)

    MultiIndex(levels=[[2008, 2018], [1, 2]],

    labels=[[0, 0, 1, 1], [0, 1, 0, 1]])

    为了更清晰的表征每一个索引列,我们可以给每一个索引都加一个名字:

    pop = pd.Series(population, index=mul_index)

    pop.index.names = ['state', 'year']

    print(pop)

    state year

    California 2008 33870000

    2018 37250000

    New York 2008 18970000

    2018 19370000

    Texas 2008 20850000

    2018 25140000

    dtype: int64

    【妹子说】之前我们举的几个例子都是行索引,那列索引应该也可以是多级的吧。

    当然,我们可以设置二维列索引,结合之前的二维行索引,我们就可以表示四维数据了。我们看下面的这个例子:

    import pandas as pd

    import numpy as np

    index = pd.MultiIndex.from_product([[2008,2018],[1,2]],

    names=['year','visit'])

    colomus = pd.MultiIndex.from_product([['Tom','Bill'],[22,18]],

    names=['name','age'])

    data = np.random.randn(4,4)

    df_data = pd.DataFrame(data,index=index,columns=colomus)

    print(df_data)

    name Tom Bill

    age 22 18 22 18

    year visit

    2008 1 -1.225804 -0.363311 0.098241 -1.318783

    2 0.456561 -1.049426 0.407306 -1.014973

    2018 1 2.178388 -0.491357 1.184801 0.341740

    2 -2.536552 -0.351532 -0.233742 -0.164102

    【妹子说】这样一来,在行方向和列方向上,都存在多级索引,那么如何通过索引实现对DataFrame值的访问呢?

    恩,多级索引的取值问题是一个重点,不过今天的内容已经够多啦,这个内容我们下一集慢慢再说。

    展开全文
  • 我想知道为什么存在通过键访问多级索引系列的行的功能,但是对于 dataframe 却不存在.例如,我有以下 dataframe :index_1 index_2 num_1 num_20 a c 1 21 a c 4 32 a c 3 43 a d ...

    我想知道为什么存在通过键访问多级索引系列的行的功能,但是对于 dataframe 却不存在.

    例如,我有以下 dataframe :

    index_1 index_2 num_1 num_2

    0 a c 1 2

    1 a c 4 3

    2 a c 3 4

    3 a d 2 3

    4 b d 3 1

    5 b d 2 3

    我现在执行如下的groupby操作:

    group_single_col = test.groupby(['index_1', 'index_2'])['num_1'].max()

    我这样做没有问题:

    group_single_col[('a')]

    要么

    group_single_col[('a', 'c')]

    这是一个了不起的功能,使我可以基于不同索引级别的值进行切片.

    但是,如果我进行groupby并提取多个列,如下所示:

    group_double_col = test.groupby(['index_1', 'index_2'])[['num_1', 'num_2]].max()

    返回的对象是一个DataFrame,尽管实现了多级索引,但操作类似于:

    group_double_col[('a')]

    失败.

    我知道在第一种情况下返回了一系列,而在第二种情况下返回了一个 dataframe ,但是我仍然认为该功能应该可以很好地与 dataframe 一起使用.

    后续问题是,对于 dataframe ,有什么解决方法?

    目前,我正在:

    grouped[(grouped.index.get_level_values('index_1')=='a')]

    但我想知道是否有更有效的方法.

    展开全文
  • L = [[ 1 , 4 , 7, 10], [ 2 , 5 , 8 ], [ 3 , 6 , 9, 12], [ 5 , 5 , 5 , 5 ,20]] max_len = max(len(item) for item in L) H=[] for item in L: if len(item) < max_len: item.extend([None] * (max_len ...
  • pop = pd.Series(populations, index=index) #用元组创建一个多级索引 index = pd.MultiIndex.from_tuples(index) #如果将前面创建的 pop 的索引重置(reindex)为 MultiIndex,就会看到层级索引 pop = pop.reindex...
  • 透视表 下面这种话在用透视表做去重计算的时候很常见 df_pivot = pd.pivot_table(df,index = 'name', columns = 'first', values = 'value', aggfunc = {'value':'unique'}) 但容易出现下面的情况: ...
  • 第1关:多级索引的取值与切片 任务描述 本关任务:根据相关知识以及编程要求,得到目标DataFrame多级索引。 相关知识 创建多级索引 通过MultiIndex构建多级索引: index = [('California', 2000), ('California', ...
  • 首先了解一下什么是多级索引,以及它的作用,为什么要有这个玩意。多级索引也称为层次化索引(hierarchical indexing),是指数据在一个轴上(行或者列)拥有多个(两个以上)索引级别。之所以引入多级索引,在于它可以使...
  • python多级索引修改

    2021-08-27 09:45:24
    创建多级索引 cols = pd.MultiIndex.from_tuples([("a","b"), ("a","c")]) pd.DataFrame([[1,2], [3,4]], columns=cols) a b c 0 1 2 1 3 4 df.columns = df.columns....
  • 1.带多级索引的Series数据类型 2.多级索引Series对象和DataFrame对象的相互转化 3.带多级索引的DataFrame数据类型 4.多级索引的创建方法 5.多级行索引和多级列索引举例 1.多级索引的Series类型 之前的几集里,我们...
  • python多级索引要写入excel表格,想要去除索引和空行,可以使用set_column和set_row删除不想要的列和行。 ws = pd.ExcelWriter(os.path.join(os.path.abspath(""), "test.xlsx")) self.main_item_result.to_excel(ws...
  • 话不多说,直接上答案 import pandas as pd from sklearn import datasets def demo1(): data = datasets.load_linnerud().data # ********** Begin **********# index=pd.MultiIndex.from_product([['A','B','...
  • C{1,2} ans = 1×3 100 200 300 通过追加索引,并使用与内容的数据类型匹配的语法,来访问元胞的部分内容。 使用圆括号将数值索引括起来。例如,C{1,1} 返回一个 1×3 数值向量 [1 2 3]。使用圆括号访问该向量的...
  • Clustered and Secondary Indexes(聚集索引和二级索引)Every InnoDB table has a special index called the clustered index where the data for the rows is stored. Typically, the clustered index is synonymous...
  • 1.Pandas数据类型多级索引的取值方法 2.Pandas数据类型多级索引的分片方法 3.多级Series与DataFrame的转换 4.多级DataFrame的行列统计 接着上一集,说说多级索引下Pandas数据类型的取值方法。 1.多级索引的Series ...
  • C{1,2} ans = 1×3 100 200 300 通过追加索引,并使用与内容的数据类型匹配的语法,来访问元胞的部分内容。 使用圆括号将数值索引括起来。例如,C{1,1} 返回一个 1×3 数值向量 [1 2 3]。使用圆括号访问该向量的第...
  • 二、多级索引 1. 多级索引及其表的结构 为了更加清晰地说明具有多级索引的 DataFrame 结构,下面新构造一张表,读者可以忽略这里的构造方法,它们将会在第4小节被更详细地讲解。 In [70]: np.random.seed(0) In [71...
  • 两种基本索引类型:1、顺序索引:文件记录基于某个值的顺序排序。 2、散列索引:根据散列函数和某个值,将文件记录平均分布到各个散列桶中。 1、聚合索引:数据文件记录的存储顺序,是按照某个搜索码指定的顺序存储...
  • 第5章 索引:Index对象、MultiIndex对象。 第6章 数据读写操作:读写Excel文件、读写CSV文件。 第7章 数据操作:算术运算、描述性统计方法、函数应用、排序。 第8章 项目实战:搜狐证券股票数据分析。 前置课程:
  • pandas索引(2)多层索引

    2020-12-22 12:14:20
    多级索引及其表的结构 In [67]: np.random.seed(0) In [68]: multi_index = pd.MultiIndex.from_product([list('ABCD'), ....: df.Gender.unique()], names=('School', 'Gender')) ....: In [69]: multi_column...
  • MySQL创建索引

    2021-01-28 02:04:34
    mysql的数据索引我们开发的时候一定都会用到,比如我们的主键、唯一等这些都是有到索引的内容,但是如果只有这样的索引在我们的实际开发中肯定满足不了我们的需求,这个时候就需要我们来创建相关的索引,但是索引...
  • MySQL 索引结构

    2021-01-19 02:23:16
    谈到 MYSQL 索引服务端的同学应该是熟悉的不能再熟悉,新建表的时候怎么着都知道先来个主键索引,对于经常查询的列也会加个索引加快查询速度。那么 MYSQL 索引都有哪些类型呢?索引结构是什么样的呢?有了索引是如何...
  • 有的伙伴想学用Pandas做多层级索引,但不知道从何学起,难度肯定会有的,还是得掌握方法的!Pandas库的名字来源于其中3种主要数据结构开头字母的缩写:Panel,Dataframe,Series。其中Series表示一维数据,Dataframe...
  • 首先讲讲根据行列索引的查询 import pandas as pd import numpy as np df = pd.DataFrame(np.random.randint(50, 100, size=(4, 4)), columns=pd.MultiIndex.from_product( [['math', 'physics'], ['term1', '...
  • dataframe 中的多层索引

    2021-01-16 13:41:14
    1、生成两层行索引、列索引的样本数据 1)生成 DataFrame import pandas as pd import numpy as np pd.set_option('display.max_columns', 1000) pd.set_option('display.width', 1000) pd.set_option('display.max...
  • 连接文件:是指向同一索引节点的那些目录条目。用ls来查看是,连接文件的标志用l开头,而文件面后以"->"指向所连接的文件。 ? 特殊文件:LINUX的一些设备如磁盘、终端、打印机等都在文件系统中表示出来,则一类文件...
  • 在Pandas中使用pivot_table做聚合运算后,计算出来的结果具有多层次索引。 import pandas as pd sku_store=data10.pivot_table(index=["item_num","vender_name"],columns="period",values=["store_name"],aggfunc=...
  • 聚簇索引的优缺点

    2021-02-02 04:33:08
    聚簇索引并不是一种单独的索引类型,而是一种数据存储方式.比较常用的就是 InnoDB 中的聚簇索引,它实际上是在同一结构中保存了 B-tree 索引和数据行.也就是说一个表的数据实际存放在索引的叶子页中.Mysql(InnoDB)中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,229
精华内容 12,491
关键字:

多级索引