Python之Pandas库学习(2)

Pandas库数据的排序

对index进行排序

Pandas库中使用以下方法对Series和DataFrame的索引进行排序.

Series.sort_index(axis=0, level=None, ascending=True, inplace=False, kind=’quicksort’, na_position=’last’, sort_remaining=True) [官方文档]

DataFrame.sort_index(axis=0, level=None, ascending=True, inplace=False, kind=’quicksort’, na_position=’last’, sort_remaining=True, by=None) [官方文档]

axis : 要排序索引的轴.
level : 选择层次.
ascending : 升序(True)或降序(False), 默认为True.
inplace : 有返回值(False), 无返回值(True), 默认为False.
kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, 排序方式, 快速排序, 归并排序, 堆排序. 默认为’quicksort’
na_position : {‘first’, ‘last’}, 将无效值放在前面或后面. 默认为last.
sort_remaining : 对当前索引排序后, 是否对更深层次索引再次排序. 默认为True. 例如:

>>> import pandas as pd
>>> import numpy as np
>>> df = pd.DataFrame({'one' : pd.Series(np.random.randn(3), index=['a', 'b', 'c']), 'two' : pd.Series(np.random.randn(4), index=['a', 'b', 'c', 'd']), 'three' : pd.Series(np.random.randn(3), index=['b', 'c', 'd'])})
>>> df
        one       two     three
a  0.147325 -0.061285       NaN
b  1.019212  1.060940  0.634215
c -0.594902 -0.429536 -0.028395
d       NaN  0.571735  1.537099
>>> unsorted_df = df.reindex(index=['a', 'd', 'c', 'b'], columns=['three', 'two', 'one'])
>>> unsorted_df
      three       two       one
a       NaN -0.061285  0.147325
d  1.537099  0.571735       NaN
c -0.028395 -0.429536 -0.594902
b  0.634215  1.060940  1.019212
>>> unsorted_df.sort_index(ascending=False)
      three       two       one
d  1.537099  0.571735       NaN
c -0.028395 -0.429536 -0.594902
b  0.634215  1.060940  1.019212
a       NaN -0.061285  0.147325
>>> unsorted_df.sort_index(axis=1)
        one     three       two
a  0.147325       NaN -0.061285
d       NaN  1.537099  0.571735
c -0.594902 -0.028395 -0.429536
b  1.019212  0.634215  1.060940
>>> unsorted_df['three'].sort_index()
a         NaN
b    0.634215
c   -0.028395
d    1.537099
Name: three, dtype: float64

对values进行排序

Pandas库中使用以下方法对Series和DataFrame的值进行排序.

Series.sort_values(axis=0, ascending=True, inplace=False, kind=’quicksort’, na_position=’last’) [官方文档]

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind=’quicksort’, na_position=’last’) [官方文档]

by : axis轴上要排序的值对应索引的名称或名称列表.
axis : 要排序的轴.
ascending : 升序(True)或降序(False), 默认为True.
inplace : 有返回值(False), 无返回值(True), 默认为False.
kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, 排序方式, 快速排序, 归并排序, 堆排序. 默认为’quicksort’
na_position : {‘first’, ‘last’}, 将无效值放在前面或后面. 默认为last.

例如:

>>> df1 = pd.DataFrame({'one':[2,1,1,1],'two':[1,3,2,4],'three':[5,4,3,2]})
>>> df1
   one  two  three
0    2    1      5
1    1    3      4
2    1    2      3
3    1    4      2
>>> df1.sort_values(by='two')
   one  two  three
0    2    1      5
2    1    2      3
1    1    3      4
3    1    4      2
>>> df1.sort_values(by=['one','two'])
   one  two  three
2    1    2      3
1    1    3      4
3    1    4      2
0    2    1      5

pandas库数据的统计分析

数据的基本统计分析方法

方法	描述
.sum(axis=0, skipna=True, **kwargs)	计算0轴数据的总和, 排除NaN值, 可选参数
.count(axis=0, skipna=True, **kwargs)	计算0轴数据的总数, 排除NaN值, 可选参数
.mean(axis=0, skipna=True, kwargs) .median(axis=0, skipna=True, kwargs)	计算0轴数据的平均值, 中位数, 排除NaN值, 可选参数
.var(axis=0, skipna=True, kwargs) .std(axis=0, skipna=True, kwargs)	计算0轴数据的方差, 标准差, 排除NaN值, 可选参数
.min(axis=0, skipna=True, kwargs) .max(axis=0, skipna=True, kwargs)	计算0轴数据的最小值和最大值, 排除NaN值, 可选参数

仅适用于Series类型的方法:

