Pandas学习（四）

变形

透视表

1.pivot

一般状态下，数据在DataFrame会以压缩（stacked）状态存放.

pivot函数可将某一列作为新的cols.

• 1.index：用于制作新框架索引的列。如果为None，则使用现有索引。

• 2.columns：用于制作新框架列的列。

• 3.values：用于填充新框架值的列。如果未指定，将使用所有剩余的列，并且结果将具有按层次结构索引的列。

>>> import pandas as pd
>>> import numpy as np
>>> df = pd.read_csv('data/table.csv')
>>> df.head()
  School Class    ID Gender   Address  Height  Weight  Math Physics
0    S_1   C_1  1101      M  street_1     173      63  34.0      A+        
1    S_1   C_1  1102      F  street_2     192      73  32.5      B+        
2    S_1   C_1  1103      M  street_2     186      82  87.2      B+        
3    S_1   C_1  1104      F  street_2     167      81  80.4      B-        
4    S_1   C_1  1105      F  street_4     159      64  84.8      B+        
>>> df.pivot(index='ID',columns='Gender',values='Height').head()
Gender      F      M
ID
1101      NaN  173.0
1102    192.0    NaN
1103      NaN  186.0
1104    167.0    NaN
1105    159.0    NaN

2.pivot_table

pivot_table比pivot功能更强大，但是也更耗时。

• 1.aggfunc：对组内进行聚合统计，可传入各类函数，默认为’mean’

>>> pd.pivot_table(df,index='School',columns='Gender',values='Height',aggfunc=['mean','sum']).head()
              mean               sum      
Gender           F           M     F     M
School
S_1     173.125000  178.714286  1385  1251
S_2     173.727273  172.000000  1911  1548

• 2.margins：汇总边际状态

>>> pd.pivot_table(df,index='School',columns='Gender',values='Height',aggfunc=['mean','sum'],margins=True,margins_name='all').head()
# margins_name可以设置名字，默认为'All'
              mean                           sum
Gender           F           M         all     F     M   all
School
S_1     173.125000  178.714286  175.733333  1385  1251  2636
S_2     173.727273  172.000000  172.950000  1911  1548  3459
all     173.473684  174.937500  174.142857  3296  2799  6095

• 3.行、列、值都可以为多级

>>> pd.pivot_table(df,index=['School','Class'],
...                columns=['Gender','Address'],
...                values=['Height','Weight'])
               Height                    ...   Weight
Gender              F                    ...        M
Address      street_1 street_2 street_4  ... street_5 street_6 street_7    
School Class                             ...
S_1    C_1        NaN    179.5    159.0  ...      NaN      NaN      NaN    
       C_2        NaN      NaN    176.0  ...     68.0     53.0      NaN    
       C_3      175.0      NaN      NaN  ...      NaN      NaN     82.0    
S_2    C_1        NaN      NaN      NaN  ...      NaN      NaN     84.0    
       C_2        NaN      NaN      NaN  ...    100.0      NaN      NaN    
       C_3        NaN      NaN    157.0  ...     88.0      NaN      NaN    
       C_4        NaN    176.0      NaN  ...      NaN      NaN     82.0    

[7 rows x 24 columns]

3.crosstab

交叉表是一种特殊的透视表，典型的用途如分组统计

# 统计关于街道和性别分组的频数
>>> pd.crosstab(index=df['Address'],columns=df['Gender'])
Gender    F  M
Address
street_1  1  2
street_2  4  2
street_4  3  5
street_5  3  3
street_6  5  1
street_7  3  3

• 1.values、aggfunc：分组对某些数据进行聚合操作，这两个参数必须成对出现

>>> pd.crosstab(index=df['Address'],columns=df['Gender'],
            values=np.random.randint(1,20,df.shape[0]),aggfunc='min')
# 默认参数等于如下方法：
# pd.crosstab(index=df['Address'],columns=df['Gender'],values=1,aggfunc='count')

Gender     F   M
Address
street_1  16   3
street_2   5   2
street_4   5   1
street_5   6   2
street_6   2  15
street_7   1   7

• 2.② 除了边际参数margins外，还引入了normalize参数，可选’all’,’index’,’columns’参数值

>>> pd.crosstab(index=df['Address'],columns=df['Gender'],normalize='all',margins=True)
Gender           F         M       All
Address
street_1  0.028571  0.057143  0.085714
street_2  0.114286  0.057143  0.171429
street_4  0.085714  0.142857  0.228571
street_5  0.085714  0.085714  0.171429
street_6  0.142857  0.028571  0.171429
street_7  0.085714  0.085714  0.171429
All       0.542857  0.457143  1.000000

其他变形方法

1.melt

melt函数可以认为是pivot函数的逆操作，将unstacked状态的数据，压缩成stacked，使“宽”的DataFrame变“窄”

>>> df_m = df[['ID','Gender','Math']]
>>> df_m.head()
     ID Gender  Math
0  1101      M  34.0
1  1102      F  32.5
2  1103      M  87.2
3  1104      F  80.4
4  1105      F  84.8

melt函数中的id_vars表示需要保留的列，value_vars表示需要stack的一组列

2. 压缩与展开

• stack：这是最基础的变形函数，总共只有两个参数：level和dropna

• unstack：stack的逆函数，功能上类似于pivot_table

哑变量与因子化

1.Dummy Variable（哑变量）

主要介绍get_dummies函数，其功能主要是进行one-hot编码：

>>> df_d = df[['Class','Gender','Weight']]
>>> df_d.head()
  Class Gender  Weight
0   C_1      M      63
1   C_1      F      73
2   C_1      M      82
3   C_1      F      81
4   C_1      F      64
>>> pd.get_dummies(df_d[['Class','Gender']]).join(df_d['Weight']).head()
   Class_C_1  Class_C_2  Class_C_3  Class_C_4  Gender_F  Gender_M  Weight
0          1          0          0          0         0         1      63  
1          1          0          0          0         1         0      73  
2          1          0          0          0         0         1      82  
3          1          0          0          0         1         0      81  
4          1          0          0          0         1         0      64  
>>> #可选prefix参数添加前缀，prefix_sep添加分隔符

2.factorize方法

该方法主要用于自然数编码，并且缺失值会被记做-1，其中sort参数表示是否排序后赋值

>>> codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b'], sort=True)
>>> codes
array([ 1, -1,  0,  2,  1], dtype=int64)
>>> uniques
array(['a', 'b', 'c'], dtype=object)