美文网首页我爱编程
【Chapter 5.2】Pandas的基本功能

【Chapter 5.2】Pandas的基本功能

作者: 蜘蛛的梦呓 | 来源:发表于2018-05-23 19:46 被阅读0次

    【5.2 Essential Functionality(主要功能)】

    接下来介绍pandas中的一些主要功能,这里只介绍一些经常用到的。

    1 Reindexing(重新索引)

    pandas对象的一个重要方法是reindex,其作用是创建一个新对象,它的数据符合新的索引。看下面的例子:

    obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
    
    obj
    Out[104]: 
    d    4.5
    b    7.2
    a   -5.3
    c    3.6
    dtype: float64
    

    用该Series的reindex将会根据新索引进行重排。如果某个索引值当前不存在,就引入缺失值:

    obj2 = obj.reindex(['a','b','c','d','e'])
    
    obj2
    Out[106]: 
    a   -5.3
    b    7.2
    c    3.6
    d    4.5
    e    NaN
    dtype: float64
    

    对于时间序列这样的有序数据,重新索引时可能需要做一些插值处理。method选项即可达到此目的,例如,使用ffill可以实现前向值填充:

    In [95]: obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
    
    In [96]: obj3
    Out[96]: 
    0      blue
    2    purple
    4    yellow
    dtype: object
    
    In [97]: obj3.reindex(range(6), method='ffill')
    Out[97]: 
    0      blue
    1      blue
    2    purple
    3    purple
    4    yellow
    5    yellow
    dtype: object
    

    借助DataFrame,reindex可以修改(行)索引和列。只传递一个序列时,会重新索引结果的行:

    
    frame = pd.DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['Ohio', 'Texas', 'California'])
    
    frame
    Out[113]: 
       Ohio  Texas  California
    a     0      1           2
    c     3      4           5
    d     6      7           8
    
    frame2 = frame.reindex(['a','b','c','d'])
    
    frame2
    Out[115]: 
       Ohio  Texas  California
    a   0.0    1.0         2.0
    b   NaN    NaN         NaN
    c   3.0    4.0         5.0
    d   6.0    7.0         8.0
    

    列可以用columns关键字重新索引:

    states = ['Texas','Utah','California']
    
    frame.reindex(columns=states)
    Out[118]: 
      Texas  Utah  California
    a      1   NaN           2
    c      4   NaN           5
    d      7   NaN           8
    

    表5-3列出了reindex函数的各参数及说明。

    还可以使用loc更简洁的reindex:

    frame.loc[['a', 'b', 'c', 'd'], states]
        Texas  Utah  California
    a    1.0   NaN         2.0
    b    NaN   NaN         NaN
    c    4.0   NaN         5.0
    d    7.0   NaN         8.0
    

    2. Dropping Entries from an Axis (按轴删除记录)

    丢弃某条轴上的一个或多个项很简单,只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑,所以drop回返回一个新的object,并删去你制定的axis的值:

    obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
    
    obj
    Out[122]: 
    a    0.0
    b    1.0
    c    2.0
    d    3.0
    e    4.0
    dtype: float64
    
    new_obj = obj.drop('c')
    
    new_obj
    Out[124]: 
    a    0.0
    b    1.0
    d    3.0
    e    4.0
    dtype: float64
    

    对于DataFrame,可以删除任意轴上的索引值。为了演示,先新建一个DataFrame例子:

    
    data = pd.DataFrame(np.arange(16).reshape(4, 4),
                        index=['Ohio', 'Colorado', 'Utah', 'New York'],
                        columns=['one', 'two', 'three', 'four'])
    data
                        
    Out[127]: 
              one  two  three  four
    Ohio        0    1      2     3
    Colorado    4    5      6     7
    Utah        8    9     10    11
    New York   12   13     14    15
    

    行处理:如果a sequence of labels(一个标签序列)来调用drop,会删去row labels(axis 0):

    data.drop(['Colorado', 'Ohio'])
    Out[128]: 
              one  two  three  four
    Utah        8    9     10    11
    New York   12   13     14    15
    

    列处理:drop列的话,设定axis=1或axis='columns':

    data.drop('two', axis=1)
    Out[129]: 
              one  three  four
    Ohio        0      2     3
    Colorado    4      6     7
    Utah        8     10    11
    New York   12     14    15
    
    data.drop('two', axis='columns')
    Out[130]: 
              one  three  four
    Ohio        0      2     3
    Colorado    4      6     7
    Utah        8     10    11
    New York   12     14    15
    

    drop也可以不返回一个新的object,而是直接更改series or dataframe in-place:

    obj.drop('c', inplace=True)
    
    obj
    Out[132]: 
    a    0.0
    b    1.0
    d    3.0
    e    4.0
    dtype: float64
    

    3. Indexing, Selection, and Filtering(索引,选择,过滤)

    series indexing(obj[...]) 相当于numpy的array indexing, 只不过Series的索引值不只是整数 :

    obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
    
    obj
    Out[137]: 
    a    0.0
    b    1.0
    c    2.0
    d    3.0
    dtype: float64
    
    obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
    
    obj
    Out[137]: 
    a    0.0
    b    1.0
    c    2.0
    d    3.0
    dtype: float64
    
    obj['b']
    Out[138]: 1.0
    
    obj[1]
    Out[139]: 1.0
    
    obj[2:4]
    Out[140]: 
    c    2.0
    d    3.0
    dtype: float64
    
    obj[0]
    Out[141]: 0.0
    
    obj[['b', 'a', 'd']]
    Out[142]: 
    b    1.0
    a    0.0
    d    3.0
    dtype: float64
    
    obj[[1, 3]]
    Out[143]: 
    b    1.0
    d    3.0
    dtype: float64
    
    obj[obj < 2]
    Out[144]: 
    a    0.0
    b    1.0
    dtype: float64
    

    用label来slicing(切片)的时候,和python的切片不一样的在于,会包括尾节点:

    obj['b':'d']
    Out[146]: 
    b    1.0
    c    2.0
    d    3.0
    dtype: float64
    

    用切片可以对Series的相应部分进行设置:

    obj['b':'c']=5
    
    obj
    Out[151]: 
    a    0.0
    b    5.0
    c    5.0
    d    3.0
    dtype: float64
    

    用一个值或序列对DataFrame进行索引其实就是获取一个或多个列:

    data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                        index=['Ohio', 'Colorado', 'Utah', 'New York'],
                        columns=['one', 'two', 'three', 'four'])
    data
                        
    Out[153]: 
              one  two  three  four
    Ohio        0    1      2     3
    Colorado    4    5      6     7
    Utah        8    9     10    11
    New York   12   13     14    15
    
    In [130]: data['two']
    Out[130]: 
    Ohio         1
    Colorado     5
    Utah         9
    New York    13
    Name: two, dtype: int64
    
    In [131]: data[['three', 'one']]
    Out[131]: 
              three  one
    Ohio          2    0
    Colorado      6    4
    Utah         10    8
    New York     14   12
    
    

    选取行的语法data[:2]十分方便。向[ ]传递单一的元素或列表,就可选择列。

    另一种用法是通过布尔型DataFrame(比如下面这个由标量比较运算得出的)进行索引:

    data
    Out[155]: 
              one  two  three  four
    Ohio        0    1      2     3
    Colorado    4    5      6     7
    Utah        8    9     10    11
    New York   12   13     14    15
    
    data<5
    Out[156]: 
                one    two  three   four
    Ohio       True   True   True   True
    Colorado   True  False  False  False
    Utah      False  False  False  False
    New York  False  False  False  False
    
    data[data<5] = 0
    
    data
    Out[158]: 
              one  two  three  four
    Ohio        0    0      0     0
    Colorado    0    5      6     7
    Utah        8    9     10    11
    New York   12   13     14    15
    

    这使得DataFrame的语法与NumPy二维数组的语法很像。

    用loc和iloc来选择

    对于DataFrame的行的标签索引,我引入了特殊的标签运算符loc和iloc。它们可以让你用类似NumPy的标记,使用轴标签(loc)或整数索引(iloc),从DataFrame选择行和列的子集。

    作为一个初步示例,让我们通过标签选择一行和多列:

    data.loc['Colorado',['two','three']]
    Out[159]: 
    two      5
    three    6
    Name: Colorado, dtype: int32
    

    然后用iloc和整数进行选取:

    data.iloc[2, [3, 0, 1]]
    Out[161]: 
    four    11
    one      8
    two      9
    Name: Utah, dtype: int32
    
    data.iloc[2]#行
    Out[162]: 
    one       8
    two       9
    three    10
    four     11
    Name: Utah, dtype: int32
    
    data.iloc[[1, 2], [3, 0, 1]]
    Out[163]: 
              four  one  two
    Colorado     7    0    5
    Utah        11    8    9
    

    这两个索引函数也适用于一个标签或多个标签的切片:

    In [141]: data.loc[:'Utah', 'two']
    Out[141]: 
    Ohio        0
    Colorado    5
    Utah        9
    Name: two, dtype: int64
    
    In [142]: data.iloc[:, :3][data.three > 5]
    Out[142]: 
              one  two  three
    Colorado    0    5      6
    Utah        8    9     10
    New York   12   13     14
    

    所以,在pandas中,有多个方法可以选取和重新组合数据。对于DataFrame,表5-4进行了总结。后面会看到,还有更多的方法进行层级化索引。

    注意:当设计padnas的时候,作者发现frame[:, col]这样的语法是比较冗长的,因为这是会被经常用到的一个功能。作者把一些indexing的功能(lable or integer)集成在了ix这个方法上。实际中,因为这种label和integer都可以用的方式很方便,于是pandas team设计了loc和ilco来实现label-based和integer-based indexing.

    虽然ix indexing依然存在,但是已经过时,不推荐使用。

    4. Integer Indexes(整数索引)

    一些新手再用integer来index的时候,总是会被绊倒。因为这种方法和python用于list和tuple的indexing方法不同。

    比如,你不希望下面的代码出现error:

    ser = pd.Series(np.arange(3.))
    ser
    ser[-1]
    

    这里,pandas可以勉强进行整数索引,但是会导致小bug。我们有包含0,1,2的索引,但是引入用户想要的东西(基于标签或位置的索引)很难:

    In [144]: ser
    Out[144]: 
    0    0.0
    1    1.0
    2    2.0
    dtype: float64
    

    另外,对于非整数索引,不会产生歧义:

    In [145]: ser2 = pd.Series(np.arange(3.), index=['a', 'b', 'c'])
    
    In [146]: ser2[-1]
    Out[146]: 2.0
    

    为了保持连贯性,如果axis index里包含integer,那么选择数据的时候,就会是label-orented. 为了更精确地选择,使用loc(for label)或ilco(for integers):

    In [147]: ser[:1]
    Out[147]: 
    0    0.0
    dtype: float64
    
    In [148]: ser.loc[:1]
    Out[148]: 
    0    0.0
    1    1.0
    dtype: float64
    
    In [149]: ser.iloc[:1]
    Out[149]: 
    0    0.0
    dtype: float64
    
    

    5. 算数和数据对齐

    pandas一个有用的feature就是,不同index的obejct之间的算数计算。如果两个object相加,但他们各自的index并不相同,最后结果得到的index是这两个index的合集:

    
    s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])
    
    s2 = pd.Series([2.1, 3.6, -1.5, 4, 3.1], index=['a', 'c', 'e', 'f', 'g'])
    
    s1,s2
    Out[171]: 
    (a    7.3
     c   -2.5
     d    3.4
     e    1.5
     dtype: float64, a    2.1
     c    3.6
     e   -1.5
     f    4.0
     g    3.1
     dtype: float64)
    
    s1 + s3
    
    s1 + s2
    Out[173]: 
    a    9.4
    c    1.1
    d    NaN
    e    0.0
    f    NaN
    g    NaN
    dtype: float64
    

    这种数据对齐的方式(internal data alignment)引入了很多缺失值在没有陈赫的位置上。这些缺失值会被用在之后的算数计算中。

    在DataFrame中,数据对齐同时发生在行和列上:

    
    df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
                       index=['Ohio', 'Texas', 'Colorado'])
                       
    
    df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                       index=['Utah', 'Ohio', 'Texas', 'Oregon'])
                       
    
    df1
    Out[177]: 
                b    c    d
    Ohio      0.0  1.0  2.0
    Texas     3.0  4.0  5.0
    Colorado  6.0  7.0  8.0
    
    df2
    Out[178]: 
              b     d     e
    Utah    0.0   1.0   2.0
    Ohio    3.0   4.0   5.0
    Texas   6.0   7.0   8.0
    Oregon  9.0  10.0  11.0
    
    
    df1 + df2
    Out[179]: 
                b   c     d   e
    Colorado  NaN NaN   NaN NaN
    Ohio      3.0 NaN   6.0 NaN
    Oregon    NaN NaN   NaN NaN
    Texas     9.0 NaN  12.0 NaN
    Utah      NaN NaN   NaN NaN
    

    因为'c'和'e'列都不在两个DataFrame里,所有全是缺失值。对于行,即使有相同的,但列不一样的话也会是缺失值。

    如果DataFrame对象相加,没有共用的列或行标签,结果都会是空:

    In [160]: df1 = pd.DataFrame({'A': [1, 2]})
    
    In [161]: df2 = pd.DataFrame({'B': [3, 4]})
    
    In [162]: df1
    Out[162]: 
       A
    0  1
    1  2
    
    In [163]: df2
    Out[163]: 
       B
    0  3
    1  4
    
    In [164]: df1 - df2
    Out[164]: 
        A   B
    0 NaN NaN
    1 NaN NaN
    
    

    在算术方法中填充值

    在对不同索引的对象进行算术运算时,你可能希望当一个对象中某个轴标签在另一个对象中找不到时填充一个特殊值(比如0):

    df1 = pd.DataFrame({'A': [1, 2]})
    
    df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)), 
                       columns=list('abcd'))
    
    df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)), 
                       columns=list('abcde'))
    
    df2.loc[1, 'b'] = np.nan
    
    
    df1
    Out[182]: 
         a    b     c     d
    0  0.0  1.0   2.0   3.0
    1  4.0  5.0   6.0   7.0
    2  8.0  9.0  10.0  11.0
    
    df2
    Out[183]: 
          a     b     c     d     e
    0   0.0   1.0   2.0   3.0   4.0
    1   5.0   NaN   7.0   8.0   9.0
    2  10.0  11.0  12.0  13.0  14.0
    3  15.0  16.0  17.0  18.0  19.0
    

    使用fill_value:

    df1.add(df2, fill_value=0)
    Out[184]: 
          a     b     c     d     e
    0   0.0   2.0   4.0   6.0   4.0
    1   9.0   5.0  13.0  15.0   9.0
    2  18.0  20.0  22.0  24.0  14.0
    3  15.0  16.0  17.0  18.0  19.0
    

    下表中就有很多这样灵活的算数方法:

    img

    与此类似,在对Series或DataFrame重新索引时,也可以指定一个填充值:

    In [174]: df1.reindex(columns=df2.columns, fill_value=0)
    Out[174]: 
         a    b     c     d  e
    0  0.0  1.0   2.0   3.0  0
    1  4.0  5.0   6.0   7.0  0
    2  8.0  9.0  10.0  11.0  0
    
    

    6. Function Application and Mapping (函数应用和映射)

    numpy的ufuncs(element-wise数组方法)也能用在pandas的object上:

    frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), 
                         index=['Utah', 'Ohio', 'Texas', 'Oregon'])
    frame
                         
    Out[186]: 
                   b         d         e
    Utah    0.810787 -0.033742  0.453338
    Ohio    1.943699 -1.217804  0.986678
    Texas  -0.755921 -1.377585  0.380717
    Oregon -1.696865  0.232021  1.687488
    
    np.abs(frame)
    Out[187]: 
                   b         d         e
    Utah    0.810787  0.033742  0.453338
    Ohio    1.943699  1.217804  0.986678
    Texas   0.755921  1.377585  0.380717
    Oregon  1.696865  0.232021  1.687488
    

    另一个常用的操作是把一个用在一维数组上的函数,应用在一行或一列上。要用到DataFrame中的apply函数:

    f = lambda x: x.max() - x.min()
    frame.apply(f)
    
    Out[188]: 
    b    3.640564
    d    1.609605
    e    1.306771
    dtype: float64
    

    这里函数f,计算的是一个series中最大值和最小值的差,在frame中的每一列,这个函数被调用一次。作为结果的series,它的index就是frame的column。

    如果你传入axis='column'用于apply,那么函数会被用在每一行:

    frame.apply(f, axis='columns')
    Out[189]: 
    Utah      0.844529
    Ohio      3.161503
    Texas     1.758302
    Oregon    3.384353
    dtype: float64
    

    像是sum, mean这样的数组统计方法,DataFrame中已经集成了,所以没必要用apply。

    apply不会返回标量,只会返回一个含有多个值的series:

    def f(x): 
        return pd.Series([x.min(), x.max()], index=['min', 'max'])
    
    
    frame
    Out[191]: 
                   b         d         e
    Utah    0.810787 -0.033742  0.453338
    Ohio    1.943699 -1.217804  0.986678
    Texas  -0.755921 -1.377585  0.380717
    Oregon -1.696865  0.232021  1.687488
    
    frame.apply(f)
    Out[192]: 
                b         d         e
    min -1.696865 -1.377585  0.380717
    max  1.943699  0.232021  1.687488
    

    element-wise的python函数也能用。假设想要格式化frame中的浮点数,变为string。可以用apply map:

    format = lambda x: '%.2f' % x
    
    frame.applymap(format)
    Out[195]: 
                b      d     e
    Utah     0.81  -0.03  0.45
    Ohio     1.94  -1.22  0.99
    Texas   -0.76  -1.38  0.38
    Oregon  -1.70   0.23  1.69
    

    applymap的做法是,series有一个map函数,能用来实现element-wise函数:

    frame['e'].map(format)
    Out[196]: 
    Utah      0.45
    Ohio      0.99
    Texas     0.38
    Oregon    1.69
    Name: e, dtype: object
    

    7. Sorting and Ranking (排序)

    按row或column index来排序的话,可以用sort_index方法,会返回一个新的object:

    obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
    
    obj
    Out[200]: 
    d    0
    a    1
    b    2
    c    3
    dtype: int64
    
    obj.sort_index()
    Out[201]: 
    a    1
    b    2
    c    3
    d    0
    dtype: int64
    

    在DataFrame,可以用index或其他axis来排序:

    frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
                         index=['three', 'one'],
                         columns=['d', 'a', 'b', 'c'])
    frame
                         
    Out[202]: 
           d  a  b  c
    three  0  1  2  3
    one    4  5  6  7
    
    frame.sort_index(axis=1)#升序
    Out[203]: 
           a  b  c  d
    three  1  2  3  0
    one    5  6  7  4
    
    frame.sort_index(axis=1, ascending=False) #降序
    Out[204]: 
           d  c  b  a
    three  0  3  2  1
    one    4  7  6  5
    

    通过值来排序,用sort_values方法:

    obj = pd.Series([4, 7, -3, 2])
    
    obj
    Out[209]: 
    0    4
    1    7
    2   -3
    3    2
    dtype: int64
    
    obj.sort_values()
    Out[210]: 
    2   -3
    3    2
    0    4
    1    7
    dtype: int64
    

    缺失值会被排在最后:

    obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
    obj.sort_values()
    
    Out[211]: 
    4   -3.0
    5    2.0
    0    4.0
    2    7.0
    1    NaN
    3    NaN
    dtype: float64
    

    对于一个DataFrame,可以用一列或多列作为sort keys。这样的话,只需要把一列多多列的名字导入到sort_values即可:

    frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
    frame
    
    Out[213]: 
       a  b
    0  0  4
    1  1  7
    2  0 -3
    3  1  2
    
    frame.sort_values(by='b')
    Out[214]: 
       a  b
    2  0 -3
    3  1  2
    0  0  4
    1  1  7
    

    多列排序的话,传入一个list of names:

    
    frame.sort_values(by='b')
    Out[214]: 
       a  b
    2  0 -3
    3  1  2
    0  0  4
    1  1  7
    

    ranking(排名)是给有效的数据分配数字。rank方法能用于series和DataFrame,rank方法默认会给每个group一个mean rank(平均排名)。rank 表示在这个数在原来的Series中排第几名,有相同的数,取其排名平均(默认)作为值:

    obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
    obj
    
    Out[217]: 
    0    7
    1   -5
    2    7
    3    4
    4    2
    5    0
    6    4
    dtype: int64
    
    obj.sort_values()
    Out[218]: 
    1   -5
    5    0
    4    2
    3    4
    6    4
    0    7
    2    7
    dtype: int64
    
    obj.rank()
    Out[219]: 
    0    6.5
    1    1.0
    2    6.5
    3    4.5
    4    3.0
    5    2.0
    6    4.5
    dtype: float64
    

    在obj中,4和4的排名是第4名和第五名,取平均得4.5。7和7的排名分别是第六名和第七名,则其排名取平均得6.5。

    rank也可以根据数据被观测到的顺序来设定:

    obj
    Out[221]: 
    0    7
    1   -5
    2    7
    3    4
    4    2
    5    0
    6    4
    dtype: int64
    
    obj.rank(method='first')
    Out[222]: 
    0    6.0
    1    1.0
    2    7.0
    3    4.0
    4    3.0
    5    2.0
    6    5.0
    dtype: float64
    

    这里没有给0和2(指两个数字7)赋予average rank 6.5,而是给第一个看到的7(label 0)设置rank为6,第二个看到的7(label 2)设置rank为7。

    也可以设置降序:

    
    obj.rank(ascending=False, method='max')
    Out[223]: 
    0    2.0
    1    7.0
    2    2.0
    3    4.0
    4    5.0
    5    6.0
    6    4.0
    dtype: float64
    

    dataframe 可以根据行或列来计算rank:

    frame = pd.DataFrame({'b': [4.3, 7, -3, 2],
                          'a': [0, 1, 0, 1],
                          'c': [-2, 5, 8, -2.5]})
    frame
                          
    Out[224]: 
       a    b    c
    0  0  4.3 -2.0
    1  1  7.0  5.0
    2  0 -3.0  8.0
    3  1  2.0 -2.5
    
    frame.rank(axis='columns') # columns表示列与列之间的排序(即每一行里数据间的排序)
    Out[225]: 
         a    b    c
    0  2.0  3.0  1.0
    1  1.0  3.0  2.0
    2  2.0  1.0  3.0
    3  2.0  3.0  1.0
    
    img

    8. 带有重复标签的轴索引

    直到目前为止,我所介绍的所有范例都有着唯一的轴标签(索引值)。虽然许多pandas函数(如reindex)都要求标签唯一,但这并不是强制性的。我们来看看下面这个简单的带有重复索引值的Series:

    In [222]: obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
    
    In [223]: obj
    Out[223]: 
    a    0
    a    1
    b    2
    b    3
    c    4
    dtype: int64
    
    

    索引的is_unique属性可以告诉你它的值是否是唯一的:

    In [224]: obj.index.is_unique
    Out[224]: False
    

    对于带有重复值的索引,数据选取的行为将会有些不同。如果某个索引对应多个值,则返回一个Series;而对应单个值的,则返回一个标量值:

    In [225]: obj['a']
    Out[225]: 
    a    0
    a    1
    dtype: int64
    
    In [226]: obj['c']
    Out[226]: 4
    

    这样会使代码变复杂,因为索引的输出类型会根据标签是否有重复发生变化。

    对DataFrame的行进行索引时也是如此:

    In [227]: df = pd.DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])
    
    In [228]: df
    Out[228]: 
              0         1         2
    a  0.274992  0.228913  1.352917
    a  0.886429 -2.001637 -0.371843
    b  1.669025 -0.438570 -0.539741
    b  0.476985  3.248944 -1.021228
    
    In [229]: df.loc['b']
    Out[229]: 
              0         1         2
    b  1.669025 -0.438570 -0.539741
    b  0.476985  3.248944 -1.021228
    
    

    相关文章

      网友评论

        本文标题:【Chapter 5.2】Pandas的基本功能

        本文链接:https://www.haomeiwen.com/subject/csddjftx.html