方法	描述
.argmin() .argmax()	计算数据最小值, 最大值所在位置的索引位置(自动索引)
.idxmin() .idxmax()	计算数据最小值, 最大值所在位置的索引位置(自定义索引)

适用于Series和DataFrame的输出所有基本统计分析数据的方法:

.describe(percentiles=None, include=None, exclude=None) [官方文档]

percentiles : 可以选择特定的百分位数输出, 默认为[.25, .5, .75], 返回25%, 50%, 75%的数
include : 选定要统计的列或者数据.
- ‘all’ : 所有列都会被分别统计.
- 一串dtypes : 只对所选dtypes数据进行分析
- None(默认) : 对所有数据进行分析.
exclude : 类似于include, 只不过时选定不分析的数据类型, 默认为None.

注意 : 对于混合类型的DataFrame对象, describe()将限制只分析数值列, 如果没有, 则只分析分类列.
例如:

df = pd.DataFrame({'categorical': pd.Categorical(['d','e','f']), 'numeric': [1, 2, 3], 'object': ['a', 'b', 'c']})
>>> df
  categorical  numeric object
0           d        1      a
1           e        2      b
2           f        3      c
>>> df.describe()
       numeric
count      3.0
mean       2.0
std        1.0
min        1.0
25%        1.5
50%        2.0
75%        2.5
max        3.0
>>> df.describe(include='all')
       categorical  numeric object
count            3      3.0      3
unique           3      NaN      3
top              f      NaN      a
freq             1      NaN      1
mean           NaN      2.0    NaN
std            NaN      1.0    NaN
min            NaN      1.0    NaN
25%            NaN      1.5    NaN
50%            NaN      2.0    NaN
75%            NaN      2.5    NaN
max            NaN      3.0    NaN
>>> df.describe(include=[np.number])
       numeric
count      3.0
mean       2.0
std        1.0
min        1.0
25%        1.5
50%        2.0
75%        2.5
max        3.0
>>> df.describe(include=[np.object])
       object
count       3
unique      3
top         a
freq        1
>>> df.describe(include=['category'])
       categorical
count            3
unique           3
top              f
freq             1
>>> df.describe(exclude=[np.object])
       categorical  numeric
count            3      3.0
unique           3      NaN
top              f      NaN
freq             1      NaN
mean           NaN      2.0
std            NaN      1.0
min            NaN      1.0
25%            NaN      1.5
50%            NaN      2.0
75%            NaN      2.5
max            NaN      3.0

数据的累计统计分析方法

普通累计统计分析方法

方法	描述
.cumsum(axis=0, skipna=True, **kwargs)	依次给出前n个数的和
.cumprod(axis=0, skipna=True, **kwargs)	依次给出前n个数的积
.cummax(axis=0, skipna=True, **kwargs)	依次给出前n个数的最大值
.cummin(axis=0, skipna=True, **kwargs)	依次给出前n个数的最小值

例如:

>>> df = pd.DataFrame([[2.0, 1.0], [3.0, 2.0], [1.0, 0.0]], columns=['a', 'b'])
>>> df
     a    b
0  2.0  1.0
1  3.0  2.0
2  1.0  0.0
>>> df.cumsum()
     a    b
0  2.0  1.0
1  5.0  3.0
2  6.0  3.0
>>> df.cumsum(axis=1)
     a    b
0  2.0  3.0
1  3.0  5.0
2  1.0  1.0

滚动累计统计分析方法

方法	描述
.rolling(w).sum(axis=0)	依次计算相邻w个元素的和
.rollong(w).mean(axis=0)	依次计算相邻w个元素的算术平均值
.rolling(w).var(axis=0)	依次计算相邻w个元素的方差
.rolling(w).std(axis=0)	依次计算相邻w个元素的标准差
.rolling(w).min(axis=0) .rolling(w).max()	依次计算相邻w个元素的最小值和最大值

例如:

>>> df = pd.DataFrame([[2.0, 1.0], [3.0, 2.0], [1.0, 0.0]], columns=['a', 'b'])
>>> df.rolling(2).sum()
     a    b
0  NaN  NaN
1  5.0  3.0
2  4.0  2.0
>>> df.rolling(2, axis=1).sum()
    a    b
0 NaN  3.0
1 NaN  5.0
2 NaN  1.0

数据的相关性分析方法

方法	描述
.cov()	计算协方差矩阵
.corr(method=’pearson’)	计算相关系数矩阵, Pearson, Spearman, Kendall等系数

例如:

>>> df = pd.DataFrame([(2, 3), (0, 6), (6, 0), (2, 1)],columns=['dogs', 'cats'])
>>> df
   dogs  cats
0     2     3
1     0     6
2     6     0
3     2     1
>>> df.corr()
          dogs      cats
dogs  1.000000 -0.851064
cats -0.851064  1.000000