DataFrame索引操作、切片选取、条件过滤、赋值

索引操作

1. 修改索引顺序

reindex(index=[ ],columns=[ ],method,fill_value,copy)
根据传入的列表顺序对DataFrame重新索引，并返回一个新DataFrame，不影响原DataFrame。若传入列表中的值在原索引中并不存在，则在DataFrame的对应位置插入值为NaN的行/列。若只传入一个列表且未指定参数名，默认修改index即行索引。建议加入参数名以免混淆。
method 若原索引是有序序列，则对缺失的值按method指定的方法进行填充，ffill 向前填充，bfill 向后填充
fill_value 对于缺失值的替代值

In [1]: import numpy as np

In [2]: import pandas as pd

In [3]: data=pd.DataFrame([[0,1,2],[3,4,5],[6,7,8]],index=['a','c','d'],columns=['A','B','C'])

In [4]: data
Out[4]: 
   A  B  C
a  0  1  2
c  3  4  5
d  6  7  8

# 传入参数没指定参数名，且只有一列序列，默认对行索引进行修改，若索引值不存在则置NaN
In [6]: data.reindex(['c','a','b','d'])
Out[6]: 
     A    B    C
c  3.0  4.0  5.0
a  0.0  1.0  2.0
b  NaN  NaN  NaN
d  6.0  7.0  8.0

# 建议加上参数名，以免产生错误
In [7]: data.reindex(index=['a','b','c','d'],columns=['B','C','D','A'])
Out[7]: 
     B    C   D    A
a  1.0  2.0 NaN  0.0
b  NaN  NaN NaN  NaN
c  4.0  5.0 NaN  3.0
d  7.0  8.0 NaN  6.0

2. 修改索引值

如果只要修改索引值，而不改变DataFrame数据的顺序，可以直接对index columns 属性进行赋值，传入的列表大小必须和DataFrame的索引长度相同。该操作直接修改原DataFrame。

In [10]: data.index=list('xyz')

In [11]: data.columns=list('XYZ')

In [12]: data
Out[12]: 
   X  Y  Z
x  0  1  2
y  3  4  5
z  6  7  8

3. 删除索引

drop(axis=0,index,columns,inplace=False) 删除传入的索引项，返回新的DataFrame
axis 指定删除哪个轴上的索引，默认行索引axis=0或axis='index'，列索引为axis=1或axis='columns'
index columns 显式指定删除哪个轴的索引
inplace 默认False 返回新对象；True 直接修改原对象，无返回

In [13]: data.drop(['x'],axis=0) # 使用axis指定轴
Out[13]: 
   X  Y  Z
y  3  4  5
z  6  7  8

In [14]: data.drop(columns=['X','Z']) # 显式指定删除哪个轴的索引
Out[14]: 
   Y
x  1
y  4
z  7

In [15]: data.drop(['y','z'],inplace=True) # 直接修改对象，无返回

In [16]: data
Out[16]: 
   X  Y  Z

切片选取

1. 直接选取

对于DataFrame，使用一个值或序列进行索引，就是获取一个或多列
使用切片则获取指定的行，使用索引位置序号切片结果不包含末端索引，使用索引标签切片结果包含末端索引

In [17]: data=pd.DataFrame(np.arange(20).reshape(5,4),index=list('abcde'),columns=list('ABCD'))

In [18]: data
Out[18]: 
    A   B   C   D
a   0   1   2   3
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15
e  16  17  18  19

# 使用序列对列索引进行选择
In [23]: data[['A','C']]
Out[23]: 
    A   C
a   0   2
b   4   6
c   8  10
d  12  14
e  16  18

# 使用切片对行索引进行选择
# 对行索引的b~e（索引位置序号为1~4）进行切片，切片使用索引位置序号，结果不包含末端索引
In [24]: data[1:4]
Out[24]: 
    A   B   C   D
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15

# 使用索引标签切片结果包含末端索引，注意结果有e行
In [26]: data['b':'e']
Out[26]: 
    A   B   C   D
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15
e  16  17  18  19

# 行列结合进行选取
In [27]: data[['A','C']][:2]
Out[27]: 
   A  C
a  0  2
b  4  6

# 行列顺序不影响结果，切片就是选择行，值或序列就是选择列
In [28]: data[:2][['A','C']]
Out[28]: 
   A  C
a  0  2
b  4  6

注意：若索引的标签值是整数，在使用标签值进行索引选取的时候会造成混乱，比如要选取标签值为1的项目，使用data[1]，但得到的却是索引位置为1的项目。
因此若索引的标签值含有整数，在进行选取时应该总是使用标签。为了更准确，请使用loc（标签）或iloc（整数）。

2. 用loc和iloc进行选取

上面直接选取的方法中，对于列无法使用切片方式进行选取，而loc() iloc() 方法支持行和列使用切片方式选取
loc(行标签,列标签) 使用标签值选取
iloc(行序号,列序号) 使用索引位置进行选取

