利用Python进行数据分析-07-汇总和计算描述统计

1、sum函数

df = pd.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'])

df
Out[6]: 
    one  two
a  1.40  NaN
b  7.10 -4.5
c   NaN  NaN
d  0.75 -1.3

df.sum()
Out[7]: 
one    9.25
two   -5.80
dtype: float64

df.sum(axis=1)  #NA值会自动排除，除非整个切片添加skipna禁用该功能
Out[8]: 
a    1.40
b    2.60
c    0.00
d   -0.55
dtype: float64

df.mean(axis=1,skipna = False)  #skipna 禁用na
Out[10]: 
a      NaN
b    1.300
c      NaN
d   -0.275
dtype: float64

df.idxmax()  #idxmax和idxmin返回的是间接统计（比如达到最小值和最大值的索引）
Out[13]: 
one    b
two    d
dtype: object

df.cumsum() #案列累计
Out[14]: 
    one  two
a  1.40  NaN
b  8.50 -4.5
c   NaN  NaN
d  9.25 -5.8

一次性产生多个汇总

df.describe()
Out[15]: 
            one       two
count  3.000000  2.000000
mean   3.083333 -2.900000
std    3.493685  2.262742
min    0.750000 -4.500000
25%    1.075000 -3.700000
50%    1.400000 -2.900000
75%    4.250000 -2.100000
max    7.100000 -1.300000

对于非数值数据，describe会产生另外一种汇总统计：

obj = pd.Series(['a','a','b','c']*4) 

obj.describe()
Out[17]: 
count     16
unique     3
top        a
freq       8
dtype: object

2、Series的corr用于计算两个Series中重叠的、非NA的按索引对齐的相关系数，类似COV用于计算协方差

DataFrame的corr和cov将以DataFrame的形式返回完整的相关系数或协方差矩阵

利用DataFrame的corrwith方法，你可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将会返回另一个Series（针对各列进行计算）

3、Series

value_count计算频数    obj.unique.sort()排序加唯一值

value_count适用于任何数组和序列

isin 计算一个Series各值是否包含于传入的值序列中的 布尔型数组

4、处理缺失数据

1、Series滤除缺失数据：dropna方法

DataFrame滤除用dropna方法会滤除含有NA的行和列：

from numpy import nan as NA

data = pd.DataFrame([[1.,6.5,3],[1,NA,NA],[NA,NA,NA],[NA,6.5,3.]])

cleaned = data.dropna()

data
Out[64]: 0 1 2 0 1 6.5 3 1 1 NaN NaN 2 NaN NaN NaN 3 NaN 6.5 3 cleaned Out[65]: 0 1 2 0 1 6.5 3

 

传入how =‘all’将只会丢弃全为NA的那些行

data.dropna(how = 'all')
Out[66]: 
    0    1   2 0 1 6.5 3 1 1 NaN NaN 3 NaN 6.5 3

thresh=3，会在一行中至少有 3 个非 NA 值时将其保留。

df = pd.DataFrame(np.random.randn(7,3))

df
Out[70]: 
          0         1         2
0 -0.182777  0.122331  1.177341
1 -0.113750  0.565018  0.460551
2  1.569241 -0.244783 -0.584233
3  1.230427 -0.749321 -0.408792
4  1.342502  1.474066 -1.078444
5  0.730472 -0.835126  0.845470
6 -0.455549 -1.051597  0.875379

df.ix[:4,1] = NA;df.ix[:2,2] = NA

df
Out[72]: 0 1 2 0 -0.182777 NaN NaN 1 -0.113750 NaN NaN 2 1.569241 NaN NaN 3 1.230427 NaN -0.408792 4 1.342502 NaN -1.078444 5 0.730472 -0.835126 0.845470 6 -0.455549 -1.051597 0.875379 df.dropna(thresh =3) Out[73]: 0 1 2 5 0.730472 -0.835126 0.845470 6 -0.455549 -1.051597 0.875379

填充缺失数据：

常数调用fillna会将缺失值替换为那个常数值：

df.fillna(0)
Out[75]: 
          0         1         2
0 -0.182777  0.000000  0.000000
1 -0.113750  0.000000  0.000000
2  1.569241  0.000000  0.000000
3  1.230427  0.000000 -0.408792
4  1.342502  0.000000 -1.078444
5  0.730472 -0.835126  0.845470
6 -0.455549 -1.051597  0.875379

