宽客财经

关注微信公众号"宽客财经"，定时推送前沿、专业、深度的交易极客和量化投资资讯。

 找回密码
 免费注册
搜索
发布主题
返回列表 发新帖

【转】DataFrame数据选取超全攻略

0
回复 6438
查看 [复制链接]
gyshssl

196

主题

140

回帖

1444

积分

管理员

积分
1444
来源: 2019-7-23 22:30:22 显示全部楼层 |阅读模式

pandas库的DataFrame，作为一种非常强大的数据处理手段，一直以来无论是从整个库的API设计和性能，都给我非常大的惊喜，但是，在由生疏到慢慢熟练的过程中，发现在利用DataFrame时，一个最大的问题就是，如何高效优雅地选取到自己需要的数据，毕竟大部分时候我们是不需要整个DataFrame中的所有数据的。而为了遵循python语言本身的设计哲学，这些操作几乎都是利用原有的运算符，pandas只是进行了覆写，因而这些技能都像是隐藏的大招，难以发现和掌握，故特意花时间研究了一下官方文档，现总结如下，见笑。

1.属性选取

属性选取，顾名思义，也就是直接使用面向对象思想中对象的属性这一特性，以进行数据的选取，这里我们先创建一个示例的数据


  2. In [1]: import pandas as pd
  3. In [2]: import numpy as np
  4. In [3]: df = pd.DataFrame(np.random.randn(6, 6),
  5.    ...:                   index=[1, 2, 'C', 'D', '5', '6'],
  6.    ...:                   columns=['A', 'B', '3', '4', 5, 6])
复制代码

注意，这里我们构建了一个非常特殊的DataFrame，特别是在index和columns这两个参数，我们使用了三种分别明显的index，有int型的，字符串型两种，字符型里面又有数字和字母不一，且两者是没有冲突的，下面会演示这些index和columns都有啥坑（以下可能将index称为行名，columns称为列名）。

正常情况下，使用属性选取方式是非常简单的，直接访问对象属性即可

  1. In [4]: df.A
  2. Out[4]:
  3. 1    0.124010
  4. 2   -1.520924
  5. C   -1.941521
  6. D   -0.613758
  7. 5    0.788941
  8. 6    0.894871
  9. Name: A, dtype: float64
复制代码

而如果我们访问不存在的列，将会抛出AttributeError异常（为节约篇幅，以下错误演示去除了堆栈信息，仅保留异常信息，下同）

  1. In [5]: df.G
  2. AttributeError: 'DataFrame' object has no attribute 'G'
复制代码

当然，属性选取有非常大的局限性，首先，这种方法不能选取到行，只能选取到列

  1. In [6]: df.C
  2. AttributeError: 'DataFrame' object has no attribute 'C'
复制代码

其次就是其对于列名也有非常严格的要求,首先就是如果列名与Dataframe自带的方法、属性名一致的列都不能使用属性选取

  1. In [7]: df.min
  2. Out[7]:
  3. <bound method DataFrame.min of           A         B         3         4
  4. 5         6
  5. 1  0.124010 -1.160599 -1.236521 -2.356423  0.089117  1.090875
  6. 2 -1.520924 -0.285893  0.918261  1.250223  2.028298 -0.007042
  7. C -1.941521  0.716184  0.318086 -0.540593 -2.408134  0.526977
  8. D -0.613758  0.718741 -1.420655 -0.182436  0.333909 -1.608134
  9. 5  0.788941 -0.541419 -1.195019 -0.924797 -0.261171  1.078212
  10. 6  0.894871  0.454283 -0.763443  0.065712 -0.336119  0.182736>
复制代码

再次就是由于Python的命名规则，开头是数字的，或者带有其他非法符号的显然也不能使用属性选取


  1. In [8]: df.3
  2. SyntaxError: invalid syntax
复制代码