• 若参数指定的是多行和多列，得到的仍旧是DataFrame；
• 若参数里单独指定某一行或某一列，得到的是name为该行标签或该列标签的Series，但如果以列表形式指定某一行或某一列如[‘B’]，得到的是DataFrame；
• 若行列都指定某一个标签，得到的是指定位置的数据，类型即为该数据的数据类型
• loc使用标签切片包含末端项，iloc使用索引位置切片不包含末端项。

In [29]: data.loc['a'] # 选取行标签为'a'的行，得到一个name为行标签的Series
Out[29]: 
A    0
B    1
C    2
D    3
Name: a, dtype: int32

In [30]: data.loc[['a','c']] # 选取多行，得到DataFrame
Out[30]: 
   A  B   C   D
a  0  1   2   3
c  8  9  10  11

In [31]: data.loc[['a','c'],'B'] # 选取多行和指定的某一列，得到name为列标签的Series
Out[31]: 
a    1
c    9
Name: B, dtype: int32


In [32]: data.loc['a':'d','B':'D'] # 使用切片方式同时选取行和列
Out[32]: 
    B   C   D
a   1   2   3
b   5   6   7
c   9  10  11
d  13  14  15

In [33]: data.loc[:,'B':'D'] # 切片方式选择所有行和指定列
Out[33]: 
    B   C   D
a   1   2   3
b   5   6   7
c   9  10  11
d  13  14  15
e  17  18  19

In [34]: data.iloc[0:4,1:3] # iloc使用索引序号进行切片，不包含末端项
Out[34]: 
    B   C
a   1   2
b   5   6
c   9  10
d  13  14

条件过滤

1. 布尔运算

对DataFrame或切片选取的结果进行布尔运算，会得到一个格式与被运算对象完全相同的布尔型新对象

In [40]: data%3==0 # 判断元素是否是3的倍数，得到的新对象格式与data完全一样
Out[40]: 
       A      B      C      D
a   True  False  False   True
b  False  False   True  False
c  False   True  False  False
d   True  False  False   True
e  False  False   True  False

In [41]: data['B']>5 # data['B']是一个Series，因此运算结果也是一个Series
Out[41]: 
a    False
b    False
c     True
d     True
e     True
Name: B, dtype: bool

In [42]: data[['B','D']][:2]<3 # 前两行B,D列小于3
Out[42]: 
       B      D
a   True  False
b  False  False

# 使用loc或iloc选取结果也可以进行布尔运算，也可以将多个运算结果再次进行与或运算
In [48]: (data.loc[:,'B':'D']>5) & (data.loc[:,'B':'D']<10)
Out[48]: 
       B      C      D
a  False  False  False
b  False   True   True
c   True  False  False
d  False  False  False
e  False  False  False

2. 过滤

将布尔运算结果再次传入DataFrame中，会得到一个过滤后的新对象，对应位置为False的值均置NaN
注意：若对单列进行布尔运算如data['B']>5，结果是Series，传入DataFrame后会对行进行过滤，但若对单行进行布尔运算如data.loc['c']>10，得到的Series是不能进行过滤的

In [59]: data[data%3==0]
Out[59]: 
      A    B     C     D
a   0.0  NaN   NaN   3.0
b   NaN  NaN   6.0   NaN
c   NaN  9.0   NaN   NaN
d  12.0  NaN   NaN  15.0
e   NaN  NaN  18.0   NaN

In [60]: data[data['B']>5] # 对单列进行布尔运算，对行进行过滤
Out[60]: 
    A   B   C   D
c   8   9  10  11
d  12  13  14  15
e  16  17  18  19

In [71]: data[data[['B','D']][:2]<3]
Out[71]: 
    A    B   C   D
a NaN  1.0 NaN NaN
b NaN  NaN NaN NaN
c NaN  NaN NaN NaN
d NaN  NaN NaN NaN
e NaN  NaN NaN NaN

In [72]: data[(data.loc[:,'B':'D']>5) & (data.loc[:,'B':'D']<10)]
Out[72]: 
    A    B    C    D
a NaN  NaN  NaN  NaN
b NaN  NaN  6.0  7.0
c NaN  9.0  NaN  NaN
d NaN  NaN  NaN  NaN
e NaN  NaN  NaN  NaN

赋值

在进行切片选取和条件过滤时可以直接进行赋值，此时不返回新对象，而是直接修改原对象，对切片选取或条件过滤结果元素的对应位置进行赋值。

In [81]: data[(data.loc[:,'B':'D']>5) & (data.loc[:,'B':'D']<10)]='X'

In [82]: data
Out[82]: 
    A   B   C   D
a   0   1   2   3
b   4   5   X   X
c   8   X  10  11
d  12  13  14  15
e  16  17  18  19