df.fillna({1:1.5555,2:111111})    #1:1.5555代表在第一列找到NA值填充为1.5555
Out[76]: 0 1 2 0 -0.182777 1.555500 111111.000000 1 -0.113750 1.555500 111111.000000 2 1.569241 1.555500 111111.000000 3 1.230427 1.555500 -0.408792 4 1.342502 1.555500 -1.078444 5 0.730472 -0.835126 0.845470 6 -0.455549 -1.051597 0.875379

fillna默认会返回新的对象，同时也可以在旧的对象上进行修改：

_ = df.fillna(0,inplace = True)

df
Out[79]: 
          0         1         2
0 -0.182777  0.000000  0.000000
1 -0.113750  0.000000  0.000000
2  1.569241  0.000000  0.000000
3  1.230427  0.000000 -0.408792
4  1.342502  0.000000 -1.078444
5  0.730472 -0.835126  0.845470
6 -0.455549 -1.051597  0.875379

对reindex适用的方法同样适用于fillna：

df.fillna(method = 'ffill')
Out[82]: 
          0         1         2 0 0.441535 -0.330724 0.789183 1 0.666540 1.958989 -0.817482 2 -2.027360 0.416607 0.052060 3 -0.163996 -0.682905 0.926443 4 -1.163515 1.788535 -2.014879 5 0.483060 -1.225616 -0.021665 df.fillna(method='ffill',limit = 2) Out[83]: 0 1 2 0 0.441535 -0.330724 0.789183 1 0.666540 1.958989 -0.817482 2 -2.027360 0.416607 0.052060 3 -0.163996 -0.682905 0.926443 4 -1.163515 1.788535 -2.014879 5 0.483060 -1.225616 -0.021665

 

 

2、层次化索引

在一个轴上拥有多个（两个以上）的索引级别，可以低维度形式处理高纬度数据。创建一个Series，并用一个列表或数组组成的列表作为索引。

data =pd.Series(np.random.randn(10),index = [['a','a','a','b','b','b','c','c','d','d'],[1,2,3,1,2,3,1,2,2,3]]) data Out[90]: a 1 1.263309 2 -1.726591 3 0.084191 b 1 3.110524 2 -1.285000 3 0.741029 c 1 -1.443983 2 -0.775486 d 2 1.340332 3 -0.066965 dtype: float64

可用unstack聚合函数将DataFrame聚合：

data.unstack()           #逆运算是stack
Out[92]: 
          1         2         3
a  1.263309 -1.726591  0.084191
b  3.110524 -1.285000  0.741029
c -1.443983 -0.775486 NaN d NaN 1.340332 -0.066965

重排分级顺序：

frame = pd.DataFrame(np.arange(12).reshape((4,3)),index = [['a','a','b','b'],[1,2,1,2]],columns = [['Ohio','Ohio','Colorado'],['Green','Red','Green']]) frame Out[101]: Ohio Colorado Green Red Green a 1 0 1 2 2 3 4 5 b 1 6 7 8 2 9 10 11 frame.index.names = ['key1','key2'] frame.columns.names = ['state','color'] frame Out[104]: 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

 

 

用swaplevel来进行转换外层级别：

frame.swaplevel('key1','key2') Out[105]: state Ohio Colorado color Green Red Green key2 key1 1 a 0 1 2 2 a 3 4 5 1 b 6 7 8 2 b 9 10 11

 

sortlevel（1）  swaplevel（0,1） 对索level进行排序

使用DataFrame的列：DataFrame的sex_index函数会将其一个或多个列转换为行索引，并创建一个新索引

frame = pd.DataFrame({'a':range(7),'b':range(7,0,-1),'c':['one','one','one','two','two','two','tow'],'d':[0,1,2,0,1,2,3]}) frame Out[115]: 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 tow 3 frame2 = frame.set_index(['c','d']) #默认情况下，那些列会从DataFrame中移除，但可以添加 drop = False 来 frame2 Out[117]: a b c d one 0 0 7 1 1 6 2 2 5 two 0 3 4 1 4 3 2 5 2 tow 3 6 1

不考虑索引类型的、基于位置的索引，可以使用Series的iget_value方法和DataFrame的irow和icol方法：

ser3 = pd.Series(range(3),index = [-5,1,3])

ser3.iget_value(2)      #基于索引位置的值
Out[129]: 2

frame = pd.DataFrame(np.arange(6).reshape(3,2),index = [2,0,1])

转载于:https://www.cnblogs.com/groupe/p/4938191.html