后，由于Python对象的动态特性，如果希望通过属性的方式添加一列，也是错误的

  1. In [9]: df.G = np.arange(6)
  2. In [10]: df
  3. Out[10]:
  4.           A         B         3         4         5         6
  5. 1  0.124010 -1.160599 -1.236521 -2.356423  0.089117  1.090875
  6. 2 -1.520924 -0.285893  0.918261  1.250223  2.028298 -0.007042
  7. C -1.941521  0.716184  0.318086 -0.540593 -2.408134  0.526977
  8. D -0.613758  0.718741 -1.420655 -0.182436  0.333909 -1.608134
  9. 5  0.788941 -0.541419 -1.195019 -0.924797 -0.261171  1.078212
  10. 6  0.894871  0.454283 -0.763443  0.065712 -0.336119  0.182736
  11. In [11]: df.G
  12. Out[11]: array([0, 1, 2, 3, 4, 5])
复制代码

可以看到，我们只是动态地给DataFrame的实例对象加入了一个属性，而如果该列已经存在，是可以对该列进行更改的

  1. In [12]: df.A = np.arange(6)

  3. In [13]: df
  4. Out[13]:
  5.    A         B         3         4         5         6
  6. 1  0 -1.160599 -1.236521 -2.356423  0.089117  1.090875
  7. 2  1 -0.285893  0.918261  1.250223  2.028298 -0.007042
  8. C  2  0.716184  0.318086 -0.540593 -2.408134  0.526977
  9. D  3  0.718741 -1.420655 -0.182436  0.333909 -1.608134
  10. 5  4 -0.541419 -1.195019 -0.924797 -0.261171  1.078212
  11. 6  5  0.454283 -0.763443  0.065712 -0.336119  0.182736
复制代码

所以，以上就是属性选取方法，可见，由于各种限制，属性选取有着非常大的局限，同时，这种操作还很可能得到意想不到的结果，所以我个人并不推介使用这种选取的方法。

2.基础选取

官方文档称这种方式为Basic Selecte，所以这里我也称之为基础选取方式，这种方式就是直接对DataFrame对象使用[]运算符，其实现方式是实现类的__getitem__魔术方法。

使用这种选取方法，非常简单，直接将需要选取的列名放入中括号中即可

  1. In [14]: df['A']
  2. Out[14]:
  3. 1    0
  4. 2    1
  5. C    2
  6. D    3
  7. 5    4
  8. 6    5
  9. Name: A, dtype: int32
复制代码

可以看到，这种方法可以非常方便地选取到一列数据，而当我们访问不存在的列时，将会抛出KeyError，这与Python的魔术方法协议是一致的，这点也是我喜欢Python的原因之一，通过各种类似协议的魔术方法，使得类似的操作能得到同样的结果，比如求长度我就立刻知道应该使用len()而不需要去猜是.length()还是.size()

  1. In [15]: df['G']
  2. KeyError: 'G'
复制代码

其次就是，这种方法只能选取一列，不可以同时选取到多个列

  1. In [16]: df[('A', 'B')]
  2. KeyError: ('A', 'B')
复制代码

时需要注意的是，我们传入的列名，其类型也必须和列名的类型相同

  1. In [17]: df[3]
  2. KeyError: 3
  3. In [18]: df['3']
  4. Out[18]:
  5. 1   -1.236521
  6. 2    0.918261
  7. C    0.318086
  8. D   -1.420655
  9. 5   -1.195019
  10. 6   -0.763443
  11. Name: 3, dtype: float64
复制代码

最后，这种方法还可以对DataFrame进行切片，但此时是对行进行切片


  1. In [19]: df[:'B']
  2. KeyError: 'B'
  3. In [20]: df[:3]
  4. Out[20]:
  5.    A         B         3         4         5         6
  6. 1  0 -1.160599 -1.236521 -2.356423  0.089117  1.090875
  7. 2  1 -0.285893  0.918261  1.250223  2.028298 -0.007042
  8. C  2  0.716184  0.318086 -0.540593 -2.408134  0.526977
  9. In [21]: df[:'D':-1]
  10. Out[21]:
  11.    A         B         3         4         5         6
  12. 6  5  0.454283 -0.763443  0.065712 -0.336119  0.182736
  13. 5  4 -0.541419 -1.195019 -0.924797 -0.261171  1.078212
  14. D  3  0.718741 -1.420655 -0.182436  0.333909 -1.608134
