【学习】数据处理基础知识（基本功能）【pandas】

本章介绍pandas的重要功能，只记录一些重点内容

1、重新索引

pandas对象的一个重要方法是reindex，其作用是创建一个适应用新索引的新对象

#重新索引
obj = pd.Series([4.5, 7.2, -5.3, 3.6], index = ['d', 'b', 'a', 'c'])
obj
#调用该Series的reindex将会根据新索引进行重排。如果某个索引值当前不存在，就引入缺失值
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
obj2
obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value = 0)
#对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。method选项即可达到些目标
#使用ffill实现前向值填充
obj3 = pd.Series(['blue', 'purple', 'yellow'], index = [0, 2, 4])
obj3.reindex(range(6), method = 'ffill')
 
#reindex的（插值）method选项
#ffill 或 pad  前向填充值； bfill 或 backfill  后向填充值
obj2.ix[['a']]

输出结果

obj = pd.Series([4.5, 7.2, -5.3, 3.6], index = ['d', 'b', 'a', 'c'])
 
obj
Out[15]:
d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
 
obj2
Out[17]:
a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64
 
obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value = 0)
Out[18]:
a   -5.3
b    7.2
c    3.6
d    4.5
e    0.0
dtype: float64
 
obj3 = pd.Series(['blue', 'purple', 'yellow'], index = [0, 2, 4])
 
obj3.reindex(range(6), method = 'ffill')
Out[20]:
0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object
 
obj2.ix[['a']]
Out[21]:
a   -5.3
dtype: float64

reindex函数的参数

2、丢弃指定轴上的项

丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。

drop方法返回的是一个在指定轴上删除了指定值的新对象

#定义一个数组，索引为 ['a', 'b', 'c', 'd', 'e']
obj = pd.Series(np.arange(5.), index = ['a', 'b', 'c', 'd', 'e'])
obj
new_obj = obj.drop('c')
new_obj
obj.drop(['d', 'c'])
#对DataFrame, 可以删除任意轴上的索引值

3、索引、选取和过滤

为了在DataFrame的行上进行标签索引，引入专门的索引字段ix，可以通过NumPy式的标记法以及轴标签从DataFrame中选取行和列的子集。

#为了在DataFrame的行上进行标签索引，引入专门的索引字段ix，可以通过NumPy式的标记法以及轴标签从DataFrame中选取行和列的子集。
data = pd.DataFrame(np.arange(16).reshape((4, 4)), \
                    index = ['Ohio', 'Colorado', 'Utah', 'New York'], \
                    columns = ['one', 'two', 'three', 'four'])
data
 
data.ix['Colorado', ['two', 'three']]
data.ix[['Colorado', 'Utah'], [3, 0, 1]]
#3,0,1代表列标识
data.ix[2]
#第2行
data.ix[:'Utah', 'two']
data.ix[data.three>5, :3]

注意：在设计pandas时， 我觉得必须输入frame[:, col]才能选取列实在有些啰嗦，而且还很容易出错，因为列的选取是一种最常见的操作

于是，我就把所有的标签索引功能都放在ix中了

DataFrame的索引选项

4、算术运算和数据对齐

pd最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集

#算术运算和数据对齐
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, s2
s1 + s2
#list('bcd'),相当于列元素，b, c, d
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
df1 + df2
 
#在算术方法中填充值
df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)), columns = list('abcd'))
df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)), columns = list('abcde'))
df1
df2
#将它们相加时，没有重叠的位置会产生Na
df1 + df2
 
#使用df1的add方法，传入df2以及一个fill_value参数
df1.add(df2, fill_value = 0)
#在对Series或DataFrame重新索引时，也可以指定一个填充值
df1.reindex(columns = df2.columns, fill_value = 0)

灵活的算术方法

5、DataFrame和Series之间的运算

