【翻译】《利用Python进行数据分析·第2版》第5章（中）pandas入门

作者：SeanCheney   Python爱好者社区专栏作者

简书专栏：https://www.jianshu.com/u/130f76596b02

前文传送门：

5.2 基本功能

本节中，我将介绍操作Series和DataFrame中的数据的基本手段。后续章节将更加深入地挖掘pandas在数据分析和处理方面的功能。本书不是pandas库的详尽文档，主要关注的是最重要的功能，那些不大常用的内容（也就是那些更深奥的内容）就交给你自己去摸索吧。

重新索引

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

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

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

In [93]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e']) In [94]: obj2 Out[94]: 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可以修改（行）索引和列。只传递一个序列时，会重新索引结果的行：

In [98]: frame = pd.DataFrame(np.arange(9).reshape((3, 3)),   ....:                      index=['a', 'c', 'd'],   ....:                      columns=['Ohio', 'Texas', 'California']) In [99]: frame Out[99]:   Ohio  Texas  California a     0      1           2 c     3      4           5 d     6      7           8 In [100]: frame2 = frame.reindex(['a', 'b', 'c', 'd']) In [101]: frame2 Out[101]:   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关键字重新索引：

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

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

丢弃指定轴上的项

丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑，所以drop方法返回的是一个在指定轴上删除了指定值的新对象：

In [105]: obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e']) In [106]: obj Out[106]: a    0.0 b    1.0 c    2.0 d    3.0 e    4.0 dtype: float64 In [107]: new_obj = obj.drop('c') In [108]: new_obj Out[108]: a    0.0 b    1.0 d    3.0 e    4.0 dtype: float64 In [109]: obj.drop(['d', 'c']) Out[109]: a    0.0 b    1.0 e    4.0 dtype: float64

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

In [110]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),   .....:                     index=['Ohio', 'Colorado', 'Utah', 'New York'],   .....:                     columns=['one', 'two', 'three', 'four']) In [111]: data Out[111]:          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

用标签序列调用drop会从行标签（axis 0）删除值：

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

通过传递axis=1或axis='columns'可以删除列的值：

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

许多函数，如drop，会修改Series或DataFrame的大小或形状，可以就地修改对象，不会返回新的对象：

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

小心使用inplace，它会销毁所有被删除的数据。

索引、选取和过滤

Series索引（obj[...]）的工作方式类似于NumPy数组的索引，只不过Series的索引值不只是整数。下面是几个例子：

In [117]: obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd']) In [118]: obj Out[118]: a    0.0 b    1.0 c    2.0 d    3.0 dtype: float64 In [119]: obj['b'] Out[119]: 1.0 In [120]: obj[1] Out[120]: 1.0 In [121]: obj[2:4] Out[121]: c    2.0 d    3.0 dtype: float64 In [122]: obj[['b', 'a', 'd']] Out[122]: b    1.0 a    0.0 d    3.0 dtype: float64 In [123]: obj[[1, 3]] Out[123]: b    1.0 d    3.0 dtype: float64 In [124]: obj[obj < 2] Out[124]: a    0.0 b    1.0 dtype: float64

利用标签的切片运算与普通的Python切片运算不同，其末端是包含的：

In [125]: obj['b':'c'] Out[125]: b    1.0 c    2.0 dtype: float64

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

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

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

In [128]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),   .....:                     index=['Ohio', 'Colorado', 'Utah', 'New York'],   .....:                     columns=['one', 'two', 'three', 'four']) In [129]: data Out[129]:          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

这种索引方式有几个特殊的情况。首先通过切片或布尔型数组选取数据：

In [132]: data[:2] Out[132]:          one  two  three  four Ohio        0    1      2     3 Colorado    4    5      6     7 In [133]: data[data['three'] > 5] Out[133]:          one  two  three  four Colorado    4    5      6     7 Utah        8    9     10    11 New York   12   13     14    15

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

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

In [134]: data < 5 Out[134]:            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 In [135]: data[data < 5] = 0 In [136]: data Out[136]:          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选择行和列的子集。

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

In [137]: data.loc['Colorado', ['two', 'three']] Out[137]: two      5 three    6 Name: Colorado, dtype: int64

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