复制代码


可以看到，此时我们可以使用坐标进行切片，也可以输入行名，同时切片的第三个参数也是可以使用的，但如果我们尝试对列进行切片，则会抛出KeyError。

3.标签选取

标签选取，即严格使用行列名（index）进行选取的方法，其需要使用.loc属性

  1. In [22]: df.loc['C']
  2. Out[22]:
  3. A    2.000000
  4. B    0.716184
  5. 3    0.318086
  6. 4   -0.540593
  7. 5   -2.408134
  8. 6    0.526977
  9. Name: C, dtype: float64
复制代码

可以看到，这种方法其能够快速选定一行，而事实上，该方法可以同时定位行和列或者多行多列，此时只需要默念，先行后列，先行后列，先行后列，并使用逗号分隔


  1. In [23]: df.loc['C', 'A']
  2. Out[23]: 2.0
  3. In [24]: df.loc[('C', 'D'), ('A', 'B')]
  4. Out[24]:
  5.    A         B
  6. C  2  0.716184
  7. D  3  0.718741
复制代码

同时，该方法可以进行切片，并且可以行列同时进行，需要说明的是，这里只能接受两个参数，即行和列的切片，不能使用第三个参数


  1. In [25]: df.loc['C':'6', '3':]
  2. Out[25]:
  3.           3         4         5         6
  4. C  0.318086 -0.540593 -2.408134  0.526977
  5. D -1.420655 -0.182436  0.333909 -1.608134
  6. 5 -1.195019 -0.924797 -0.261171  1.078212
  7. 6 -0.763443  0.065712 -0.336119  0.182736
  8. In [26]: df.loc['C':'6', '3':, -1]
  9. IndexingError: Too many indexers
复制代码

如果需要表示全部选中，比如选中所有的行，则必须要写出:表示全部选中，即可以省略后面的参数，默认选中所有的列，但是，需要选中所有的行时，行参数不可以省略

  1. In [27]: df.loc[:, 5]
  2. Out[27]:
  3. 1    0.089117
  4. 2    2.028298
  5. C   -2.408134
  6. D    0.333909
  7. 5   -0.261171
  8. 6   -0.336119
  9. Name: 5, dtype: float64
复制代码

如果我们选择不存在的位置，将会抛出KeyError


  1. In [28]: df.loc['G']
  2. KeyError: 'the label [G] is not in the [index]'
复制代码

值得注意的是，该方法要求非常严格，其要求输入的行列名必须与DataFrame的行列名类型一致，否则抛出KeyError

  1. In [29]: df.loc[6]
  2. KeyError: 'the label [6] is not in the [index]'
复制代码
4.坐标选取

大多数刚刚开始使用DataFrame的童鞋可能都非常喜欢使用坐标来选取数据，毕竟如果我们将DataFrame理解为一个二维的数组，那么使用坐标来选取就显得非常的浑然天成，但是这时候，我们会发现前面说到的方法多大都需要时行名列名且要确保其类型也是一致的，这时候传统的直接使用坐标进行选取就会失效。

如果我们仍然需要使用坐标进行数据选取，此时就需要使用.iloc属性

  1. In [30]: df.iloc[0]
  2. Out[30]:
  3. A    0.000000
  4. B   -1.160599
  5. 3   -1.236521
  6. 4   -2.356423
  7. 5    0.089117
  8. 6    1.090875
  9. Name: 1, dtype: float64
复制代码

与标签选取方法类似，这种方法也可以同时定位行和列、多行和多列，同样是先行后列，逗号分隔

  1. In [31]: df.iloc[0, 5]
  2. Out[31]: 1.0908752302725568
  3. In [32]: df.iloc[(0, 2), (2, 3)]
  4. Out[32]:
  5.           3         4
  6. 1 -1.236521 -2.356423
  7. C  0.318086 -0.540593
复制代码

