暑期实训Python 第八天--分组 转换 拼接

分组

df = pd.DataFrame({
    'Name':['BOSS','Jason','Jason','Han','BOSS','BOSS','Jason','BOSS'],
    'Year':[2016,2016,2016,2016,2017,2017,2017,2017],
    'Salary':[10000,2000,4000,5000,18000,25000,3000,4000],
    'Bonus':[3000,1000,1000,1200,4000,2300,500,1000]
})
gb = df.groupby('Name')
按两列 进行分组
df.groupby(["Name","Year"])

GroupBy 对象是可以迭代对象，所以可以用 for 循环遍历

for item in gb:
     print(item)

聚合运算

单个聚合运算：

gb.sum()
       Year  Salary  Bonus
Name                      
BOSS   8067   57000  10300
Han    2016    5000   1200
Jason  6049    9000   2500

gb.mean()
             Year   Salary        Bonus
Name                                    
BOSS   2016.750000  14250.0  2575.000000
Han    2016.000000   5000.0  1200.000000
Jason  2016.333333   3000.0   833.333333

gb.agg("sum")
       Year  Salary  Bonus
Name                      
BOSS   8067   57000  10300
Han    2016    5000   1200
Jason  6049    9000   2500

gb.agg("mean")
              Year   Salary        Bonus
Name                                    
BOSS   2016.750000  14250.0  2575.000000
Han    2016.000000   5000.0  1200.000000
Jason  2016.333333   3000.0   833.333333

多个聚合运算

gb.agg(['mean','sum'])
              Year       Salary               Bonus       
              mean   sum   mean    sum         mean    sum
Name                                                      
BOSS   2016.750000  8067  14250  57000  2575.000000  10300
Han    2016.000000  2016   5000   5000  1200.000000   1200
Jason  2016.333333  6049   3000   9000   833.333333   2500

gb.agg([np.sum, np.mean])
       Year              Salary         Bonus             
        sum         mean    sum   mean    sum         mean
Name                                                      
BOSS   8067  2016.750000  57000  14250  10300  2575.000000
Han    2016  2016.000000   5000   5000   1200  1200.000000
Jason  6049  2016.333333   9000   3000   2500   833.333333

每个列单独指定聚合算法

gb.agg({"Salary":np.mean,"Bonus":np.sum})

       Salary  Bonus
Name                
BOSS    14250  10300
Han      5000   1200
Jason    3000   2500

也可以接受 lambda 表达式

gb.agg({"Salary":np.mean, "Bonus":lambda x:x/2+10}

transform 方法

对 dataframe 中每个元素，按指定规则进行映射

df.loc[:,"Bonus"].transform((lambda x:x/2+10))
0    1510.0
1     510.0
2     510.0
3     610.0
4    2010.0
5    1160.0
6     260.0
7     510.0
Name: Bonus, dtype: float64

apply 函数

apply 函数既可以进行聚合运算，也可以进行映射运算，相当于 agg 和 transform 两个函数功能的集合

df.loc[:, "Year":"Bonus"].apply(lambda x: sum(x))
Year      16132
Salary    71000
Bonus     14000
dtype: int64

df.loc[:, "Year":"Bonus"].apply(lambda x: x / 2 + 10)
     Year   Salary   Bonus
0  1018.0   5010.0  1510.0
1  1018.0   1010.0   510.0
2  1018.0   2010.0   510.0
3  1018.0   2510.0   610.0
4  1018.5   9010.0  2010.0
5  1018.5  12510.0  1160.0
6  1018.5   1510.0   260.0
7  1018.5   2010.0   510.0

filter 函数

过滤掉不满足条件的组

通过列名进行筛选满足条件的列出来
df.filter(items=['one', 'three']) # 筛选列表中指定的列

df.filter(regex='e$', axis=1) #筛选列名满足正则表达式条件的列

df.filter(like='ear', axis=0) #筛选列名中包含ear的列

contat 拼接

pd.concat((df1, df2), axis=0) # 列对齐进行拼接，垂直拼接
pd.concat((df1, df2), axis=1) # 行对齐进行拼接，水平拼接

merge

df1 = pd.DataFrame(np.random.random((2, 3)), columns=['A', 'B', 'C'])
df2 = pd.DataFrame(np.random.random((2, 3)), columns=['B', 'C', 'D'])
df1.merge(df2, how="outer")
df1.merge(df2, how='inner')
df1.merge(df2, how='left')
df1.merge(df2, how='right')

一 对 一
一 对 多

pandas 数据可视化

matplotlib

 8.1 dataframe.plot()    折线图，可以反应数据的变化趋势
 8.2 dataframe.plot.bar()    条形图，可以方便对比不同列的数据的大小
   dataframe.plot.bar(stacked=True)    堆叠条形图，归一化之后，可以非常方便对比不同列的占比的大小
   dataframe.T.plot.barh() 横向的条形图
8.3 dataframe.T.plot.hist() 直方图，可以反应数据的分布情况

8.3 dataframe.T.plot.hist() 直方图，可以反应数据的分布情况

8.4 dataframe.T.plot.box() 箱型图，也可以从整体上比较概况反应数据的分布情况，
# 可以在图像反应 异常值的情况、中位数、1/4分位数、3/4分位数、上下边界

8.5 dataframe.T.plot.scatter() 散点图，反应数据变化的相关性

8.6 Series.plot.pie() 饼状图，反应数据占比情况