精华内容
下载资源
问答
  • Pandas MultiIndex 详解

    千次阅读 2019-10-28 15:55:09
    什么是MultiIndex2.1 levels和codes的意义 1. 什么是Index   学习MultiIndex前,首先要看一下Index。   Index是DataFrame的索引,如下代码生成一个DataFrame。 frame_index = pd.DataFrame(np.arange(6)....

    1. 什么是Index

      学习MultiIndex前,首先要看一下Index。
      Index是DataFrame的索引,如下代码生成一个DataFrame。

    frame_index =  pd.DataFrame(np.arange(6).reshape((2,3)), index=['a','b'],
                         columns=['Ohio', 'Ohio', 'Colorado'])
    frame_index
    
    OhioOhioColorado
    a012
    b345
    frame_index.index
    
    Index(['a', 'b'], dtype='object')
    

      可以看到index就一层‘a’和‘b’。

    frame_index.columns
    
    Index(['Ohio', 'Ohio', 'Colorado'], dtype='object')
    

      columns也是一个index,只不过表示列而已。

    2. 什么是MultiIndex

      MultiIndex顾名思义是多级索引,看一下多级索引的DataFrame生成如下:

    frame = pd.DataFrame(np.arange(12).reshape((4,3)), index=[['a', 'a', 'b', 'b'], [1,2,1,2]],
                         columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
    frame					 
    
    OhioColorado
    GreenRedGreen
    a1012
    2345
    b1678
    291011
    frame.index
    
    MultiIndex(levels=[['a', 'b'], [1, 2]],
               codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
    

      可以看到当选择frame.index时候,对象变成了MultiIndex,这是因为MultiIndex是Index的一个子类,当DataFrame的index索引传入多列表时,自动构建多级索引,那么不禁要问levels和codes的意义?

    2.1 levels和codes的意义

      levels和codes是为了确定多级索引的对应关系

    1. levels的第一级列表[‘a’,‘b’],对应codes的[0,0,1,1],codes中是0代表’a’的位置,1代表‘b’的位置。
    2. leves的第二级列表[1,2],对应codes的[0,1,0,1],codes中的0代表1的位置,1代表2的位置。
      两级位置确定后,根据codes位置标识绘制如下:
      在这里插入图片描述

      这个表格恰恰是frame的index对应关系,我们的解读是正确的。
      columns同理,这里不再赘述了。

      注意:在pandas version 0.24.0之前,codes用labels来表示的,意义相同。

    展开全文
  • 主要介绍了Pandas之MultiIndex对象的示例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • pandas:MultiIndex对象

    2019-09-28 09:51:05
    分层/多级索引非常令人兴奋,因为它为一些非常复杂的数据分析和操作提供了可能性,特别是对于处理更...MultiIndex对象是标准Index对象的扩展, 你可以将MultiIndex视为元组构成的列表,其中每个元组都是唯一的, 它与I...

    分层/多级索引非常令人兴奋,因为它为一些非常复杂的数据分析和操作提供了可能性,特别是对于处理更高维度的数据。从本质上讲,它使你能在较低维度的数据结构(如Series(1d)和DataFrame(2d))中存储和操作具有任意数量维度的数据。

    创建MultiIndex

    MultiIndex对象是标准Index对象的扩展, 你可以将MultiIndex视为元组构成的列表,其中每个元组都是唯一的, 它与Index的区别是, Index可以视为数字或者字符串构成的列表。可以从数组列表(使用MultiIndex.from_arrays),元组列表(使用MultiIndex.from_tuples)或交叉迭代集(使用MultiIndex.from_product)创建MultiIndex。当构造函数传递元组列表时,它将尝试返回MultiIndex。以下示例演示了创建MultiIndexes的不同方法。

    from_tuples

    下面先创建一个元祖构成的列表

    arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
                ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
    
    tuples = list(zip(*arrays))
    print(tuples)
    '''
    [('bar', 'one'), ('bar', 'two'),
     ('baz', 'one'), ('baz', 'two'), 
     ('foo', 'one'), ('foo', 'two'), 
     ('qux', 'one'), ('qux', 'two')]
    
    '''
    

    使用from_tuples来创建MultiIndex:

    index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
    print(index)
    '''
    MultiIndex([('bar', 'one'),
                ('bar', 'two'),
                ('baz', 'one'),
                ('baz', 'two'),
                ('foo', 'one'),
                ('foo', 'two'),
                ('qux', 'one'),
                ('qux', 'two')],
               names=['first', 'second'])
    '''
    

    from_arrays

    如果说from_tuples接受的参数是””的列表, 那么 from_arrays接受的参数是就是””的列表:

    arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
                ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
    
    index = pd.MultiIndex.from_arrays(arrays)
    s = pd.Series(np.random.randn(8), index=index)
    print(s)
    '''
    bar  one   -0.268434
         two   -0.026027
    baz  one   -0.658945
         two    0.283218
    foo  one    1.054412
         two    1.977076
    qux  one   -0.563627
         two   -0.156421
    dtype: float64
    '''
    

    不过为了简便, 我们通常可以直接在Series的构造函数中使用:

    arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
                ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
    
    s = pd.Series(np.random.randn(8), index=arrays)
    print(s)
    '''
    bar  one   -1.411561
         two    0.667025
    baz  one   -0.079449
         two   -0.715518
    foo  one   -1.844785
         two    0.257104
    qux  one   -0.776653
         two   -1.159284
    dtype: float64
    '''
    

    from_product

    假如我们有两个list, 这两个list内的元素相互交叉, 两两搭配, 这就是两个list的product:

    lists = [['bar', 'baz', 'foo', 'qux'], ['one', 'two']]
    
    index = pd.MultiIndex.from_product(lists, names=['first', 'second'])
    s = pd.Series(np.random.randn(len(index)), index=index)
    print(s)
    '''
    first  second
    bar    one      -1.309958
           two       0.379085
    baz    one       0.739266
           two      -0.165164
    foo    one      -0.022698
           two      -0.006190
    qux    one       0.299748
           two      -0.864639
    dtype: float64
    '''
    
    MultiIndex.names

    你可以为MultiIndex的各个层起名字, 这就是names属性:

    print(s.index.names)
    #['first', 'second']
    
    s.index.names = ['FirstLevel', 'SecondLevel']
    print(s.index.names)
    #['FirstLevel', 'SecondLevel']
    

    MultiIndex可以作为列名称

    Series和DataFrame的列名称属性就是columns, 也可以是一个MultiIndex对象:

    df = pd.DataFrame(np.random.randn(3, 8), index=['A', 'B', 'C'], columns=index)
    print(df)
    '''
    FirstLevel        bar                 baz  ...       foo       qux          
    SecondLevel       one       two       one  ...       two       one       two
    A            1.127256  1.453003  0.025833  ... -1.258916  0.711659 -1.460118
    B            1.589573  2.057785  0.028412  ... -1.678021 -0.662083 -1.044907
    C           -0.879705  0.730224 -0.003296  ... -0.446753 -1.694061  1.440663
    
    [3 rows x 8 columns]
    '''
    

    获取各水平的值

    方法get_level_values将返回特定级别的每个位置的标签向量

    print(index.get_level_values(0))
    '''
    Index(['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
     dtype='object', name='FirstLevel')
    
    '''
    

    如果你给index设置了名称, 那么你可以直接使用名称来获取水平值:

    print(index.get_level_values('FirstLevel'))
    '''
    Index(['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
     dtype='object', name='FirstLevel')
    
    '''
    

    选择数据

    这可能是MultiIndex最重要的功能之一。

    print(df)
    '''
    FirstLevel        bar                 baz  ...       foo       qux          
    SecondLevel       one       two       one  ...       two       one       two
    A            1.134195 -0.351198  0.218614  ... -0.755923  0.129988 -0.052183
    B           -0.308971  1.399584 -0.894162  ... -1.022070  0.045872  1.539032
    C           -0.399760  0.351285  1.069002  ... -0.771437  2.350300 -0.922563
    
    [3 rows x 8 columns]
    '''
    

    获取FirstLevel是bar的所有数据

    print(df['bar'])
    '''
    SecondLevel       one       two
    A            0.204079  0.635272
    B            1.691298 -0.449358
    C           -1.236855 -1.144767
    '''
    

    获取FirstLevel是bar, SecondLevel是one的所有数据:

    A   -0.494211
    B   -0.051951
    C   -0.606048
    Name: (bar, one), dtype: float64
    

    这样来用, 意义更明确:

    print(df['bar']['one'])
    '''
    A    0.121725
    B    1.130435
    C   -0.011153
    Name: one, dtype: float64
    '''
    

    需要注意的是, 结果选择输出的结果的columns已经改变:

    
    print(df['bar'].columns)
    #Index(['one', 'two'], dtype='object', name='SecondLevel')
    

    如果你要选择第二层的列名为one的所有数据, 你需要借助xs方法:

    print(df.xs('bar', level=0, axis=1))
    '''
    SecondLevel       one       two
    A           -1.493262 -0.704469
    B            3.509268 -1.283146
    C           -0.056974  0.710284
    '''
    print(df.xs('one', level=1, axis=1))
    '''
    FirstLevel       bar       baz       foo       qux
    A           0.537299 -1.054771  0.144664 -0.940659
    B          -0.560000 -0.952308 -1.667759 -1.480754
    C           0.733805  0.930315 -0.144840 -1.261983
    '''
    

    或者使用名称代替数字:

    print(df.xs('one', level='SecondLevel', axis='columns'))
    '''
    FirstLevel       bar       baz       foo       qux
    A           0.537299 -1.054771  0.144664 -0.940659
    B          -0.560000 -0.952308 -1.667759 -1.480754
    C           0.733805  0.930315 -0.144840 -1.261983
    '''
    

    xs, 它不仅可以用来选择列, 也可以用来选择行:

    print(s)
    '''
    FirstLevel  SecondLevel
    bar         one            1.262375
                two            0.211678
    baz         one           -0.207278
                two            0.386925
    foo         one           -0.010342
                two           -1.775980
    qux         one           -0.981227
                two           -2.159368
    dtype: float64
    '''
    
    print(s.xs('one', level='SecondLevel', axis='index'))
    '''
    FirstLevel
    bar    0.783906
    baz    1.159497
    foo   -1.361565
    qux   -0.838874
    dtype: float64
    '''
    

    选择行

    下面我们把df进行转置, 然后看看一些选择行的操作:

    df = df.T
    print(df)
    '''
                                   A         B         C
    FirstLevel SecondLevel                              
    bar        one          0.923159  3.412767 -2.821506
               two          2.641013  0.229025  1.251807
    baz        one          0.900035  0.874848  0.246452
               two         -1.326872  0.647462 -0.088361
    foo        one          1.730885 -0.732980 -0.373840
               two         -1.369826 -1.532940 -0.204242
    qux        one          0.305318  0.929807 -0.331868
               two          1.110960 -0.869984  0.990428
    '''
    

    选择FirstLevel是bar, SecondLevel是two的数据:

    print(df.loc[('bar', 'two')])
    '''
    A   -0.096414
    B    0.796829
    C   -0.571624
    Name: (bar, two), dtype: float64
    '''
    

    多重索引的标签要一元组的形式('bar', 'two'),不能是列表的形式['bar', 'two']

    print(df.loc[['bar', 'two']])
    '''
                                   A         B         C
    FirstLevel SecondLevel                              
    bar        one         -0.918643 -1.125853 -0.885147
               two         -0.810740 -0.759485  0.822972
    '''
    

    下面的用法是等效的:

    print(df.loc['bar'].loc['two'])
    '''
    A   -0.755750
    B    0.387714
    C    1.164027
    Name: two, dtype: float64
    '''
    

    选择行的同时也能选择列:

    print(df.loc[('bar', 'two'), 'A'])
    #-0.5189738423458226
    

    还能使用切片操作:

    print(df.loc['baz': 'foo'])
    '''
                                   A         B         C
    FirstLevel SecondLevel                              
    baz        one         -1.507232 -0.207591  1.242952
               two         -0.424180 -1.741234 -1.205756
    foo        one          0.858520  1.594259 -1.314260
               two         -0.711255  0.356851 -0.276307
    '''
    

    或许, 使用更多的是这样:

    print(df.loc[('bar', 'two'): ('baz', 'two')])
    '''
    FirstLevel SecondLevel                              
    bar        two         -1.293961 -0.931613  0.090003
    baz        one         -0.509716 -0.802122  1.583681
               two         -0.613451  0.121745  0.895646
    '''
    

    当然, 推荐使用xs, 它可以使你的代码更容易被别人理解, 而且选择行和列都用统一的方式:

    print(df.xs('two', level='SecondLevel', axis='index'))
    '''
                       A         B         C
    FirstLevel                              
    bar        -1.201396 -2.257291  0.831497
    baz        -1.204905 -0.351232 -0.025386
    foo         0.987691 -0.454322  0.679079
    qux         0.813230  0.073436 -0.951928
    '''
    

    数据对齐

    如果你需要对数据进行运算, 那么设置好了index可以给你带来很多便利:

    print(s)
    '''
    FirstLevel  SecondLevel
    bar         one            0.653282
                two            2.213182
    baz         one            0.826812
                two           -1.987085
    foo         one           -0.785736
                two            0.494006
    qux         one            2.608325
                two            2.488264
    dtype: float64
    '''
    

    假设我们只需要对第二个元素之后的数据进行运算, 我们的pandas为我们做了按照index的自动数据对齐:

    print(s + s[2:])
    '''
    FirstLevel  SecondLevel
    bar         one                 NaN
                two                 NaN
    baz         one            1.291180
                two            2.123520
    foo         one            2.897265
                two            0.555278
    qux         one           -2.814526
                two           -4.069465
    dtype: float64
    '''
    

    或许下面这个看起来更有用:

    FirstLevel  SecondLevel
    bar         one            3.782157
                two                 NaN
    baz         one            0.876798
                two                 NaN
    foo         one           -0.756565
                two                 NaN
    qux         one            3.809493
                two                 NaN
    dtype: float64
    

    MultiIndex对象属性

    m_index1=pd.Index([("A","x1"),("A","x2"),("B","y1"),("B","y2"),("B","y3")],name=["class1","class2"])
    print(m_index1)
    '''
    MultiIndex([('A', 'x1'),
                ('A', 'x2'),
                ('B', 'y1'),
                ('B', 'y2'),
                ('B', 'y3')],
               names=['class1', 'class2'])
    '''
    df1=DataFrame(np.random.randint(1,10,(5,3)),index=m_index1)
    print(df1)
    '''
    class1 class2         
    A      x1      1  9  2
           x2      5  3  2
    B      y1      8  8  6
           y2      9  2  2
           y3      5  6  8
    '''
    m_index=df1.index
    print(m_index[0])
    #('A', 'x1')
    
    
    调用.get_loc().get_indexer()获取标签的下标:
    print(m_index.get_loc(("A","x2")))  #1
    print(m_index.get_indexer([("A","x2"),("B","y1"),"nothing"]))
    #[ 1  2 -1]
    
    
    MultiIndex对象使用多个Index对象保存索引中每一级的标签:
    print(m_index.levels[0])
    print(m_index.levels[1])
    '''
    Index(['A', 'B'], dtype='object', name='class1')
    Index(['x1', 'x2', 'y1', 'y2', 'y3'], dtype='object', name='class2')
    '''
    
    MultiIndex对象还有属性labels保存标签的下标:
    print(m_index.labels[0])
    print(m_index.labels[1])
    '''
    [0 0 1 1 1]
    [0 1 2 3 4]
    '''
    
    展开全文
  • Pandas详解四之MultiIndex对象

    万次阅读 多人点赞 2018-03-16 13:03:24
    约定 import pandas as pd ...MultiIndex表示多级索引,它是从Index继承过来的,其中多级标签用元组对象来表示。 一、创建MultiIndex对象 创建方式一:元组列表 m_index1=pd.Index([("...
    约定 
    
    import pandas as pd
    from pandas import DataFrame
    import numpy as np

    MultiIndex

    MultiIndex表示多级索引,它是从Index继承过来的,其中多级标签用元组对象来表示。

    一、创建MultiIndex对象

    • 创建方式一:元组列表
    m_index1=pd.Index([("A","x1"),("A","x2"),("B","y1"),("B","y2"),("B","y3")],name=["class1","class2"])
    m_index1

    代码结果:

    MultiIndex(levels=[['A', 'B'], ['x1', 'x2', 'y1', 'y2', 'y3']],
               labels=[[0, 0, 1, 1, 1], [0, 1, 2, 3, 4]],
               names=['class1', 'class2'])
    
    df1=DataFrame(np.random.randint(1,10,(5,3)),index=m_index1)
    df1
    代码结果:
    012
    class1class2
    Ax1748
    x2452
    By1697
    y2216
    y3686
    • 创建方式二:特定结构

    例如**from_arrays()

    class1=["A","A","B","B"]
    class2=["x1","x2","y1","y2"]
    m_index2=pd.MultiIndex.from_arrays([class1,class2],names=["class1","class2"])
    m_index2

    代码结果:

    MultiIndex(levels=[['A', 'B'], ['x1', 'x2', 'y1', 'y2']],
               labels=[[0, 0, 1, 1], [0, 1, 2, 3]],
               names=['class1', 'class2'])
    
    df2=DataFrame(np.random.randint(1,10,(4,3)),index=m_index2)
    df2
    
    代码结果:
    012
    class1class2
    Ax1245
    x2359
    By1712
    y2318
    • c创建方式三:笛卡尔积

    from_product()从多个集合的笛卡尔积创建MultiIndex对象。

    m_index3=pd.MultiIndex.from_product([["A","B"],['x1','y1']],names=["class1","class2"])
    m_index3

    代码结果:

    MultiIndex(levels=[['A', 'B'], ['x1', 'y1']],
               labels=[[0, 0, 1, 1], [0, 1, 0, 1]],
               names=['class1', 'class2'])
    
    df3=DataFrame(np.random.randint(1,10,(2,4)),columns=m_index3)
    df3
    代码结果:
    class1AB
    class2x1y1x1y1
    02918
    15252

    二、MultiIndex对象属性

    df1
    代码结果:
    012
    class1class2
    Ax1748
    x2452
    By1697
    y2216
    y3686
    m_index4=df1.index
    print(in1[0])

    代码结果:

    ('A', 'x1')
    
    • 调用.get_loc().get_indexer()获取标签的下标:
    print(m_index4.get_loc(("A","x2")))
    print(m_index4.get_indexer([("A","x2"),("B","y1"),"nothing"]))
    

    代码结果:

    1
    [ 1  2 -1]
    
    • MultiIndex对象使用多个Index对象保存索引中每一级的标签:
    print(m_index4.levels[0])
    print(m_index4.levels[1])

    代码结果:

    Index(['A', 'B'], dtype='object', name='class1')
    Index(['x1', 'x2', 'y1', 'y2', 'y3'], dtype='object', name='class2')
    
    • MultiIndex对象还有属性labels保存标签的下标:
    print(m_index4.labels[0])
    print(m_index4.labels[1])

    代码结果:

    FrozenNDArray([0, 0, 1, 1, 1], dtype='int8')
    FrozenNDArray([0, 1, 2, 3, 4], dtype='int8')
    

    谢谢大家的浏览,
    希望我的努力能帮助到您,
    共勉!

    展开全文
  • 今天小编就为大家分享一篇对Pandas MultiIndex(多重索引)详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Pandas的MultiIndex多层索引使用

    千次阅读 2020-01-09 16:27:13
    MultiIndex多层索引 1.创建方式 1.1.第一种:多维数组 1.2.第二种:MultiIndex 1.3.创建案例: 2.多层索引操作 2.1.Series多层索引 2.2.DataFrame多层索引 2.3.交换索引 2.4.索引排序 2.5.索引堆叠 2.6....

    目录

    MultiIndex多层索引

    1.创建方式

    1.1.第一种:多维数组

    1.2.第二种:MultiIndex

    1.3.创建案例:

    2.多层索引操作

    2.1.Series多层索引

    2.2.DataFrame多层索引

    2.3.交换索引

    2.4.索引排序

    2.5.索引堆叠

    2.6.取消堆叠

    2.7.设置索引

    2.8.重置索引


    MultiIndex多层索引

    MultiIndex,即具有多个层次的索引,有些类似于根据索引进行分组的形式。通过多层次索引,我们就可以使用高层次的索引,来操作整个索引组的数据。通过给索引分类分组,则可以操作组数据。

    1.创建方式

    1.1.第一种:多维数组

    我们在创建Series或DataFrame时,可以通过给index(columns)参数传递多维数组,进而构建多维索引。
    【数组中每个维度对应位置的元素,组成每个索引值】

    多维索引也可以设置名称(name性),属性的值为一维数组,元素的个数需要与索引的层数相同(每层索引都需要具有一个名称)。

    1.2.第二种:MultiIndex

    我们可以通过MultiIndex类的相关方法,预先创建一个MultiIndex对象,然后作为Series与DataFrame中的index(或columns)参数值。同时,可以通过names参数指定多层索引的名称。

    • from_arrays:接收一个多维数组参数,高维指定高层索引,低维指定底层索引。
    • from_tuples:接收一个元组的列表,每个元组指定每个索引(高维索引,低维索引)。
    • from_product:接收一个可迭代对象的列表,根据多个可迭代对象元素的笛卡尔积进行创建索引。

    from_product相对于前两个方法而言,实现相对简单,但是,也存在局限。

    1.3.创建案例:

    import numpy as np
    import pandas as pd

    import warnings
    warnings.filterwarnings('ignore')

    #通过给index(columns)参数传递多维数组,进而构建多维索引

    # 多层索引,指定一个多维数组。多维数组中,逐级给出每层索引的值。
    s = pd.Series([1, 2, 3, 4], index=[["A", "A", "B", "B"], ["a", "b", "c", "d"]])
    # 多于多层索引,每一层都具有一个名字。
    s.index.names = ["index1", "index2"]
    display(s)
    display(s.loc["A"].loc["a"])

    df=pd.DataFrame(np.arange(9).reshape(3, 3), columns=[["X", "X", "Y"], ["x1", 'x2', 'y1']],index=[["A", "B", "B"], ["a", 'a', 'b']])
    display(df)
    display(df.loc["B"]) 
    display(df["X"])
    display(df.loc["B"].loc["a"]["X"]["x1"])

    #通过MultiIndex类的方法进行创建。

    # 通过列表的方式进行创建。(每个内嵌列表元素指定层次的索引,[[第0层索引], [第1层索引],……[第n层索引]])
    array1=pd.MultiIndex.from_arrays([["A","A","B"],["a","b","a"]])
    df=pd.DataFrame(np.random.rand(3,3),index=array1)
    display(df)

    # 通过元组构成列表的方式进行创建。[(高层,底层), (高层, 底层), ……]
    tuple1 = pd.MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "a")])
    df2 = pd.DataFrame(np.random.random((3, 3)), index=tuple1)
    display(df2)

    # 通过乘积(笛卡尔积)的方式进行创建。
    product1 = pd.MultiIndex.from_product([["A", "B"], ["a", "b"]])
    df3 = pd.DataFrame(np.random.random((4, 3)), index=product1)
    display(df3)

     

    2.多层索引操作

    对于多层索引,同样也支持单层索引的相关操作,例如,索引元素,切片,索引数组选择元素等。我们也可以根据多级索引,按层次逐级选择元素。

    多层索引的优势:通过创建多层索引,我们就可以使用高层次的索引,来操作整个索引组的数据。格式:

    • s[操作]
    • s.loc[操作]
    • s.iloc[操作]

    其中,操作可以是索引,切片,数组索引,布尔索引。

    2.1.Series多层索引

    • 通过loc(标签索引)操作,可以通过多层索引,获取该索引所对应的一组值。
    • 通过iloc(位置索引)操作,会获取对应位置的元素值(与是否多层索引无关)。
    • 通过s[操作]的行为有些诡异,建议不用。
      • 对于索引(单级),首先按照标签选择,如果标签不存在,则按照位置选择。
      • 对于多级索引,则按照标签进行选择。
      • 对于切片,如果提供的是整数,则按照位置选择,否则按照标签选择。
      • 对于数组索引, 如果数组元素都是整数,则根据位置进行索引,否则,根据标签进行索引。

    2.2.DataFrame多层索引

    • 通过loc(标签索引)操作,可以通过多层索引,获取该索引所对应的一组值。
    • 通过iloc(位置索引)操作,会获取对应位置的一行(与是否多层索引无关)。
    • 通过s[操作]的行为有些诡异,建议不用。
      • 对于索引,根据标签获取相应的列(如果是多层索引,则可以获得多列)。
      • 对于数组索引, 根据标签,获取相应的列(如果是多层索引,则可以获得多列)。
      • 对于切片,首先按照标签进行索引,然后再按照位置进行索引(取行)。

    2.3.交换索引

    df.swaplevel(i=-2, j=-1, axis=0)

    我们可以调用DataFrame对象的swaplevel方法来交换两个层级索引。该方法默认对倒数第2层与倒数第1层进行交换。我们也可以指定交换的层。层次从0开始,由外向内递增(或者由上到下递增),也可以指定负值,负值表示倒数第n层。除此之外,我们也可以使用层次索引的名称来进行交换。

    df = pd.DataFrame(np.random.rand(4, 4), index=[["A", "A", "B", "B"], ["a1", "a1", "b1", "c1"], ["a2", "b2", "c2", "c2"]])
    df.index.names = ["layer1", "layer2", "layer3"]
    display(df)

    # 多层索引,编号从外向内,0, 1, 2, 3.同时,索引编号也支持负值。
    # 负值表示从内向外,-1, -2, -3. -1表示最内层。
    display(df.swaplevel())  #默认对倒数第2层与倒数第1层进行交换
    display(df.swaplevel(0, 2))
    # 交换多层索引时,我们除了可以指定层次的编号外,也可以指定索引层次的名称。
    display(df.swaplevel("layer1", "layer3"))

     

    2.4.索引排序

    我们可以使用sort_index方法对索引进行排序处理。

    Signature: df.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
    • level:指定根据哪一层进行排序,默认为最外(上)层。该值可以是数值,索引名,或者是由二者构成的列表。
    • inplace:是否就地修改。默认为False。

    display(df.sort_index())  #默认索引排序

    # 自定义排序的层次。
    display(df.sort_index(level=1))
    display(df.sort_index(level=2))

    # 也可以通过索引的名称进行排序。
    display(df.sort_index(level="layer1"))
    display(df.sort_index(level="layer2"))

    2.5.索引堆叠

    通过DataFrame对象的stack方法,可以进行索引堆叠,即将指定层级的列转换成行。 level:指定转换的层级,默认为-1。

    # 进行堆叠  列->行      取消堆叠   行->列
    df.stack()                     df.unstack()

    2.6.取消堆叠

    通过DataFrame对象的unstack方法,可以取消索引堆叠,即将指定层级的行转换成列。 level:指定转换的层级,默认为-1。 fill_value:指定填充值。默认为NaN。

    df = pd.DataFrame(np.random.rand(4, 4), index=[["A", "B", "B", "A"], ["b", "b", "a", "c"], ["b2", "c2", "a2", "c2"]])
    df.index.names = ["layer1", "layer2", "layer3"]
    display(df)

    # 取消堆叠,如果没有匹配的数据,则显示空值NaN。
    display(df.unstack())

    # 我们可以指定值去填充NaN(空值)。
    df.unstack(fill_value=11)

    # unstack默认会将最内层取消堆叠,我们也可以自行来指定层次。
    display(df.unstack(0))

    # 进行堆叠  列->行      取消堆叠   行->列
    df.stack()              # df.unstack()
    # stack堆叠也可以指定层次。
    # stack堆叠也可以通过索引名进行操作。
    df.stack(0)

    2.7.设置索引

    在DataFrame中,如果我们需要将现有的某一(几)列作为索引列,可以调用set_index方法来实现。

    Signature: df.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)
    
    • drop:是否丢弃作为新索引的列,默认为True。
    • append:是否以追加的方式设置索引,默认为False。
    • inplace:是否就地修改,默认为False。

    df = pd.DataFrame({"pk":[1, 2, 3, 4], "age":[15, 20, 17, 8], "name":["n1", "n2", "n3", "n4"]})
    display(df)

    df1 = df.set_index("pk", drop=False)
    display(df1)

    2.8.重置索引

    调用在DataFrame对象的reset_index,可以重置索引。该操作与set_index正好相反。

    Signature: df.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
    • level:重置索引的层级,默认重置所有层级的索引。如果重置所有索引,将会创建默认整数序列索引。
    • drop:是否丢弃重置的索引列,默认为False。
    • inplace:是否就地修改,默认为False。

    df = pd.DataFrame({"pk":[1, 2, 3, 4], "age":[15, 20, 17, 8], "name":["n1", "n2", "n3", "n4"]})
    #display(df)

    df1 = df.set_index("pk", drop=False)
    #display(df1)
    df2 = df1.reset_index(0, drop=True)
    display(df2)

    展开全文
  • 主要介绍了详解pandas中MultiIndex和对象实际索引不一致问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 今天小编就为大家分享一篇在pandas多重索引multiIndex中选定指定索引的行方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • pandas multiindex使用方法 使用代码如下: import pandas as pd import numpy as np m_index = pd.MultiIndex.from_product([[i for i in range(2016,2020)],['一季度','中报','三季度','年报']],names = ['year',...
  • Pandas中multiindex转换成列

    千次阅读 2018-09-10 14:59:25
    Multiindex格式如下:(a, b, c, ...), index column (a1,b1,c1) d1 (a2,b2,c2) d2 直接调用函数reset_index(),Multiindex中(a, b, c, ...)就变成columns了,index重置为(0,1,2,...), 如下: ...
  • pandas multiIndex

    千次阅读 2015-07-26 08:54:38
    In [1]: arrays = [[’bar’, ’bar’, ’baz’, ’baz’, ’foo’, ’foo’, ’qux’, ’qux’], ...: [’one’, ’two’, ’one’, ’two’, ’one’, ’two’, ’one’, ’two’]] ...In [4]: index = MultiIndex
  • pandas中对dataframe进行groupby+统计操作后会生成MultiIndex 如对df4的'prod_label_name2'进行聚合后,对'm_up_flow'列进行describe操作 df55=df4.groupby(['prod_label_name2'])[['m_up_flow']].describe()....
  • 理解pd.MultiIndex.from_product

    千次阅读 2020-08-24 21:22:25
    classmethod MultiIndex.from_product(iterables, sortorder=None,names=<object object>) Make a MultiIndex from the cartesian product of multiple iterables. Parameters iterable : list/sequence ...
  • pandas层次性索引MultiIndex变化操作需求背景问题求解 手动反爬虫:原博地址 知识梳理不易,请尊重劳动成果,文章仅发布在CSDN网站上,在其他网站看到该博文均属于未经作者授权的恶意爬取信息 如若转载,请标明...
  • 选取 DataFrame 使用正常的 loc 或 iloc 索引数据,但是对于 Multiindex 层次化索引该怎么索引数据呢?
  • 在pandas多重索引multiIndex中选定指定索引的行

    万次阅读 多人点赞 2018-05-07 22:55:33
    multiIndex中选定指定索引的行 我们在用pandas类似groupby来使用多重index时,有时想要对多个level中的某个index对应的行进行操作,就需要在dataframe中找到该index对应的行,在单层index中我们可以方便的使用df....
  • import pandas as pdimport numpy as npfrom pandas import DataFrame, Series ...mIndex = pd.MultiIndex(levels=[['One','Two'],['a','b']],labels=[[0,0,1,1],[0,1,0,1]])frame=DataFrame(np.random.randn(4,4...
  • pandas教程[9]MultiIndex用法

    万次阅读 2018-08-16 11:49:29
    #在pandas的DataFrame中经常使用多个索引,在pandas中成为MultiIndex对象,这篇文章介绍一下MultiIndex创建和使用方法: import pandas as pd import numpy as np import pandas.util.testing as tm print ("1...
  • 文章目录获取数据Series的分层索引MultiIndexSeries有多层索引怎样筛选数据?DataFrame的多层索引MultiIndexDataFrame有多层索引...Series的分层索引MultiIndex   使用之前的多key索引,得到如下结果:   可以看
  • 3.1.4 Multiindex与Panel 1. Multiindex 多级或分层索引对象 index的属性: names:levels的名称 levels:每个level的元组值 new_df.index new_df.index.levels new_df.index.names MultiIndex([(2012, 1), ...
  • MultiIndex MultiIndex,即具有多个层次的索引,有些类似于根据索引进行分组的形式。通过多层次索引,我们就可以使用高层次的索引,来操作整个索引组的数据。 创建方式 第一种 我们在创建Series或DataFrame时,可以...
  • MultiIndex MultiIndex,即具有多个层次的索引,有些类似于根据索引进行分组的形式。通过多层次索引,我们就可以使用高层次的索引,来操作整个索引组的数据。 创建方式 第一种 我们在创建Series或DataFrame时,...
  • Pandas详解十三之多级索引MultiIndex(层次化索引)

    万次阅读 多人点赞 2018-04-24 21:36:29
    约定: import pandas as pd import numpy as np ...多级索引(也称层次化索引)是pandas...实质上,单级索引对应Index对象,多级索引对应MultiIndex对象。 一、Series对象的多级索引 多级索引Series对象的创...
  • pandas numpy multiIndex python
  • Pandas 读取Excel并设定n列做MultiIndex

    千次阅读 2018-10-18 10:35:53
    Pandas 读取Excel并设定n列做MultiIndex #读取数据 import pandas as pd import numpy as np import glob,os path=r'e:\tj\month\fx1809' file=glob.glob(os.path.join(path, "zk*09.xls")) print(file)...
  • 1 import pandas as pd 2 import numpy as np 多级索引 多级索引(也称层次化索引...实质上,单级索引对应Index对象,多级索引对应MultiIndex对象。 一、Series对象的多级索引 多级索引Series对象的创建 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,567
精华内容 46,226
关键字:

multiindex