pandas教程：Essential Functionality 索引 过滤 映射 排序-灵析社区

清晨我上码

5.2 Essential Functionality（主要功能）

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

1 Reindexing（重新索引）

pandas中一个重要的方法是reindex，已实施在创建object的时候遵照一个新的index。如下例：

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

在series上调用reindex能更改index，如果没有对应index的话会引入缺失数据：

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

在处理时间序列这样的数据时，我们可能需要在reindexing的时候需要修改值。method选项能做到这一点，比如设定method为ffill:

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

对于DataFrame，reindex能更改row index,或column index。reindex the rows:

import numpy as np
frame = pd.DataFrame(np.arange(9).reshape(3, 3),
                     index=['a', 'c', 'd'],
                     columns=['Ohio', 'Texas', 'California'])
frame

frame2 = frame.reindex(['a', 'b', 'c', 'd'])
frame2

更改columns index:

states = ['Texas', 'Utah', 'California']
frame.reindex(columns=states)

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

frame.loc[['a', 'b', 'c', 'd'], states]

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

对于series，drop回返回一个新的object，并删去你制定的axis的值：

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

对于DataFrame，index能按行或列的axis来删除：

data = pd.DataFrame(np.arange(16).reshape(4, 4),
                    index=['Ohio', 'Colorado', 'Utah', 'New York'],
                    columns=['one', 'two', 'three', 'four'])
data

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

data.drop(['Colorado', 'Ohio'])

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

data.drop('two', axis=1)

data.drop(['two', 'four'], axis='columns')

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

obj.drop('c', inplace=True)
obj
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的index：

obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
obj
a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
obj['b']
1.0
obj[1]
1.0
obj[2:4]
c    2.0
d    3.0
dtype: float64
# 选中行
obj[['b', 'a', 'd']]
b    1.0
a    0.0
d    3.0
dtype: float64
obj[[1, 3]]
b    1.0
d    3.0
dtype: float64
obj[obj < 2]
a    0.0
b    1.0
dtype: float64

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

obj['b':'c']
1
b    1.0
c    2.0
dtype: float64

可以直接给选中的label更改值：

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

而对于DataFrame，indexing可以通过一个值或序列，选中一个以上的列：

data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                    index=['Ohio', 'Colorado', 'Utah', 'New York'],
                    columns=['one', 'two', 'three', 'four'])
data

data['two']
Ohio         1
Colorado     5
Utah         9
New York    13
Name: two, dtype: int64
data[['three', 'one']]

dataframe的indexing有一些比较特别的方式。比如通过布尔数组：

data[:2]

data[data['three'] > 5]

行选择的语法格式data[:2]是很方便的。给[]里传入一个list的话，可以选择列。

另一种方法是用boolean dataframe:

data < 5

data[data < 5] = 0
data

Selection with loc and iloc(用loc和iloc来选择)

对于label-indexing on rows, 我们介绍特别的索引符，loc and iloc. 这两个方法能通过axis labels(loc)或integer(iloc)，来选择行或列。

一个列子，选中一行多列by label：

data

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

同iloc实现相同的效果：

data.iloc[2, [3, 0, 1]]
four    11
one      8
two      9
Name: Utah, dtype: int64
data.iloc[2] # 一行
one       8
two       9
three    10
four     11
Name: Utah, dtype: int64
data.iloc[[1, 2], [3, 0, 1]]

indexing函数也能用于切片，不论是single labels或lists of labels:

data.loc[:'Utah', 'two']
Ohio        0
Colorado    5
Utah        9
Name: two, dtype: int64
data.iloc[:, :3][data.three > 5]

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

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

4 Integer Indexes（整数索引）

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

比如，你不希望下面的代码出现error：

ser = pd.Series(np.arange(3.))
ser
0    0.0
1    1.0
2    2.0
dtype: float64
ser[-1]


---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-61-3cbe0b873a9e> in <module>()
----> 1 ser[-1]


/Users/xu/anaconda/envs/py35/lib/python3.5/site-packages/pandas/core/series.py in __getitem__(self, key)
    581         key = com._apply_if_callable(key, self)
    582         try:
--> 583             result = self.index.get_value(self, key)
    584 
    585             if not lib.isscalar(result):


/Users/xu/anaconda/envs/py35/lib/python3.5/site-packages/pandas/indexes/base.py in get_value(self, series, key)
   1978         try:
   1979             return self._engine.get_value(s, k,
-> 1980                                           tz=getattr(series.dtype, 'tz', None))
   1981         except KeyError as e1:
   1982             if len(self) > 0 and self.inferred_type in ['integer', 'boolean']:


pandas/index.pyx in pandas.index.IndexEngine.get_value (pandas/index.c:3332)()


pandas/index.pyx in pandas.index.IndexEngine.get_value (pandas/index.c:3035)()


pandas/index.pyx in pandas.index.IndexEngine.get_loc (pandas/index.c:4018)()


pandas/hashtable.pyx in pandas.hashtable.Int64HashTable.get_item (pandas/hashtable.c:6610)()


pandas/hashtable.pyx in pandas.hashtable.Int64HashTable.get_item (pandas/hashtable.c:6554)()


KeyError: -1

看到了，pandas在整数索引上可能会出错。这里我们有一个index包括0，1，2，但是猜测用户想要什么是很困难的：

