数据科学库pandas笔记2

对于pandas来说，掌握了Series和DataFrame的基本使用后，pandas还提供了很多高阶的函数与方法可以实现更加高级的功能，使用它们可以提高分析的效率，满足更多的需求。

pandas高阶函数与方法

依旧以一个简单的DataFrame为例：

In [161]: df
Out[161]:
  city education  top   avg work_year
0   上海        本科    9   8.0        3年
1   广州        硕士   15  11.0        2年
2   广州        本科   12  10.0     应届毕业生
3   北京        本科   13  12.0        2年
4   北京        本科   11   8.0        1年

下面的函数或者方法操作都是以这个DataFrame对象为例。

1. 转置方法T
这个方法可以实现行标签和列标签的转置，常用于矩阵运算方面。

In [161]: df
Out[161]:
  city education  top   avg work_year
0   上海        本科    9   8.0        3年
1   广州        硕士   15  11.0        2年
2   广州        本科   12  10.0     应届毕业生
3   北京        本科   13  12.0        2年
4   北京        本科   11   8.0        1年

In [162]: df.T
Out[162]:
            0   1      2   3   4
city       上海  广州     广州  北京  北京
education  本科  硕士     本科  本科  本科
top         9  15     12  13  11
avg         8  11     10  12   8
work_year  3年  2年  应届毕业生  2年  1年

2. 排序与排名
pandas中的排序有两种，一种是对行或者列索引(sort_index)进行排序，另外一种是按值对一列即Series对象(sort_values)进行排序。

首先从常用的sort_values函数开始，当希望对一个DataFrame进行排序的时候，将一个列或者多个列传递给by参数即可。

In [164]: df
Out[164]:
  city education  top   avg work_year
0   上海        本科    9   8.0        3年
1   广州        硕士   15  11.0        2年
2   广州        本科   12  10.0     应届毕业生
3   北京        本科   13  12.0        2年
4   北京        本科   11   8.0        1年

In [165]: df.sort_values(by='avg') # 根据avg进行排序，默认是升序
Out[165]:
  city education  top   avg work_year
0   上海        本科    9   8.0        3年
4   北京        本科   11   8.0        1年
2   广州        本科   12  10.0     应届毕业生
1   广州        硕士   15  11.0        2年
3   北京        本科   13  12.0        2年

sort_values()函数默认是升序排序，如果想改为降序排序，只要将ascending参数设置为False即可。

In [166]: df.sort_values(by='avg',ascending=False)
Out[166]:
  city education  top   avg work_year
3   北京        本科   13  12.0        2年
1   广州        硕士   15  11.0        2年
2   广州        本科   12  10.0     应届毕业生
0   上海        本科    9   8.0        3年
4   北京        本科   11   8.0        1年

除了根据一列进行排序外，还可以根据多列进行排序，多列排序时传递给by参数的是一个包含多个列索引的列表。

In [168]: df.sort_values(by=['avg','city'])
Out[168]:
  city education  top   avg work_year
0   上海        本科    9   8.0        3年
4   北京        本科   11   8.0        1年
2   广州        本科   12  10.0     应届毕业生
1   广州        硕士   15  11.0        2年
3   北京        本科   13  12.0        2年

而基于行索引或者列索引的排序使用sort_index()函数

In [171]: df.index = ['d','a','c','b','e'] # 将行索引改为d,a,c,b,e

In [172]: df 
Out[172]:
  city education  top   avg work_year
d   上海        本科    9   8.0        3年
a   广州        硕士   15  11.0        2年
c   广州        本科   12  10.0     应届毕业生
b   北京        本科   13  12.0        2年
e   北京        本科   11   8.0        1年

In [173]: df.sort_index() # 根据行索引进行排序
Out[173]:
  city education  top   avg work_year
a   广州        硕士   15  11.0        2年
b   北京        本科   13  12.0        2年
c   广州        本科   12  10.0     应届毕业生
d   上海        本科    9   8.0        3年
e   北京        本科   11   8.0        1年

进行排序之后，你有可能会关心排名，比如这个学生的成绩排名第几。pandas提供了rank函数来计算排名，排名会从1开始一直到数组中有效数据的数量。

In [9]: df.avg.rank() # 根据avg的值进行排名
Out[9]:
0    1.5
1    4.0
2    3.0
3    5.0
4    1.5
Name: avg, dtype: float64

In [10]: df['rank'] = df.avg.rank() # 赋值进数据框，观看友好一点

In [11]: df
Out[11]:
  city education  top   avg work_year  rank
0   上海        本科    9   8.0        3年   1.5
1   广州        硕士   15  11.0        2年   4.0
2   广州        本科   12  10.0     应届毕业生   3.0
3   北京        本科   13  12.0        2年   5.0
4   北京        本科   11   8.0        1年   1.5

默认是升序排名，改为降序使用ascending=False参数即可。当排名的值有重复值的时候，rank()函数还提供了method参数，选用不同参数有不同的排名方法。

• method参数默认是使用平均值计算重复值的排名，即有两个重复值排名是前两位，那么这两个值的排名都是(1+2)/2=1.5
• 当使用method='max'的时候，重复值会使用最大值的排名，如有4个90分排名1,2,3,4名，那么这四个90的排名都是第四名
• 当使用method='min'的时候，重复值会使用最小值的排名，如4个90分排名1,2,3,4名，那么这四个90分的排名都是第一名，第5个分数排名第五名
• 当使用method='first'的时候，重复值的行索引小的会排在前面。

In [14]: df['rank'] = df.avg.rank(ascending=False,method='max')

In [15]: df
Out[15]:
  city education  top   avg work_year  rank
