本博客为《利用Python进行数据分析》的读书笔记，请勿转载用于其他商业用途。
1. 整数索引
在pandas对象使上用整数索引对新用户来说经常会产生歧义，这是因为它和在列表、元组等Python内建数据结构上进行索引有些许不同。例如：
ser = pd.Series(np.arange(3.))
print(ser)
print(ser[-1])
在上面的例子中，pandas可以“回退”到整数索引，但是这样的方式难免会引起一些微小的错误。假设我们有一个索引，它包含了0、1、2，但是腿短用户所需要的索引方式（标签索引或位置索引）是很难的：
#
0 0.0
1 1.0
2 2.0
dtype: float64
另一方面，对于非整数索引，则不会有潜在的歧义：
ser2 = pd.Series(np.arange(3.), index=['a', 'b', 'c'])
print(ser2[-1])
#
2.0
为了保持一致性，如果我们有一个包含整数的索引轴，数据选择时请始终使用标签索引。
为了更精确地处理，可以使用loc（用于标签）或iloc（用于整数）：
print(ser[:1])
print(ser.loc[:1])
print(ser.iloc[:1])
#
0 0.0
dtype: float64
0 0.0
1 1.0
dtype: float64
0 0.0
dtype: float64
2. 算数和数据对齐
不同索引的对象之间的算数行为是pandas提供给一些应用的一项重要特征。当我们将对象相加时，如果存在某个索引对不相同，则返回结果的索引将是索引对的并集。 对数据库用户来说，这个特性类似于索引标签的自动外连接（outer join）：
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'])
print(s1)
print(s2)
print(s1 + s2)
#
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
a 5.2
c 1.1
d NaN
e 0.0
f NaN
g NaN
dtype: float64
没有交叠的标签位置上，内部数据对齐会产生缺失值。缺失值会在后续的算数操作上产生影响。在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'])
print(df1)
print(df2)
#
b c d
Ohio 0.0 1.0 2.0
Texas 3.0 4.0 5.0
Colorado 6.0 7.0 8.0
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的索引、列的并集：
print(df1 + df2)
#
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对象也是如此。
如果我们将两个行或列完全不同的DataFrame对象相加，结果将全部为空：
df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'B': [3, 4]})
print(df1)
print(df2)
print(df1 + df2)
#
A
0 1
1 2
B
0 3
1 4
A B
0 NaN NaN
1 NaN NaN
2.1 使用填充值的算数方法
在两个不同的索引化对象之间进行算数操作时，我们可能会想要使用特殊填充值，比如当轴标签在一个对象中存在，在另一个对象中不存在时，我们希望将缺失值填充为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
print(df1)
print(df2)
#
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
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
将这些df添加到一起会导致在一些不重叠的位置出现NA值：
print(df1 + df2)
#
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作为参数传入：
print(df1.add(df2, fill_value=0))
#
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
灵活算数方法
| 方法 | 描述 |
|---|---|
| add, radd | 加法（+） |
| sub, rsub | 减法（-） |
| div, rdiv | 除法（/） |
| floordiv, rfloordiv | 整除（//） |
| mul, rmul | 乘法（*） |
| pow, rpow | 幂次方（**） |
2.2 DataFrame和Series间的操作
DataFrame和Series间的算数操作与NumPy中不同维度数组间的操作类似。首先，在下面的生动实例中，考虑二维数组和其中一行之间的区别：
arr = np.arange(12.).reshape((3, 4))
print(arr)
print(arr[0])
print(arr - arr[0])
#
[[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]
[ 8. 9. 10. 11.]]
[0. 1. 2. 3.]
[[0. 0. 0. 0.]
[4. 4. 4. 4.]
[8. 8. 8. 8.]]
当我们从arr中减去arr[0]时，减法在每一行都进行了操作。这就是所谓的广播机制。DataFrame和Series间的操作时类似的：
frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
columns=list('bde'),
index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series = frame.iloc[0]
print(frame)
print(series)
#
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
b 0.0
d 1.0
e 2.0
Name: Utah, dtype: float64
默认情况下，DataFrame和Series的数学操作中会将Series的索引和DataFrame的列进行匹配，并广播到各行：
print(frame - series)
#
b d e
Utah 0.0 0.0 0.0
Ohio 3.0 3.0 3.0
Texas 6.0 6.0 6.0
Oregon 9.0 9.0 9.0
如果一个索引值不在DataFrame的列中，也不在Series的索引中，则对象会重建索引并形成联合：
series2 = pd.Series(range(3), index=['b', 'e', 'f'])
print(series2)
print(frame + series2)
#
b 0
e 1
f 2
dtype: int64
b d e f
Utah 0.0 NaN 3.0 NaN
Ohio 3.0 NaN 6.0 NaN
Texas 6.0 NaN 9.0 NaN
Oregon 9.0 NaN 12.0 NaN
如果我们想改为在列上进行广播，在行上匹配，必须使用算数方法中的一种。例如：
series3 = frame['d']
print(series3)
print(frame.sub(series3, axis='index'))
#
Utah 1.0
Ohio 4.0
Texas 7.0
Oregon 10.0
Name: d, dtype: float64
b d e
Utah -1.0 0.0 1.0
Ohio -1.0 0.0 1.0
Texas -1.0 0.0 1.0
Oregon -1.0 0.0 1.0
我们传递axis值是用于匹配的。上面的例子中我们需要在DataFrame的行索引上对行匹配（axis='index'或axis=0），并进行广播。
2.3 函数应用和映射
NumPy的通用函数（逐元素数组方法）对pandas对象也有效：
frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])
print(frame)
print(np.abs(frame))
#
b d e
Utah -1.465526 0.658874 -0.597709
Ohio 0.775255 -0.484118 -1.566905
Texas -0.485606 0.100989 0.499592
Oregon 1.093376 -0.010603 1.121682
b d e
Utah 1.465526 0.658874 0.597709
Ohio 0.775255 0.484118 1.566905
Texas 0.485606 0.100989 0.499592
Oregon 1.093376 0.010603 1.121682
另一个常用的操作时将函数应用到一行或一列的一维数组上。DataFrame的apply方法可以实现这个功能：
f = lambda x: x.max() - x.min()
print(frame.apply(f))
#
b 2.558903
d 1.142992
e 2.688587
dtype: float64
这里的函数f，可以计算Series最大值和最小值的差，会被frame中的每一列调用一次。结果是一个以frame的列作为索引的Series。
如果我们传递axis='columns'给apply函数，函数将会被每行调用一次：
print(frame.apply(f, axis='columns'))
#
Utah 2.124401
Ohio 2.342160
Texas 0.985198
Oregon 1.132285
dtype: float64
大部分最常用的数组统计（比如sum和mean）都是DataFrame的方法，因此计算统计值时使用apply并不是必须的。
传递给apply的函数并不一定要返回一个标量值，也可以返回带有多个值的Series：（这里我们重新选择一组随机数）
def f(x):
return pd.Series([x.min(), x.max()], index=['min', 'max'])
print(frame.apply(f))
#
b d e
min 0.042147 -1.145714 -2.458830
max 1.240665 1.039007 1.281412
逐元素的Python函数也可以使用。假设我们想根据frame中的每个浮点数计算一个格式化字符串，可以使用applymap方法：
format = lambda x: '%.2f' % x
print(frame.applymap(format))
#
b d e
Utah -1.99 0.60 -0.18
Ohio 0.77 0.40 -0.97
Texas 0.94 -0.12 -1.82
Oregon 0.84 0.89 1.20
使用applymap作为函数名是因为Series有map方法，可以将一个逐元素的函数应用到Series上：
print(frame['e'].map(format))
#
Utah 2.358782599101512
Ohio 0.8136685914882829
Texas -0.6656273895485438
Oregon -0.4634101122416516
Name: e, dtype: object
2.4 排名和排序
根据某些准则对数据集进行排序是另一个重要的内建操作。如需按行或列索引进行字典型排序，需要使用sort_index方法，该方法返回一个新的、排序好的对象：
obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
print(obj.sort_index())
#
a 1
b 2
c 3
d 0
dtype: int64
在DataFrame中，我们可以在各个轴上按索引排序：
frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
index=['three', 'one'],
columns=['d', 'a', 'b', 'c'])
print(frame.sort_index())
#
d a b c
one 4 5 6 7
three 0 1 2 3
print(frame.sort_index(axis=1))
#
a b c d
three 1 2 3 0
one 5 6 7 4
数据默认会升序排序，但是也可以按照降序排列：
print(frame.sort_index(axis=1, ascending=False))
#
d c b a
three 0 3 2 1
one 4 7 6 5
如果要根据Series的值进行排序，使用sort_values方法：
obj = pd.Series([4, 7, -3, 2])
print(obj.sort_values())
#
2 -3
3 2
0 4
1 7
dtype: int64
默认情况下，所有的缺失值都会被排序至Series的尾部：
obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
print(obj.sort_values())
#
4 -3.0
5 2.0
0 4.0
2 7.0
1 NaN
3 NaN
dtype: float64
当对DataFrame排序时，我们可以使用一列或多列作为排序键。为了实现这个功能，传递一个或多个列名给sort_values的可选参数by：
frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
print(frame)
print(frame.sort_values(by='b'))
#
b a
0 4 0
1 7 1
2 -3 0
3 2 1
b a
2 -3 0
3 2 1
0 4 0
1 7 1
对多列排序时，传递列名的列表：
print(frame.sort_values(by=['a', 'b']))
#
b a
2 -3 0
0 4 0
3 2 1
1 7 1
排名是指对数组从1到有效数据点总数分配名次的操作。Series和DataFrame的rank方法是实现排名的方法，默认情况下，rank通过将平均排名分配到每个组来打破平级关系：
obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
print(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
排名也可以根据他们在数据中的观察顺序进行分配：
print(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设置的名词为6和7，而不是之前的平均排名6.5，是因为在数据中标签0在标签2的前面。
我们可以按降序排名：
print(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可以对行或列计算排名：
frame = pd.DataFrame({'a': [4.3, 7, -3, 2], 'b': [0, 1, 0, 1],
'c': [-2, 5, 8, -2.5]})
print(frame)
print(frame.rank(axis='columns'))
#
a b c
0 4.3 0 -2.0
1 7.0 1 5.0
2 -3.0 0 8.0
3 2.0 1 -2.5
a b c
0 3.0 2.0 1.0
1 3.0 1.0 2.0
2 1.0 2.0 3.0
3 3.0 2.0 1.0
排名中的平级关系打破方法
| 方法 | 描述 |
|---|---|
| ‘average’ | 默认：在每个组中分配平均排名 |
| ‘min’ | 对整个组使用最小排名 |
| ‘max’ | 对整个组使用最大排名 |
| ‘first’ | 按照值在数据中出现的次序分配排名 |
| ‘dense’ | 类似于method=‘min’，但组间排名总是增加1，而不是一个组中相等的元素的数量 |
2.5 含有重复标签的轴索引
目前为止我们所见过的示例中，轴索引都是唯一的（索引值）。尽管很多pandas函数（比如reindex）需要标签是唯一的，但这个并不是强制性的。让我们考虑一个小型的带有重复索引的Series：
obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
print(obj)
#
a 0
a 1
b 2
b 3
c 4
dtype: int64
索引的is_unique属性可以告诉我们它的标签是否唯一：
print(obj.index.is_unique)
#
False
带有重复索引的情况下，数据选择是与之前操作有差别的主要情况。根据一个标签索引多个条目会返回一个徐略，而单个条目会返回标量值：
print(obj['a'])
print(obj['c'])
#
a 0
a 1
dtype: int64
4
这可能会使代码更加复杂，因为来自索引的输出类型可能因标签是否重复而有所不同。
相同的逻辑可以拓展到在DataFrame中进行行索引：
df = pd.DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])
print(df)
print(df.loc['b'])
#
0 1 2
a -0.164321 -0.550747 0.056628
a -0.371963 1.346380 -1.570035
b 0.866466 0.181505 -1.500608
b 0.135749 0.104855 -0.913846
0 1 2
b 0.866466 0.181505 -1.500608
b 0.135749 0.104855 -0.913846