同样的，也支持切片，使用:表示全部选中，不可以有第三个参数

  1. In [33]: df.iloc[:, :3]
  2. Out[33]:
  3.    A         B         3
  4. 1  0 -1.160599 -1.236521
  5. 2  1 -0.285893  0.918261
  6. C  2  0.716184  0.318086
  7. D  3  0.718741 -1.420655
  8. 5  4 -0.541419 -1.195019
  9. 6  5  0.454283 -0.763443
复制代码

可以说，这个方法和标签选取的方法，其实是两兄弟，一个是使用标签，一个是使用坐标进行选取，当然，如果我们选取不存在的位置，其也会非常合理地抛出IndexError

  1. In [34]: df.iloc[7]
  2. IndexError: single positional indexer is out-of-bounds
复制代码

而如果我们输入的参数不是整数，此时将会抛出TypeError

  1. In [35]: df.iloc['C']  
  2. TypeError: cannot do positional indexing with these indexers [C] of <class 'str'>
复制代码

最后需要注意的是，这里说的坐标都是实时的，所以，我们需要注意，不要与标签选取的方法混淆，标签选取无论该数据在表格的什么位置都能够选取到，而定位选取则有可能给我们不一样的结果

  1. In [36]: df.sort_values('B').iloc[1]
  2. Out[35]:
  3. A    4.000000
  4. B   -0.541419
  5. 3   -1.195019
  6. 4   -0.924797
  7. 5   -0.261171
  8. 6    1.078212
  9. Name: 5, dtype: float64
  10. In [37]: df.sort_values('B').loc[1]
  11. Out[37]:
  12. A    0.000000
  13. B   -1.160599
  14. 3   -1.236521
  15. 4   -2.356423
  16. 5    0.089117
  17. 6    1.090875
  18. Name: 1, dtype: float64
复制代码

可以看到，即使顺序打乱了，我们仍能根据行名准确得到对应的行，而如果是是用坐标，那么我们得到的就是B列最小的那一行即这里的行名为5的行，所以在选择使用标签选取或者是定位选取的时候，一定要明确自己的需求。

5.条件筛选

当我们需要按列筛选行的时候，根据上面所说的方法，直接使用[]，这里是一致的

  1. In [38]: df[df['B'] > 0]
  2. Out[38]:
  3.    A         B         3         4         5         6
  4. C  2  0.716184  0.318086 -0.540593 -2.408134  0.526977
  5. D  3  0.718741 -1.420655 -0.182436  0.333909 -1.608134
  6. 6  5  0.454283 -0.763443  0.065712 -0.336119  0.182736
复制代码

而按行筛选列时，则有一点不同，正确的方法是

  1. In [39]: df.loc[:, df.loc['C'] > 0]
  2. Out[39]:
  3.    A         B         3         6
  4. 1  0 -1.160599 -1.236521  1.090875
  5. 2  1 -0.285893  0.918261 -0.007042
  6. C  2  0.716184  0.318086  0.526977
  7. D  3  0.718741 -1.420655 -1.608134
  8. 5  4 -0.541419 -1.195019  1.078212
  9. 6  5  0.454283 -0.763443  0.182736
复制代码

是否觉得很诡异，这里我们可以探究一下pandas是如何实现这个筛选逻辑的


  1. In [40]: df['B'] > 0
  2. Out[40]:
  3. 1    False
  4. 2    False
  5. C     True
  6. D     True
  7. 5    False
  8. 6     True
  9. Name: B, dtype: bool
  10. In [41]: df.loc['C'] > 0
  11. Out[41]:
  12. A     True
  13. B     True
  14. 3     True
  15. 4    False
  16. 5    False
  17. 6     True
  18. Name: C, dtype: bool
复制代码

