本博客爲《利用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