ser
0    0.0
1    1.0
2    2.0
dtype: float64

另一方面，如果用非整数来做index，就没有歧义了：

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

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

ser[:1]
0    0.0
dtype: float64
ser.loc[:1]
0    0.0
1    1.0
dtype: float64
ser.iloc[:1]
0    0.0
dtype: float64rithmetic and Data Alignment (算数和数据对齐)

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
a    7.3
c   -2.5
d    3.4
e    1.5
dtype: float64
s2
a    2.1
c    3.6
e   -1.5
f    4.0
g    3.1
dtype: float64
s1 + s2
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

df2

相加的结果就是两个DataFrame，行和列的合集：

df1 + df2

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

如果两个DataFrame相加，而且没有column和row，结果会全是null：

df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'B': [3, 4]})
df1

df2

df1 - df2

Arithmetic methods with fill values (带填充值的算数方法)

对于上面那些缺失值，我们想要填上0：

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

df2

不使用添加方法的结果：

df1 + df2

使用fill_value：

df1.add(df2, fill_value=0)

每一个都有一个配对的，以 r 开头，意思是反转：

1 / df1

df1.rdiv(1)

在reindex（重建索引）的时候，也可以使用fill_value:

df1.reindex(columns=df2.columns, fill_value=0)

Operations between DataFrame and Series (DataFrame和Series之间的操作)

先举个numpy的例子帮助理解，可以考虑成一个二维数组和它的一行：

arr = np.arange(12.).reshape((3, 4))
arr
array([[  0.,   1.,   2.,   3.],
       [  4.,   5.,   6.,   7.],
       [  8.,   9.,  10.,  11.]])
arr[0]
array([ 0.,  1.,  2.,  3.])
arr - arr[0]
array([[ 0.,  0.,  0.,  0.],
       [ 4.,  4.,  4.,  4.],
       [ 8.,  8.,  8.,  8.]])

可以看到，这个减法是用在了每一行上。这种操作叫broadcasting，在Appendix A有更详细的解释。DataFrame和Series的操作也类似：

frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
                     columns=list('bde'),
                    index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series = frame.iloc[0]
frame

series
b    0.0
d    1.0
e    2.0
Name: Utah, dtype: float64

可以理解为series的index与dataframe的列匹配，broadcasting down the rows(向下按行广播):

frame - series

如果一个index既不在DataFrame的column中，也不再series里的index中，那么结果也是合集：

series2 = pd.Series(range(3), index=['b', 'e', 'f'])
frame + series2

如果想要广播列，去匹配行，必须要用到算数方法：

series3 = frame['d']
frame

series3
Utah       1.0
Ohio       4.0
Texas      7.0
Oregon    10.0
Name: d, dtype: float64
frame.sub(series3, axis='index')

axis参数就是用来匹配轴的。在这个例子里是匹配dataframe的row index(axis='index or axis=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

np.abs(frame)

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

f = lambda x: x.max() - x.min()
frame.apply(f)
b    1.334579
d    0.609748
e    2.417783
dtype: float64

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

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

frame.apply(f, axis='columns')
Utah      1.004883
Ohio      1.953030
Texas     0.349825
Oregon    1.799333
dtype: float64

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

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

def f(x): 
    return pd.Series([x.min(), x.max()], index=['min', 'max'])
frame

frame.apply(f)

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

format = lambda x: '%.2f' % x
frame.applymap(format)

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

frame['e'].map(format)
Utah      -0.71
Ohio       1.07
Texas     -0.16
Oregon    -1.35
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.sort_index()
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

frame.sort_index()

frame.sort_index(axis=1)

默认是升序，可以设置降序：

frame.sort_index(axis=1, ascending=False)

通过值来排序，用sort_values方法：

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

缺失值会被排在最后：

obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
obj.sort_values()
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

frame.sort_values(by='b')

多列排序的话，传入一个list of names：

frame.sort_values(by=['a', 'b'])

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

obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
obj
0    7
1   -5
2    7
3    4
4    2
5    0
6    4
dtype: int64
obj.sort_values()
1   -5
5    0
4    2
3    4
6    4
0    7
2    7
dtype: int64
obj.rank()
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
0    7
1   -5
2    7
3    4
4    2
5    0
6    4
dtype: int64
obj.rank(method='first')
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。

也可以设置降序：

# Assign tie values the maximum rank in the group
obj.rank(ascending=False, method='max')
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

frame.rank(axis='columns') # columns表示列与列之间的排序（即每一行里数据间的排序）

8 Axis Indexes with Duplicate Labels (有重复label的轴索引)

我们看到的所有例子都有unique axis labels(index values),唯一的轴标签（索引值）。一些pandas函数（reindex）,需要label是唯一的，但这并是不强制的。比如下面有一个重复的索引：

obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
obj

a    0

a    1
b    2
b    3
c    4
dtype: int64

index的is_unique特性能告诉我们label是否是唯一的：

obj.index.is_unique
False

数据选择对于重复label则表现有点不同。如果一个label有多个值，那么就会返回一个series, 如果是label只对应一个值的话，会返回一个标量：

obj['a']
a    0
a    1
dtype: int64
obj['c']
4

这个选择的逻辑也应用于DataFrame：

df = pd.DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])
df

df.loc['b']

阅读量：479

点赞量：0

收藏量:0