0   上海        本科    9   8.0        3年   5.0
1   广州        硕士   15  11.0        2年   2.0
2   广州        本科   12  10.0     应届毕业生   3.0
3   北京        本科   13  12.0        2年   1.0
4   北京        本科   11   8.0        1年   5.0

In [16]: df['rank'] = df.avg.rank(ascending=False,method='min')

In [17]: df
Out[17]:
  city education  top   avg work_year  rank
0   上海        本科    9   8.0        3年   4.0
1   广州        硕士   15  11.0        2年   2.0
2   广州        本科   12  10.0     应届毕业生   3.0
3   北京        本科   13  12.0        2年   1.0
4   北京        本科   11   8.0        1年   4.0

In [18]: df['rank'] = df.avg.rank(ascending=False,method='first')

In [19]: df
Out[19]:
  city education  top   avg work_year  rank
0   上海        本科    9   8.0        3年   4.0
1   广州        硕士   15  11.0        2年   2.0
2   广州        本科   12  10.0     应届毕业生   3.0
3   北京        本科   13  12.0        2年   1.0
4   北京        本科   11   8.0        1年   5.0

3. 唯一值与值计数

pandas中提供了一些函数提取Series中的信息，第一个函数是unique()，它可以得到Series中的唯一值数组。第二个是value_counts()它用于计算一个Series中各个值出现的次数。

In [20]: df
Out[20]:
  city education  top   avg work_year  rank
0   上海        本科    9   8.0        3年   4.0
1   广州        硕士   15  11.0        2年   2.0
2   广州        本科   12  10.0     应届毕业生   3.0
3   北京        本科   13  12.0        2年   1.0
4   北京        本科   11   8.0        1年   5.0

In [21]: df.city.unique()
Out[21]: array(['上海', '广州', '北京'], dtype=object)

In [22]: df.city.value_counts() # 广州出现次数为2，北京为2，上海为1
Out[22]:
广州    2
北京    2
上海    1
Name: city, dtype: int64

4. 描述统计信息的汇总
describe()函数用于一次性产生多个汇总统计：

In [23]: df.describe()
Out[23]:
             top        avg      rank
count   5.000000   5.000000  5.000000 # 计数
mean   12.000000   9.800000  3.000000 # 平均数
std     2.236068   1.788854  1.581139 # 标准差
min     9.000000   8.000000  1.000000 # 最小值
25%    11.000000   8.000000  2.000000 
50%    12.000000  10.000000  3.000000 # 中位数
75%    13.000000  11.000000  4.000000 # 众数
max    15.000000  12.000000  5.000000 # 最大值

cumsum用于累加，如想要计算avg的值的累加：

In [25]: df
Out[25]:
  city education  top   avg work_year  rank
0   上海        本科    9   8.0        3年   4.0
1   广州        硕士   15  11.0        2年   2.0
2   广州        本科   12  10.0     应届毕业生   3.0
3   北京        本科   13  12.0        2年   1.0
4   北京        本科   11   8.0        1年   5.0

In [26]: df.avg.cumsum()
Out[26]:
0     8.0
1    19.0
2    29.0
3    41.0
4    49.0
Name: avg, dtype: float64

In [27]: df['avg_sum'] = df.avg.cumsum()

In [28]: df
Out[28]:
  city education  top   avg work_year  rank  avg_sum
0   上海        本科    9   8.0        3年   4.0      8.0
1   广州        硕士   15  11.0        2年   2.0     19.0
2   广州        本科   12  10.0     应届毕业生   3.0     29.0
3   北京        本科   13  12.0        2年   1.0     41.0
4   北京        本科   11   8.0        1年   5.0     49.0

对数据进行分段，可以根据数据进行等分，比如根据top数值将数据进行5等分。cut函数是在pandas下，而不是在DataFrame下，使用需要注意。

In [30]: pd.cut(df.top,bins=5)
Out[30]:
0    (8.994, 10.2]
1     (13.8, 15.0]
2     (11.4, 12.6]
3     (12.6, 13.8]
4     (10.2, 11.4]
Name: top, dtype: category
Categories (5, interval[float64]): [(8.994, 10.2] < (10.2, 11.4] < (11.4, 12.6] < (12.6, 13.8] <
                                    (13.8, 15.0]]

In [31]: df['bins'] = pd.cut(df.top,bins=5)

In [32]: df
Out[32]:
  city education  top      ...        rank avg_sum           bins
0   上海        本科    9      ...         4.0     8.0  (8.994, 10.2]
1   广州        硕士   15      ...         2.0    19.0   (13.8, 15.0]
2   广州        本科   12      ...         3.0    29.0   (11.4, 12.6]
3   北京        本科   13      ...         1.0    41.0   (12.6, 13.8]
4   北京        本科   11      ...         5.0    49.0   (10.2, 11.4]

[5 rows x 8 columns]

cut函数还有个参数是labels，这个参数是标签，生活中类似于把90分以上的分为优秀，70~80分的为良好。可以把在某个档次的数据标记各自的标签。

In [34]: df['labels'] = pd.cut(df.top,bins=5,labels=list('abcde'))

In [35]: df
Out[35]:
  city education  top   avg work_year  rank  avg_sum           bins labels
0   上海        本科    9   8.0        3年   4.0      8.0  (8.994, 10.2]      a
1   广州        硕士   15  11.0        2年   2.0     19.0   (13.8, 15.0]      e
2   广州        本科   12  10.0     应届毕业生   3.0     29.0   (11.4, 12.6]      c
3   北京        本科   13  12.0        2年   1.0     41.0   (12.6, 13.8]      d
4   北京        本科   11   8.0        1年   5.0     49.0   (10.2, 11.4]      b