#DataFrame和Series之间的运算
arr = np.arange(12.).reshape((3, 4))
arr
arr[0]
arr - arr[0]
#以上叫做广播
#DataFrame和Series之间的运算示例
frame = pd.DataFrame(np.arange(12).reshape((4, 3)), columns = list('bde'), index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
#选取标识为0的行，即第一行
series = frame.ix[0]
frame
series
 
#默认情况下，DataFrame和Series之间的运算会将Series的索引匹配到DataFrame的列，然后沿着行一直向下广播
frame - series
 
#如果找不到，则参与运算的两个对象就会被重新索引以形成并集
series2 = pd.Series(range(3), index = list('bef'))
series2
frame + series2 

6、函数应用与映射

#函数应用和映射
frame = pd.DataFrame(np.random.randn(4, 3), columns = list('bde'), index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
frame
np.abs(frame)
 
#另一个常见的操作是，将函数应用到由各列或行所形成的一维数组上。DataFrame的apply方法即可实现功能
#x为输入值，x.max() - x.min()为输出值
f = lambda x: x.max() - x.min()
#输入列最大减最小
frame.apply(f)
#输入行最大减最小
frame.apply(f, axis = 1)

许多最为常见的数组都被实现 成DataFrame方法，如sum和mean，因此无需使用apply方法

除标量值外，传递给apply的函数还可以返回由多个值 组成的Series

def f(x):
    return pd.Series([x.min(), x.max()], index = ['min', 'max'])
#还是调用行
frame.apply(f)
 
frame.apply(f)
Out[82]: 
            b         d         e
min -2.460592 -0.224366 -0.474713
max  0.102727  0.183401  0.485874

#可以尝试一下调用列
frame.apply(f, axis = 1)
Out[83]: 
             min       max
Utah   -1.158899  0.201939
Ohio   -0.162430  0.485874
Texas  -0.474713 -0.112733
Oregon -2.460592  0.183401

#此外，元素级的python函数也是可以用的，假如你想得到frame中各个浮点值的格式化字符串，使用applymap即可
#输入元素x为两位小数的浮点字符
format = lambda x: '%.2f' % x
frame.applymap(format)

format = lambda x: '%.2f' % x
 
frame.applymap(format)
Out[85]:
            b      d      e
Utah    -1.16  -0.22   0.20
Ohio     0.10  -0.16   0.49
Texas   -0.22  -0.11  -0.47
Oregon  -2.46   0.18   0.16

之所以中到applymap, 是因为Series有一个用于应用元素级函数的map方法：

#之所以中到applymap, 是因为Series有一个用于应用元素级函数的map方法：
#指定e列
frame['e'].map(format)
Out[86]: 
Utah       0.20
Ohio       0.49
Texas     -0.47
Oregon     0.16
Name: e, dtype: object

7、排序与排名

根据条件对数据集排序 也是一种重要的内置运算。要对行或列索引进行排序，可使用sort_index方法，它将返回一个已排序的新对象

#排序和排名
obj = pd.Series(range(4), index = ['d', 'a', 'b', 'c'])
obj.sort_index()

obj.sort_index()
Out[88]:
a    1
b    2
c    3
d    0
dtype: int32

#根据任意一个轴上的索引进行排序
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)
#若要按值对Series进行排序，可使用其order方法
obj = pd.Series([4, 7, -3, 2])
obj
obj.order()
 
#在排序时，任何缺失 值默认都会被放到Series的末尾
obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
obj
obj.order()
#希望根据一个或多个列中的值进行排序，将一个或多个列的名字传递给by选项即可
frame = pd.DataFrame({'b':[4, 7, -2, 3], 'a':[0, 1, 0, -1]})
frame
frame.sort_index(by = 'b')
#根据a, b进行排序
frame.sort_index(by = ['a', 'b'])

排名跟排序关系密切，且它会增设一个排名值（从1开始， 一直到数组中有效数据的数量）

它跟numpy.argsort产生的间接排序索引差不多，只不过它可以根据某种规则破坏平级关系。

接下来介绍rank 方法。默认情况下，rank是通过“为各组分配一个平均排名”的方式破坏平级关系的

#排名，rank方法
obj = pd.Series([7, -5, 7, 4, 2, 0 ,4])
obj
obj.rank()

obj.rank()
Out[107]:
0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

#也可以根据值在原数据中出现的顺序给出排名
obj.rank(method = 'first')
 
obj.rank(method = 'first')
Out[108]:
0    6.0
1    1.0
2    7.0
3    4.0
4    3.0
5    2.0
6    5.0
dtype: float64

#按降序进行排名
obj.rank(ascending = False, method = 'max')
 
obj.rank(ascending = False, method = 'max')
Out[109]:
0    2.0
1    7.0
2    2.0
3    4.0
4    5.0
5    6.0
6    4.0
dtype: float64

8、带有重复值的轴索引

以上介绍的所有范例都有着唯一的轴标签（索引值）。虽然许多pd函数（如reindex）都要求标签唯一，但这并不是强制性的

#带有重复值的轴索引
obj = pd.Series(range(5), index = ['a', 'a', 'b', 'b', 'c'])
obj
#索引的is_unique属性可以告诉你它的值是唯一的
obj.index.is_unique

obj.index.is_unique
Out[112]: False

对于带有重复值的索引，数据选取的行为将会有些不同，如果某个索引对应多个值，则返回一个Series；而对应单个值的，则返回一个标量值

#对DataFrame的行进行索引时也是如此
df = pd.DataFrame(np.random.randn(4, 3), index = ['a', 'a', 'b', 'b'])
df
df.ix['b']

df
Out[116]:
          0         1         2
a  0.747649  2.128339 -1.192042
a  0.479568  1.813696 -0.197266
b  0.340015 -0.187988  1.244151
b -1.858814 -0.188538 -0.985478
 
df.ix['b']
Out[117]:
          0         1         2
b  0.340015 -0.187988  1.244151
b -1.858814 -0.188538 -0.985478

上面介绍 了pandas数据处理的基础知识，以后可以查阅并参考，接下来将pandas汇总和计算描述统计进行梳理