In [138]: data.iloc[2, [3, 0, 1]] Out[138]: four    11 one      8 two      9 Name: Utah, dtype: int64 In [139]: data.iloc[2] Out[139]: one       8 two       9 three    10 four     11 Name: Utah, dtype: int64 In [140]: data.iloc[[1, 2], [3, 0, 1]] Out[140]:          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进行了总结。后面会看到，还有更多的方法进行层级化索引。

笔记：在一开始设计pandas时，我觉得用frame[:, col]选取列过于繁琐（也容易出错），因为列的选择是非常常见的操作。我做了些取舍，将花式索引的功能（标签和整数）放到了ix运算符中。在实践中，这会导致许多边缘情况，数据的轴标签是整数，所以pandas团队决定创造loc和iloc运算符分别处理严格基于标签和整数的索引。
ix运算符仍然可用，但并不推荐。

表5-4 DataFrame的索引选项

整数索引

处理整数索引的pandas对象常常难住新手，因为它与Python内置的列表和元组的索引语法不同。例如，你可能不认为下面的代码会出错：

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

为了进行统一，如果轴索引含有整数，数据选取总会使用标签。为了更准确，请使用loc（标签）或iloc（整数）：

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

算术运算和数据对齐

pandas最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。对于有数据库经验的用户，这就像在索引标签上进行自动外连接。看一个简单的例子：

In [150]: s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e']) In [151]: s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1],   .....:                index=['a', 'c', 'e', 'f', 'g']) In [152]: s1 Out[152]: a    7.3 c   -2.5 d    3.4 e    1.5 dtype: float64 In [153]: s2 Out[153]: a   -2.1 c    3.6 e   -1.5 f    4.0 g    3.1 dtype: float64

将它们相加就会产生：

In [154]: s1 + s2 Out[154]: a    5.2 c    1.1 d    NaN e    0.0 f    NaN g    NaN dtype: float64

自动的数据对齐操作在不重叠的索引处引入了NA值。缺失值会在算术运算过程中传播。

对于DataFrame，对齐操作会同时发生在行和列上：

In [155]: df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),   .....:                    index=['Ohio', 'Texas', 'Colorado']) In [156]: df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),   .....:                    index=['Utah', 'Ohio', 'Texas', 'Oregon']) In [157]: df1 Out[157]:            b    c    d Ohio      0.0  1.0  2.0 Texas     3.0  4.0  5.0 Colorado  6.0  7.0  8.0 In [158]: df2 Out[158]:          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

把它们相加后将会返回一个新的DataFrame，其索引和列为原来那两个DataFrame的并集：

In [159]: df1 + df2 Out[159]:            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）：

In [165]: df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)),   .....:                    columns=list('abcd')) In [166]: df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),   .....:                    columns=list('abcde')) In [167]: df2.loc[1, 'b'] = np.nan In [168]: df1 Out[168]:     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 In [169]: df2 Out[169]:      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

将它们相加时，没有重叠的位置就会产生NA值：

In [170]: df1 + df2 Out[170]:      a     b     c     d   e 0   0.0   2.0   4.0   6.0 NaN 1   9.0   NaN  13.0  15.0 NaN 2  18.0  20.0  22.0  24.0 NaN 3   NaN   NaN   NaN   NaN NaN 使用df1的add方法，传入df2以及一个fill_value参数： ```python In [171]: df1.add(df2, fill_value=0) Out[171]:      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

表5-5列出了Series和DataFrame的算术方法。它们每个都有一个副本，以字母r开头，它会翻转参数。因此这两个语句是等价的：

In [172]: 1 / df1 Out[172]:          a         b         c         d 0       inf  1.000000  0.500000  0.333333 1  0.250000  0.200000  0.166667  0.142857 2  0.125000  0.111111  0.100000  0.090909 In [173]: df1.rdiv(1) Out[173]:          a         b         c         d 0       inf  1.000000  0.500000  0.333333 1  0.250000  0.200000  0.166667  0.142857 2  0.125000  0.111111  0.100000  0.090909

表5-5 灵活的算术方法

与此类似，在对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

赞赏作者

Python爱好者社区历史文章大合集：

福利：文末扫码立刻关注公众号，“Python爱好者社区”，开始学习Python课程：

关注后在公众号内回复“课程”即可获取：

小编的Python入门视频课程！！！

崔老师爬虫实战案例免费学习视频。

丘老师数据科学入门指导免费学习视频。

陈老师数据分析报告制作免费学习视频。

玩转大数据分析！Spark2.X+Python 精华实战课程免费学习视频。

丘老师Python网络爬虫实战免费学习视频。