可以看到，当我们取出一列进行大小判断时，其返回的是所有的行的判断结果（Series对象），而如果我们对一行进行判断，则返回的是各个列的判断结果，即pandas通过覆写大小判断运算符将判断操作自动扩展至对象中的每个元素，这点和R的逻辑是契合的。而上面我们也说到过，当我们使用的是[]进行切片时，我们是对行进行切片，而这里，我们刚好就填入了行的判断结果（In [40]），所以，如果我们输入的切片参数是Series对象时，pandas将切出被判断为True的行。对列进行筛选的操作也是同样的，只不过先行后列，所以前面我们需要:来表示我们选中所有的行，同时也就意味着，使用.loc时，可以同时对行和列进行筛选，只需要同时给出判断结果即可

  1. In [42]: df.loc[df['B'] > 0, df.loc['C'] > 0]
  2. Out[42]:
  3.    A         B         3         6
  4. C  2  0.716184  0.318086  0.526977
  5. D  3  0.718741 -1.420655 -1.608134
  6. 6  5  0.454283 -0.763443  0.182736
复制代码

到这里，相信这个筛选操作就比较好理解了，但是有一点需要注意的是，我们不能使用定位方法进行筛选

  1. In [43]: df.iloc[1] > 0
  2. Out[43]:
  3. A     True
  4. B    False
  5. 3     True
  6. 4     True
  7. 5     True
  8. 6    False
  9. Name: 2, dtype: bool
复制代码

可以看到，即使我们使用定位方法选中的行列并进行判断后，其仍然使用标签进行定位，所以我们可以知道，在pandas的设计当中，标签定位的优先级是大于坐标定位的，因而在使用pandas库时，应该转变思想，要将理念从二维数组中跳脱出来，将pandas理解为一个更像数据库的存在。

最后，也就是多条件联合筛选，由于python内置的布尔运算符and和or不可以进行覆写，而此时又需要将布尔运算扩展至每个元素，因而pandas覆写了&和|这两个运算符，写过其他语言的小伙伴应该不陌生，要注意的是，这里只需要写一次，不像Java等需要写两次。

  1. In [44]: df[(df['B'] > 0) & (df['3'] > 0)]
  2. Out[44]:
  3.    A         B         3         4         5         6
  4. C  2  0.716184  0.318086 -0.540593 -2.408134  0.526977
  5. In [45]: df.loc[:, (df.loc['C'] > 0) | (df.loc['5'] > 0)]
  6. Out[45]:
  7.    A         B         3         6
  8. 1  0 -1.160599 -1.236521  1.090875
  9. 2  1 -0.285893  0.918261 -0.007042
  10. C  2  0.716184  0.318086  0.526977
  11. D  3  0.718741 -1.420655 -1.608134
  12. 5  4 -0.541419 -1.195019  1.078212
  13. 6  5  0.454283 -0.763443  0.182736
复制代码

需要注意的是，由于只有进行判断结束返回的Series对象，才可以进行布尔运算，所以这里需要给每个判断条件加上小括号以提高运算优先级。

6.总结

最后，结合上述内容和我个人的使用经验，总结一些我个人最佳实践

  • 数据在读取时就需要进行处理，首先一点就是应该将每一行作为一个样本，一列作为一个特征，由于大多数时候是根据属性对样本进行筛选，所以此时筛选起来就会更加的便捷。（df.T可以获得经过转置的DataFrame即行列交换）
  • 每一个样本即每一行都必须使用唯一的index(行名)，这一点有点数据库的主键的意思，这样就能保证我们能准确选到我们需要的数据，至于列名，如果根据前面的规则，则应该不会存在相同的特征，且全部行名和列名统一为一种类型，推介字符串类型。
  • 当需要选中一列时，直接使用df[col]的方法选中一列，而需要选中一行的时候，直接使用df.loc[row]来选中一行。
  • 在任何操作中尽可能避免使用坐标进行定位。
  • 当需要同时对行列进行操作时，使用df.loc[row, loc]并在心里默念先行后列，同时，这种方式的参数比较多样，可以输入判断结果，也可输入单个行列名或者包含多个行列名的列表，可以按需选择。


数据.jpg




回复

使用道具 举报

返回列表 发表新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 免费注册
Copyright @ 2019-2023  || 网络违法和不良信息举报 || 沪ICP备14010833号-2
关注微信