Pandas含有使数据分析工作变得更快更简单的高级数据结构和操作工具。pandas是基于NumPy构建的，让以Numpy为中心的应用变得更加简单。
Pandas的两个主要数据结构：Series和DataFrame。
Series：
- Series是一种类似于一维数组的对象，它由数据（各种NumPy数据类型)以及与之相关的数据标签（即索引）组成。
In [2]: from pandas import Series, DataFrame
In [3]: obj = Series([4, 7, -5, 3])
In [4]: obj
Out[4]:
0 4
1 7
2 -5
3 3
dtype: int64
- 可以通过Series的values和index属性获取其数组表示形式和索引对象：
- In [5]: obj.values Out[5]: array([ 4, 7, -5, 3]) In [6]: obj.index Out[6]: RangeIndex(start=0, stop=4, step=1)
- 可以通过索引的方式选取Series中的单个或一组值
- NumPy数组运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数等）都会保留索引和值之间的链接：
In [7]: obj[obj>2]
Out[7]:
0 4
1 7
3 3
dtype: int64
In [8]: obj*2
Out[8]:
0 8
1 14
2 -10
3 6
dtype: int64
- 还可以将Series看成是一个定长的有序字典，因为它是索引值到数据值的一个映射：
0 in obj
Out[9]: True
- Python字典中的数据也可以直接创建Series：
In [10]: sdata = {'Ohio':35000, 'Texas':71000, 'Oregon':16000, 'Utah':5000}
In [11]: obj3 = Series(sdata)
In [12]: obj3
Out[12]:
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
dtype: int64
- Pandas的isnull和notnull函数可用于检测缺失数据：
In [14]: import pandas as pd
In [16]: pd.isnull(obj3)
Out[16]:
Ohio False
Oregon False
Texas False
Utah False
dtype: bool
- Series对象本身及其索引都有一个name属性
In [17]: obj3.name = 'population'
In [18]: obj3.index.name = 'state'
In [19]: obj3
Out[20]:
state
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
Name: population, dtype: int64
Series最重要的一个功能：它在算术运算中会自动对齐不同索引的数据。
DataFrame
- DataFrame是一个表格型数据，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame即有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。
from pandas import Series, DataFrame
data = {'state':['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'year':[2000, 2001, 2002, 2001, 2001],
'pop':[1.5, 1.7, 3.6, 2.4, 2.9]}
frame = DataFrame(data);
print (frame)
- 结果DataFrame会自动加上索引，且全部列会被有序排列：
pop state year
0 1.5 Ohio 2000
1 1.7 Ohio 2001
2 3.6 Ohio 2002
3 2.4 Nevada 2001
4 2.9 Nevada 2001
- 如果指定了列序列，则DataFrame的列就会按照指定的顺序进行排序：
frame2 = DataFrame(data,columns=['year', 'state', 'pop'])
- 传入的列在数据中找不到，就会产生NA值。
- 通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series：
print (frame2['state'])
print (frame2.year)
输出：
0 Ohio
1 Ohio
2 Ohio
3 Nevada
4 Nevada
Name: state, dtype: object
0 2000
1 2001
2 2002
3 2001
4 2001
Name: year, dtype: int64
- 行也可以通过位置或名称的方式进行获取，比如用索引字段 ix
- 跟Series一样，如果传入的列在数据中找不到，就会产生NA值：
frame3 = DataFrame(data,columns=['year', 'state', 'pop', 'debt'])
print (frame3)
输出：
year state pop debt
0 2000 Ohio 1.5 NaN
1 2001 Ohio 1.7 NaN
2 2002 Ohio 3.6 NaN
3 2001 Nevada 2.4 NaN
4 2001 Nevada 2.9 NaN
列可以通过赋值的方式修改：
frame3['debt'] = np.arange(5.0)
print (frame3)
输出：
year state pop debt
0 2000 Ohio 1.5 0.0
1 2001 Ohio 1.7 1.0
2 2002 Ohio 3.6 2.0
3 2001 Nevada 2.4 3.0
4 2001 Nevada 2.9 4.0
- 将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度想匹配。如果赋值的是一个Series，就会精确匹配DataFrame的索引，所有的空位都将被填上缺失值：
val = Series([-1.2, -1.5, -1.7], index=[ 0, 2, 3])
frame3['debt'] = val
print (frame3)
输出：
year state pop debt
0 2000 Ohio 1.5 -1.2
1 2001 Ohio 1.7 NaN
2 2002 Ohio 3.6 -1.5
3 2001 Nevada 2.4 -1.7
4 2001 Nevada 2.9 NaN
注意：通过索引方式返回的列只是相应数据的视图，并不是副本
- 另一种常见的数据形式是嵌套字典（字典的字典）：
pop = {'Nevada':{2001:2.4, 2002:2.9},
'Ohio': {2000:2.5, 2001:1.7, 2002:3.6}}
frame4 = DataFrame(pop)
print (frame4)
输出：
Nevada Ohio
2000 NaN 2.5
2001 2.4 1.7
2002 2.9 3.6
转置：
frame4.T
- 由Series组成的字典用法类似
- 如果设置了DataFrame的index和columns的name属性，则这些信息也会被显示出来：
frame4 = DataFrame(pop)
frame4.index.name = 'year'
frame4.columns.name = 'state'
print (frame4)
输出：
state Nevada Ohio
year
2000 NaN 2.5
2001 2.4 1.7
2002 2.9 3.6
- 跟Series一样，values属性也会以二维ndarray的形式返回DataFrame中的数据：
print (frame4.values)
#输出
[[ nan 2.5]
[ 2.4 1.7]
[ 2.9 3.6]]
基本功能
重新索引
- 调用该Series的reindex将会根据数据索引进行重排。如果某个索引值当前不存在，就引入缺失值NaN：
obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a' , 'c'])
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
print (obj2)
#输出
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
dtype: float64
- 使用 fill_value 可做插值处理
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
print (obj2)
#输出
a -5.3
b 7.2
c 3.6
d 4.5
e 0.0
dtype: float64
- method选项
obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
print (obj3.reindex(range(6), method='ffill'))
#输出
0 blue
1 blue
2 purple
3 purple
4 yellow
5 yellow
dtype: object
| 参数 | 说明 |
| ffill或pad | 前向填充值 |
| bfill或backfill | 后向填充值 |
- 对于DataFrame，reindex可以修改（行）索引、列，或两个都修改。
frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['Ohio', 'Texas', 'California'])
frame2 = frame.reindex(['a', 'b', 'c', 'd'])
states = ['Texas', 'Utah', 'California']
frame3 = frame.reindex(columns=states)
利用ix的标签索引功能，重新索引任务可以变的更简洁：
frame.ix[['a', 'b', 'c', 'd'], states]
丢弃指定轴上的项
- 丢掉某条轴上的一个或多个项，只要有一个索引数组或列表即可，使用 drop 方法
data = DataFrame(np.arange(16).reshape((4,4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])
print (data.drop(['Colorado', 'Ohio']))
print (data.drop(['two', 'three'], axis=1))
索引、选取和过滤
- Series索引的几个例子：
obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
obj['b']
obj[1]
obj[2:4]
obj['b', 'a', 'd']
obj[[1,3]]
obj[obj<2]
obj['b', 'c']
- DataFrame索引：
data = DataFrame(np.arange(16).reshape((4,4)), index=['Ohio', 'Colorado', 'Utah',
data[['two', 'three']]
#输出
two three
Ohio 1 2
Colorado 5 6
Utah 9 10
New York 13 14
data[:2]
#输出
one two three four
Ohio 0 1 2 3
Colorado 4 5 6 7
data[data['three']>5]
#输出
one two three four
Colorado 4 5 6 7
Utah 8 9 10 11
New York 12 13 14 15
- 专门的索引字段ix
| 类型 | 说明 |
| obj[val] | 选取DataFrame的单个列或一组列 |
| obj.ix[val] | 选取DataFrame的单个行或一组行 |
| obj.ix[:,val] | 选取单个列或列子集 |
| obj.ix[val1,val2] | 同时选取行和列 |
算术运算和数据对齐
- pandas最重要的一个功能是，它可以对不同的索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。
- 使用df1的 add 方法，传入df2以及一个fill_value参数：
df1 = DataFrame(np.arange(12.).reshape((3,4)), columns= list('abcd'))
df2 = DataFrame(np.arange(20.).reshape((4,5)), columns= list('abcde'))
print(df1+df2)
print(df1.add(df2,fill_value=0))
#输出
a b c d e
0 0.0 2.0 4.0 6.0 NaN
1 9.0 11.0 13.0 15.0 NaN
2 18.0 20.0 22.0 24.0 NaN
3 NaN NaN NaN NaN NaN
a b c d e
0 0.0 2.0 4.0 6.0 4.0
1 9.0 11.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
- 在对Series或DataFrame重新索引时，也可以指定一个填充值：
df1.reindex(columns=df2.columns, fill_value=0)
#输出
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
- 默认情况下，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后沿着行一直向下广播。
- 如果某个索引值在DataFrame的列或Series的索引中找不到，则参与运算的两个对象就会被重新索引以形成并集。
函数应用和映射
- NumPy的ufuncs(元素级数组方法）也可以用于操作pandas对象：
#示例 np.abs(frame)
- 另一种常见的操作是，将函数应用到各列或行所形成的一维数组上。使用DataFrame的 apply 方法。
frame = DataFrame(np.random.randn(4,3), columns=list('bde'), index=[1,2,3,4])
print (frame)
f = lambda x:x.max() - x.min()
print (frame.apply(f))
print (frame.apply(f, axis=1))
#输出
b d e
1 0.756197 2.094682 -2.139083
2 0.231391 -0.682302 0.908212
3 0.447181 -0.172543 0.221593
4 -0.500720 0.248337 -0.034403
b 1.256918
d 2.776984
e 3.047295
dtype: float64
1 4.233765
2 1.590513
3 0.619723
4 0.749058
dtype: float64
- 元素级的Python函数也是可以用的：
format = lambda x: '%.2f' %x
print (frame.applymap(format))
之所以叫applymap，是因为Series有一个勇于应用元素级函数的map方法：
print (frame['e'].map(format))
#输出
b d e
1 -0.84 0.10 1.07
2 0.56 -0.49 -1.98
3 -0.60 -1.57 -1.42
4 0.53 -0.85 -0.01
1 1.07
2 -1.98
3 -1.42
4 -0.01
Name: e, dtype: object
排序和排名
- 要对行或列索引进行排序（按字典顺序），可使用 sort_index 方法，它将返回一个已排序的心对象:
obj = Series(range(4), index=['d', 'a', 'b', 'c']) print (obj.sort_index()) #输出 a 1 b 2 c 3 d 0 dtype: int64
默认升序，降序如下：
obj.sort_index(axis=1, ascending=False)
- 按值对Series进行排序，可使用其 order 方法：
- 在DataFrame上，将一个或多个列的名字传递给 by 选项即可根据一个或多个列中的值进行排序：
frame = DataFrame({'b':[4, 7, -3, 2], 'a':[0, 1, 0 , 1]})
print (frame.sort_values(by=['a','b']))
#输出
a b
2 0 -3
0 0 4
3 1 2
1 1 7
带有重复值的轴索引
- 许多pandas函数（如reindex）要求标签唯一，但这并不是强制性的。
obj = Series(range(5),index=['a', 'a', 'b', 'b', 'c'])
索引的 is_unique 属性可以告诉你它的值是否唯一
obj.index.is_unique
- 对于带有重复值的索引，如果某个索引对应多个值，则返回一个Series，而对应单个值的，则返回一个标量值。
- 对DataFrame的行进行索引时也是如此。
汇总和计算描述统计
- pandas对象拥有一组常用的数学和统计方法。它们大部分都属于约简和汇总统计，用于从Series中提取单个值（如sum或mean）或从DataFrame的行或列中提取一个Series。
df = DataFrame([[1.4, np.nan], [7.1, -4.5], [np.nan, np.nan], [0.75, -1.3]], index=['a', 'b', 'c', 'd'], columns=['one', 'two']) print (df) print (df.sum()) print (df.sum(axis=1)) #axis 约简的轴。DataFrame的行用0，列用1 #输出 one two a 1.40 NaN b 7.10 -4.5 c NaN NaN d 0.75 -1.3 one 9.25 two -5.80 dtype: float64 a 1.40 b 2.60 c NaN d -0.55 dtype: float64
NA值会自动被排除，除非整个切片（这里指的是行或列）都是NA。通过 skipna 选项可以禁用该功能。
- 有些方法（如 idxmin 和 idxmax ）返回的是间接统计（比如达到最小值或最大值的索引）
相关系数和协方差
- Series的 corr 方法用于计算两个Series中重叠的、非NA的、按索引对齐的值的相关系数。与此类似，cov 用于计算协方差。
- DataFrame的 corr 和 cov 方法将以DataFrame的形式返回完整的相关系数或协方差矩阵。
唯一值、值计数以及成员资格
- unique 函数可以得到Series中的唯一值数组：
obj = Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c']) uniques = obj.unique() print (uniques) #输出 ['c' 'a' 'd' 'b']
返回的唯一值是为排序的，可使用 uniques.sort() 进行排序
- value_counts 用于计算一个Series中各值出现的频率：
print (obj.value_counts()) #输出 c 3 a 3 b 2 d 1 dtype: int64
结果是按值频率降序排列的。
pd.value_counts(obj.values, sort=False)
- isin 用于判断矢量化集合的成员资格，可用于选取Series中或DataFrame列中数据的子集：
mask = obj.isin(['b','c']) print (mask) #输出 0 True 1 False 2 False 3 False 4 False 5 True 6 True 7 True 8 True dtype: bool
处理缺失数据
- pandas使用浮点值 NaN（Not a Number）表示浮点和非浮点数组中的缺失数据，它只是一个用于被检测出来的标记而已：
string_data = Series(['aa', 'bb', np.nan, 'cc']) print (string_data.isnull()) #输出 0 False 1 False 2 True 3 False dtype: bool
Python内置的 None 值也会被当作NA处理。
- NA处理方法
| 方法 | 说明 |
| dropna | 根据各标签的值中是否存在缺失数据对轴标签进行过滤，可通过阀值调节对缺失值的容忍度 |
| fillna | 用指定值或插值方法（如ffill或bfill）填充缺失数据 |
| isnull | 返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值／NA，该对象的类型与源类型一样 |
| notnull | isnull的否定式 |
滤除缺失数据
- 对于一个Series，dropna 返回一个仅含非空数据和索引值的Series：
data = Series([1, np.nan, 3.5, np.nan, 7]) print (data.dropna()) #输出 0 1.0 2 3.5 4 7.0 dtype: float64
- 对于DataFrame对象，dropna 默认丢弃任何含有缺失值的行
传入 how='all' 将只丢弃全为 NA 的那些行：
data.dropna(how='all')
以这种方式丢弃列：
data.dropna(axis=1, how='all')
填充缺失数据
- 通常一个常数调用 fillna 就会将缺失值替换为那个常数：
df.fillna(0)
- 若通过一个字典调用 fillna ,就可以实现对不同的 列 填充不同的值：
df.fillna({1:0.5, 3:-1})
注：fillna 默认返回新对象，但也可以对现有对象进行修改：
#总是返回被填充对象的引用 _ = df.fillna(o, inplace=True)
- 对 reindex 有效的那些插值方法也可以用于fillna：
#df.fillna(method='ffill') df.fillna(method='ffill', limit=2) #（对于前向和后向填充）可以连续填充的最大数量 #输出 0 1 2 0 -2.512334 0.566809 -0.310823 1 1.480002 0.089615 -0.876138 2 1.446703 0.089615 -0.705835 3 -0.241433 0.089615 0.897966 4 0.028517 NaN 0.897966 5 -0.045509 NaN 0.897966
层次化索引
- 层次化索引能使你能在一个轴上拥有多个（两个以上）索引级别：
data = Series(np.random.randn(10), index=[['a','a','a','b','b','b','c','c','d','d'],[1,2,3,1,2,3,1,2,1,2]]) print (data) print (data.index) #输出 a 1 -0.041274 2 1.288469 3 -0.731776 b 1 1.411813 2 -1.108839 3 -0.689199 c 1 -0.185918 2 0.803436 d 1 0.094525 2 0.692778 dtype: float64 MultiIndex(levels=[[u'a', u'b', u'c', u'd'], [1, 2, 3]], labels=[[0, 0, 0, 1, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 0, 1]])
- 对于一个层次化索引的对象选取数据子集操作：
data['b'] data['b':'c'] data.ix[['b', 'd']]
在内层中选取：
data[:, 2] #输出 a 0.780424 b 0.034343 c -1.635875 d -1.068981 dtype: float64
重排分级顺序
- 重新调整某条轴上各级别的顺序，swaplevel 接收两个级别编号或名称，并返回互换了级别的新对象（但数据不会发生变化）：
frame = DataFrame(np.arange(12).reshape(4,3), index=[['a','a','b','b'], [1,2,1,2]], columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']]) frame.index.names = ['key1', 'key2'] frame.columns.names = ['state', 'color'] #输出 state Ohio Colorado color Green Red Green key1 key2 a 1 0 1 2 2 3 4 5 b 1 6 7 8 2 9 10 11 frame.swaplevel('key1', 'key2')
- sortlevel根据单个级别中的值对数据进行排序（稳定）：
frame.sort_index(level=1) #输出 state Ohio Colorado color Green Red Green key1 key2 a 1 0 1 2 b 1 6 7 8 a 2 3 4 5 b 2 9 10 11
- 交换级别：
frame.swaplevel(0,1).sort_index(level=0) #输出 state Ohio Colorado color Green Red Green key2 key1 1 a 0 1 2 b 6 7 8 2 a 3 4 5 b 9 10 11
根据级别汇总统计
- 许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。
#示例 frame.sum(level='key2') #输出 state Ohio Colorado color Green Red Green key2 1 6 8 10 2 12 14 16
frame.sum(level='color', axis=1) #输出 color Green Red key1 key2 a 1 2 1 2 8 4 b 1 14 7 2 20 10
使用DataFrame的列
- 人们经常想要将DataFrame的一个或多个列当作索引来用，或者可能希望将行索引变成DataFrame的列：
frame = DataFrame({'a':range(7), 'b':range(7,0,-1), 'c':['one','one','one','two','two','two','two'],
'd':[0,1,2,0,1,2,3]})
print frame
#输出
a b c d
0 0 7 one 0
1 1 6 one 1
2 2 5 one 2
3 3 4 two 0
4 4 3 two 1
5 5 2 two 2
6 6 1 two 3
- DataFrame的 set_index 函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame：
frame2 = frame.set_index(['c','d']) #输出 a b c d one 0 0 7 1 1 6 2 2 5 two 0 3 4 1 4 3 2 5 2 3 6 1
- reset_index 的功能跟 set_index 刚好相反，层次化索引的级别会被转移到列里面：
frame2.reset_index()