Day.5利用Pandas做数据处理（二）

蔚落 2023-02-14 00:29 5阅读 0赞

### 数据合并 ###

使用Join()合并，合并的方式是根据行和行进行合并。

# 使用join合并，着重关注的是 行的合并
    import pandas as pd 
    df1=pd.DataFrame({'Red':[1,3,5],'Green':[5,0,3]},index=list('abc'))
    df2=pd.DataFrame({'Blue':[1,9,8],'Yellow':[6,6,7]},index=list('cde'))
    print(df1)
    print(df2)
    '''
        Red  Green
    a    1      5
    b    3      0
    c    5      3
        Blue  Yellow
    c     1       6
    d     9       6
    e     8       7
    '''
    # 简单合并(默认是left左连接,以左侧df1为基础，连接右侧中index相同的行)
    df3=df1.join(df2,how='left')
    print(df3)
    '''
       Red  Green  Blue  Yellow
    a    1      5   NaN     NaN
    b    3      0   NaN     NaN
    c    5      3   1.0     6.0
    '''
    
    # 右连接：以左侧df2为基础，连接左侧df1中index相同的行
    df4 = df1.join(df2,how='right')
    print(df4)
    '''
       Red  Green  Blue  Yellow
    c  5.0    3.0     1       6
    d  NaN    NaN     9       6
    e  NaN    NaN     8       7
    '''
    
    # 外连接（左右两侧的index全连接，取并集）
    df5 = df1.join(df2,how='outer')
    print(df5)
    '''
       Red  Green  Blue  Yellow
    a  1.0    5.0   NaN     NaN
    b  3.0    0.0   NaN     NaN
    c  5.0    3.0   1.0     6.0
    d  NaN    NaN   9.0     6.0
    e  NaN    NaN   8.0     7.0
    '''
    
    # 合并多个DataFrame对象
    df6 = pd.DataFrame({'Brown':[3,4,5],'White':[1,1,2]},index=list('aed'))
    print(df6)
    df7 = df2.join([df1,df6])
    print(df7)
    '''
        Brown  White
    a      3      1
    e      4      1
    d      5      2
       Blue  Yellow  Red  Green  Brown  White
    c     1       6  5.0    3.0    NaN    NaN
    d     9       6  NaN    NaN    5.0    2.0
    e     8       7  NaN    NaN    4.0    1.0
    '''

merge（）函数是列和列合并。

# 使用merge，着重关注的是列的合并
    df1=pd.DataFrame({'名字':list('ABCDE'),'性别'['男','女','男','男','女'],'职称':['副教授','讲师','助教','教授','助教']},index=range(1001,1006))
    print(df1)
    '''
         名字 性别   职称
    1001  A  男  副教授
    1002  B  女   讲师
    1003  C  男   助教
    1004  D  男   教授
    1005  E  女   助教
    '''
    
    df2=pd.DataFrame({'名字':list('ABDAX'),'课程':['C++','计算机导论','汇编','数据结构','马克思原理'],'职称':['副教授','讲师','教授','副教授','讲师']},index=[1001,1002,1004,1001,3001])
    print(df2)
    '''
         名字     课程   职称
    1001  A    C++  副教授
    1002  B  计算机导论   讲师
    1004  D     汇编   教授
    1001  A   数据结构  副教授
    3001  X  马克思原理   讲师
    '''
    
    # merge默认根据左右对象中出现同名的列作为连接的键，且连接方式是how=’inner’内连接，内连接取两者交集
    print(pd.merge(df1,df2))
    '''
      名字 性别   职称     课程
    0  A  男  副教授    C++
    1  A  男  副教授   数据结构
    2  B  女   讲师  计算机导论
    3  D  男   教授     汇编
    '''
    # 指定列名合并,suffixes来设置重复列的名字
    print(pd.merge(df1,df2,on='名字',suffixes=['_1','_2']))
    '''
      名字 性别 职称_1  课程     职称_2
    0  A  男  副教授    C++     副教授
    1  A  男  副教授   数据结构  副教授
    2  B  女   讲师  计算机导论  讲师
    3  D  男   教授     汇编    教授
    '''
    
    # 左连接，根据左侧为准
    print(pd.merge(df1,df2,how='left'))
    '''
    名字 性别   职称     课程
    0  A  男  副教授    C++
    1  A  男  副教授   数据结构
    2  B  女   讲师  计算机导论
    3  C  男   助教    NaN
    4  D  男   教授     汇编
    5  E  女   助教    NaN
    '''
    
    # 右连接，根据右侧为准
    print(pd.merge(df1,df2,how='right'))
    '''
      名字   性别   职称     课程
    0  A    男  副教授    C++
    1  A    男  副教授   数据结构
    2  B    女   讲师  计算机导论
    3  D    男   教授     汇编
    4  X  NaN   讲师  马克思原理
    '''
    
    # 合并所有 取并集
    print(pd.merge(df1,df2,how='outer'))
    '''
      名字 性别   职称     课程
    0  A    男  副教授    C++
    1  A    男  副教授   数据结构
    2  B    女   讲师  计算机导论
    3  C    男   助教    NaN
    4  D    男   教授     汇编
    5  E    女   助教    NaN
    6  X  NaN   讲师  马克思原理
    '''
    
    # 根据多个键进行连接
    print(pd.merge(df1,df2,on=['职称','名字']))
    '''
     名字 性别  职称     课程
    0  A  男  副教授    C++
    1  A  男  副教授   数据结构
    2  B  女   讲师  计算机导论
    3  D  男   教授     汇编
    '''

### 多层索引 ###

这里简单介绍一下多层索引，多层级索引，将指标进行分层，索引具有层级结构，可以使得高维度的数据进行降维。

先来学习一下Series对象创建多层索引，并对索引对象查询。

import numpy as np
    import pandas as pd
    from pandas import Series,DataFrame
    
    # Series创建多层索引
    s = Series(np.random.randint(0,150,size=6),index=list('abcdef'))
    print(s) # 原索引
    s = Series(np.random.randint(0,150,size=6),
    index=[['a','a','b','b','c','c'],['期中','期末','期中','期末','期中','期末']]) # 创建多层索引
    print(s)
    
    
    # Series索引对象的获取
    # 取一个第一级索引
    print(s['a'])
    # 取多个第一级索引
    print(s[['a','b']])
    # 根据索引获取值
    print(s['a','期末'])
    
    # loc方法取值 根据标签名取值
    print(s.loc['a'])
    print(s.loc[['a','b']])
    print(s.loc['a','期末'])
    
    
    # # iloc方法取值 根据位置取值 (iloc计算的是最内层索引,直接跳过层级，最内层开始取)
    print(s.iloc[1])
    print(s.iloc[1:4])
    
    # 注：列值中的数字是随机数，这里不附上运行结果，可以先把复制过去，全部注释，然后一行一行的运行

接下来介绍DataFrame创建多层索引的三种方式，及其索引对象的查询。

import numpy as np
    import pandas as pd
    from pandas import Series,DataFrame
    
    # DataFrame创建多层索引
    # 方式一：index由两个数组组成
    df1 = DataFrame(np.random.randint(0,150,size=(6,4)),columns = ['shon','jack','meili','dafeng'],
                    index = [['python','python','math','math','En','En'],['期中','期末','期中','期末','期中','期末']])
    print(df1)
    
    # 方式二：特定结构
    class1=['python','python','math','math','En','En']
    class2=['期中','期末','期中','期末','期中','期末']
    m_index2=pd.MultiIndex.from_arrays([class1,class2])
    df2=DataFrame(np.random.randint(0,150,(6,4)),index=m_index2)
    print(df2)
    
    # 方式三：乘法方式 product意为乘法
    class1=['python','math','En']
    class2=['期中','期末']
    m_index2=pd.MultiIndex.from_product([class1,class2])
    df3=DataFrame(np.random.randint(0,150,(6,4)),index=m_index2)
    print(df3)
    
    # Series索引对象的获取
    
    # 获取列:
    print(df1['shon'])
    # 一级索引
    print(df1.loc['python'])
    # 多个一级索引
    print(df1.loc[['python','math']])
    # 取一行
    print(df1.loc['python','期末'])
    # 取一值
    print(df1.loc['python','期末'][0])
    # iloc是只取最内层的索引的
    print(df2.iloc[0])

### 时间序列 ###

时间序列是指将同一统计指标的数值按其发生的时间先后顺序排列而成的数列。时间序列分析的主要目的是根据已有的历史数据对未来进行预测。经济数据中大多数以时间序列的形式给出。根据观察时间的不同，时间序列中的时间可以是年份、季度、月份或其他任何时间形式，下面是如何创建时间序列。

import pandas as pd
    import numpy as np
    # 1. 生成一段时间范围
    '''
    data_range(start、end、periods)函数主要用于生成一个固定频率的时间索引，使用时须指定三个参数中的两个参数值，否则报错。
    
    时间序列频率:
        D 日历日的每天
        B 工作日的每天
        H 每小时
        T或min 每分钟
        S 每秒
        L或ms 每毫秒
        U 每微秒
        M 日历日的月底日期
        BM 工作日的月底日期
        MS 日历日的月初日期
        BMS 工作日的月初日期
    
    freq:日期偏移量，取值为string, 默认为'D'， freq='1h30min' freq='10D'
    periods:固定时期，取值为整数或None
    '''
    # -----------------
    
    date = pd.date_range(start='20200528',periods=10,freq='10D')
    print(date)
    
    '''
    
    DatetimeIndex(['2020-05-28', '2020-06-07', '2020-06-17', '2020-06-27',
                   '2020-07-07', '2020-07-17', '2020-07-27', '2020-08-06',
                   '2020-08-16', '2020-08-26'],
                  dtype='datetime64[ns]', freq='10D')
    '''
    
    
    # 根据closed参数选择是否包含开始和结束时间closed=None，left包含开始时间，不包含结束时间，right与之相反。
    data_time =pd.date_range(start='2020-05-09',end='2020-05-14',closed='left')
    print(data_time)
    '''
    DatetimeIndex(['2020-05-09', '2020-05-10', '2020-05-11', '2020-05-12',
                   '2020-05-13'],
                  dtype='datetime64[ns]', freq='D')
    '''
    
    # 2. 时间序列在dataFrame中的作用
    # 可以将时间作为索引
    index = pd.date_range(start='20200101',periods=10)
    df = pd.Series(np.random.randint(0,10,size = 10),index=index)
    print(df)
    '''
    2020-01-01    4
    2020-01-02    4
    2020-01-03    0
    2020-01-04    9
    2020-01-05    6
    2020-01-06    7
    2020-01-07    5
    2020-01-08    6
    2020-01-09    4
    2020-01-10    9
    Freq: D, dtype: int64
    '''
    # truncate这个函数将before指定日期之前的值全部过滤出去,after指定日期之后的值全部过滤出去.
    after = df.truncate(after='20200105')
    print(after)
    '''
    2020-01-01    9
    2020-01-02    4
    2020-01-03    7
    2020-01-04    8
    2020-01-05    9
    Freq: D, dtype: int64
    '''

# 接下来是对时间格式的处理，因为运行出来的结果较多，所以运行完一次，我们将print注释
    # 创建一个含有一千行的时间序列,时间跨度从2019年到2021年
    long_ts = pd.Series(np.random.randn(1000),index=pd.date_range('1/1/2019',periods=1000))
    #print(long_ts)
    
    # 根据年份获取
    result = long_ts['2020']
    #print(result)
    
    # 年份和日期获取
    result = long_ts['2020-05']
    #print(result)
    
    # 使用切片
    result = long_ts['2020-05-01':'2020-05-06']
    # print(result)
    
    # 通过between_time()返回位于指定时间段的数据集
    index=pd.date_range("2020-03-17","2020-03-30",freq="2H")
    ts = pd.Series(np.random.randn(157),index=index)
    #print(ts.between_time("7:00","17:00"))
    
    # 这些操作也都适用于dataframe
    index=pd.date_range('1/1/2020',periods=100)
    df = pd.DataFrame(np.random.randn(100,4),index=index)
    #print(df.loc['2020-04'])
    
    # 将时间戳转化成时间格式 某一个时间到1970年01月01日 00:00:00 的秒数或者毫秒数
    # 时间戳是现在时间到1970年01月01日 00:00:00的毫秒数或者秒数，可以将时间格式化表示成一个数值，方便时间的计算
    # 获取当前时间的时间戳
    import time 
    #print(time.time()) #1590704235.606594
    #pd.to_datetime(1590704235.606594,unit='s')
    
    # 时区转换：utc是协调世界时,时区是以UTC的偏移量的形式表示的
    # 查询时区名字 选择Asia/Shanghai
    import pytz
    #print(pytz.common_timezones)
    #pd.to_datetime(1590704235.606594,unit='s').tz_localize('UTC').tz_convert('Asia/Shanghai')
    
    # 处理一列
    df = pd.DataFrame([1590704235.606594, 1590704295.606594, 1590704355.606594],columns = ['time_stamp'])
    # 先赋予标准时区,再转换到东八区
    #pd.to_datetime(df['time_stamp'],unit='s').dt.tz_localize('UTC').dt.tz_convert('Asia/Shanghai')
    
    # 处理中文格式日期
    #pd.to_datetime('2020年5月20日',format='%Y年%m月%d日')

### 分组聚合 ###

这一部分我们学习对DataFrame的数据按照相应的格式进行分组，使用函数groupby()。

# 分组
    import pandas as pd 
    import numpy as np
    df=pd.DataFrame({'name':['BOSS','Lilei','Lilei','Han','BOSS','BOSS','Han','BOSS'],
                        'Year':[2018,2018,2018,2018,2019,2019,2019,2019],
                        'Salary':[999999,20000,25000,3000,9999999,999999,3500,999999],
                        'Bonus':[100000,20000,20000,5000,200000,300000,3000,400000]})
    display(df)
    '''
        name  Year   Salary   Bonus
    0   BOSS  2018   999999  100000
    1  Lilei  2018    20000   20000
    2  Lilei  2018    25000   20000
    3    Han  2018     3000    5000
    4   BOSS  2019  9999999  200000
    5   BOSS  2019   999999  300000
    6    Han  2019     3500    3000
    7   BOSS  2019   999999  400000
    '''
    
    # 根据name这一列进行分组
    group_by_name=df.groupby('name')
    print(type(group_by_name))
    # 查看分组
    print(group_by_name.groups)
    # 分组后的数量
    #print(group_by_name.count())
    '''
    <class 'pandas.core.groupby.generic.DataFrameGroupBy'> # df分组后返回的是一个DataFrameGroupBy的对象，不能直接查看它
    
    {'BOSS': Int64Index([0, 4, 5, 7], dtype='int64'),
    'Han': Int64Index([3, 6], dtype='int64'),
    'Lilei': Int64Index([1, 2], dtype='int64')}
    
           Year  Salary  Bonus
    name                      
    BOSS      4       4      4
    Han       2       2      2
    Lilei     2       2      2
    '''
    
    # 查看分组的情况
    for name,group in group_by_name:
        print(name)# 组的名字 共三组
        print(group)# 组具体内容
    '''
    BOSS
       name  Year   Salary   Bonus
    0  BOSS  2018   999999  100000
    4  BOSS  2019  9999999  200000
    5  BOSS  2019   999999  300000
    7  BOSS  2019   999999  400000
    Han
      name  Year  Salary  Bonus
    3  Han  2018    3000   5000
    6  Han  2019    3500   3000
    Lilei
        name  Year  Salary  Bonus
    1  Lilei  2018   20000  20000
    2  Lilei  2018   25000  20000
    '''
    
    # 可以选择分组
    print(group_by_name.get_group('BOSS'))
    # 按照某一列进行分组, 将name这一列作为分组的键，对year进行分组
    group_by_name=df['Year'].groupby(df['name'])
    print(group_by_name.count())
    '''
    name  Year   Salary   Bonus
    0  BOSS  2018   999999  100000
    4  BOSS  2019  9999999  200000
    5  BOSS  2019   999999  300000
    7  BOSS  2019   999999  400000
    
    name
    BOSS     4
    Han      2
    Lilei    2
    Name: Year, dtype: int64
    '''
    
    # 按照多列进行分组
    group_by_name_year=df.groupby(['name','Year'])
    for name,group in group_by_name_year:
        print(name)# 组的名字
        print(group)# 组具体内容
    '''
    ('BOSS', 2018)
       name  Year  Salary   Bonus
    0  BOSS  2018  999999  100000
    ('BOSS', 2019)
       name  Year   Salary   Bonus
    4  BOSS  2019  9999999  200000
    5  BOSS  2019   999999  300000
    7  BOSS  2019   999999  400000
    ('Han', 2018)
      name  Year  Salary  Bonus
    3  Han  2018    3000   5000
    ('Han', 2019)
      name  Year  Salary  Bonus
    6  Han  2019    3500   3000
    ('Lilei', 2018)
        name  Year  Salary  Bonus
    1  Lilei  2018   20000  20000
    2  Lilei  2018   25000  20000
    '''
    
    # 将某列数据按数据值分成不同范围段进行分组(groupby)运算
    # 准备数据，生产100个年龄，从20-70岁
    df = pd.DataFrame({'Age': np.random.randint(20, 70, 100),
                     'Sex': np.random.choice(['M', 'F'], 100)})
    # print(df)
    age_groups = pd.cut(df['Age'], bins=[19,40,65,100]) # 将Age列切成几个bins，分成了三个区间
    print(age_groups)  # 查看分组
    print(df.groupby(age_groups).count()) # 分组统计
    
    # 按‘Age’分组范围对性别(sex)进行分组统计
    print(pd.crosstab(age_groups, df['Sex']))
    '''
    Name: Age, Length: 100, dtype: category
    Categories (3, interval[int64]): [(19, 40] < (40, 65] < (65, 100]]
    
               Age  Sex
    Age                
    (19, 40]    51   51
    (40, 65]    43   43
    (65, 100]    6    6
    
    Sex         F   M
    Age              
    (19, 40]   27  24
    (40, 65]   21  22
    (65, 100]   1   5
    '''

聚合函数对一组值执行计算，并返回单个值。

以下是常用的聚合函数：

<table> 
 <thead> 
  <tr> 
   <th>mean</th> 
   <th>计算分组平均值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>count</td> 
   <td>分组中非NA值的数量</td> 
  </tr> 
  <tr> 
   <td>sum</td> 
   <td>非NA值的和</td> 
  </tr> 
  <tr> 
   <td>median</td> 
   <td>非NA值的算术中位数</td> 
  </tr> 
  <tr> 
   <td>std</td> 
   <td>标准差</td> 
  </tr> 
  <tr> 
   <td>var</td> 
   <td>方差</td> 
  </tr> 
  <tr> 
   <td>min</td> 
   <td>非NA值的最小值</td> 
  </tr> 
  <tr> 
   <td>max</td> 
   <td>非NA值的最大值</td> 
  </tr> 
  <tr> 
   <td>prod</td> 
   <td>非NA值的积</td> 
  </tr> 
  <tr> 
   <td>first</td> 
   <td>第一个非NA值</td> 
  </tr> 
  <tr> 
   <td>last</td> 
   <td>最后一个非NA值</td> 
  </tr> 
  <tr> 
   <td>mad</td> 
   <td>平均绝对偏差</td> 
  </tr> 
  <tr> 
   <td>mode</td> 
   <td>模</td> 
  </tr> 
  <tr> 
   <td>abs</td> 
   <td>绝对值</td> 
  </tr> 
  <tr> 
   <td>sem</td> 
   <td>平均值的标准误差</td> 
  </tr> 
  <tr> 
   <td>skew</td> 
   <td>样品偏斜度(三阶矩)</td> 
  </tr> 
  <tr> 
   <td>kurt</td> 
   <td>样品峰度(四阶矩)</td> 
  </tr> 
  <tr> 
   <td>quantile</td> 
   <td>样本分位数(百分位上的值)</td> 
  </tr> 
  <tr> 
   <td>cumsum</td> 
   <td>累积总和</td> 
  </tr> 
  <tr> 
   <td>cumprod</td> 
   <td>累积乘积</td> 
  </tr> 
  <tr> 
   <td>cummax</td> 
   <td>累积最大值</td> 
  </tr> 
  <tr> 
   <td>cummin</td> 
   <td>累积最小值</td> 
  </tr> 
 </tbody> 
</table>

import pandas as pd 
    import numpy as np
    df1=pd.DataFrame({'Data1':np.random.randint(0,10,5),
                      'Data2':np.random.randint(10,20,5),
                      'key1':list('aabba'),
                      'key2':list('xyyxy')})
    print(df1)
    '''
        Data1  Data2 key1 key2
    0      4     19    a    x
    1      6     17    a    y
    2      4     15    b    y
    3      5     14    b    x
    4      6     15    a    y
    '''
    
    # 按key1分组，进行聚合计算
    # 注意:当分组后进行数值计算时，不是数值类的列会被清除
    print(df1.groupby('key1').sum())
    '''
            Data1  Data2
    key1              
    a        10     40
    b         8     37
    '''
    
    # 只算data1 两种方式
    print(df1['Data1'].groupby(df1['key1']).sum()) # 1. 先取出列再分组求和
    print(df1.groupby('key1')['Data1'].sum()) #2.分组后求和
    '''
    key1
    a    16
    b     3
    Name: Data1, dtype: int64
    
    key1
    a    16
    b     3
    Name: Data1, dtype: int64
    '''
    
    # 使用agg()函数做聚合运算 aggregation() 意为聚合函数
    print(df1.groupby('key1').agg('sum'))
    # # 可以同时做多个聚合运算
    print(df1.groupby('key1').agg(['sum','mean','std']))
    '''
    Data1  Data2
    key1              
    a        10     51
    b         9     30
    
              Data1                          Data2              
           sum      mean       std   sum mean       std
    key1                                              
    a       10  3.333333  4.932883    51   17  0.000000
    b        9  4.500000  0.707107    30   15  4.242641
    '''
    
    
    # # 可自定义函数，传入agg方法中 grouped.agg(func)
    def peak_range(df):
        return df.max() - df.min() # 返回数值范围
    
    print(df1.groupby('key1').agg(peak_range))
    '''
            Data1  Data2
    key1              
    a         3      4
    b         3      0
    '''
    
    # 同时应用多个聚合函数
    print(df1.groupby('key1').agg(['mean', 'std', 'count', peak_range])) # 默认列名为函数名
    
    print(df1.groupby('key1').agg(['mean', 'std', 'count', ('range', peak_range)])) # 通过元组修改列名
    '''
                Data1                            Data2                          
              mean       std count peak_range  mean       std count peak_range
    key1                                                                      
    a     1.333333  1.154701     3          2    13  3.464102     3          6
    b     5.000000  2.828427     2          4    12  1.414214     2          2
    
                Data1                       Data2                      
              mean       std count range  mean       std count range
    key1                                                            
    a     1.333333  1.154701     3     2    13  3.464102     3     6
    b     5.000000  2.828427     2     4    12  1.414214     2     2
    '''
    
    # 给每列作用不同的聚合函数
    dict_mapping = {
        'Data1':['mean','max'],
        'Data2':'sum' }
    print(df1.groupby('key1').agg(dict_mapping))
    '''
    Data1     Data2
              mean max   sum
    key1                    
    a     5.333333   8    46
    b     7.000000   9    27
    '''
    
    
    # apply函数
    # apply函数是pandas里面所有函数中自由度最高的函数；函数可以作为参数放在apply中
    # 以统计抽烟和不抽烟人的性别，年龄和体重为例
    df1=pd.DataFrame({'sex':list('FFMFMMF'),'smoker':list('YNYYNYY'),'age': [21,30,17,37,40,18,26],
                      'weight':[120,100,132,140,94,89,123]})
    print(df1)
    '''
        sex smoker  age  weight
    0   F      Y   21     120
    1   F      N   30     100
    2   M      Y   17     132
    3   F      Y   37     140
    4   M      N   40      94
    5   M      Y   18      89
    6   F      Y   26     123
    '''
    def bin_age(age):
        if age >=18:
            return 1 # 成年
        else:
            return 0 # 未成年
        
    # 抽烟的年龄大于等18的
    print(df1['age'].apply(bin_age))
    df1['age'] = df1['age'].apply(bin_age) # 对年龄这一列进行转换，判断成年还是未成年
    print(df1)
    '''
    0    1
    1    1
    2    0
    3    1
    4    1
    5    1
    6    1
    Name: age, dtype: int64
    
      sex smoker  age  weight
    0   F      Y    1     120
    1   F      N    1     100
    2   M      Y    0     132
    3   F      Y    1     140
    4   M      N    1      94
    5   M      Y    1      89
    6   F      Y    1     123
    
    '''
    
    # 取出抽烟和不抽烟的体重前二
    def top(smoker,col,n=5):
        
        return smoker.sort_values(by=col)[-n:]
    # [-n:]切片，负号表示从末尾往前取
    
    print(df1.groupby('smoker').apply(top,col='weight',n=2))
    
    '''
              sex smoker  age  weight
    smoker                          
    N      4   M      N    1      94
           1   F      N    1     100
    Y      2   M      Y    0     132
           3   F      Y    1     140
    '''

### 分组案例 ###

下面我们来对一个电影评论数据进行案例分析，公号留言回复 *PandasMovie* 即可获取。

# 读取数据并观察
    data = pd.read_csv('pandas_movie.csv')
    print('数据的形状:', data.shape)
    # 数据的形状: (5043, 28)
    #print(data.head(5)) #发现索引4 有NaN
    
    # 处理缺失值
    data = data.dropna(how='any') # 将Nan去除
    print(data.head(5)) # 索引4被去除
    
    
    # 我们来分析一下导演和票房总收入（gross）的关系 通过分组排序来观察是否票房高的电影由知名导演拍摄
    # 按照导演分组计算票房总收入
    group_director = data.groupby(by='director_name')['gross'].sum()
    print(group_director)
    
    # ascending升降序排列，True升序
    result = group_director.sort_values()
    print(type(result)) # 查看分组后结果的数据的数据类型是Series，一维数组
    print(result) # 可以看到高票房的导演
    
    
    # 电影产量年份趋势
    from matplotlib import pyplot as plt
    import random
    # 按照年分分析电影产量的情况，以及电影的名称
    movie_years = data.groupby('title_year')['movie_title']
    print(movie_years.count())
    print(movie_years.count().index.tolist()) # 将索引列也就是年份的索引取出，并转换成列表格式
    print(movie_years.count().values) # 电影的数量
    x = movie_years.count().index.tolist()
    y = movie_years.count().values 
    plt.figure(figsize=(20,8),dpi=80)
    plt.plot(x,y)
    plt.show()

运行结果：

![format_png][]

![format_png 1][]

[![format_png 2][]][format_png 2 1]

**写在后面：**

今天学习是Pandas库的下半部分~

周末快要到了，周末我们的学习计划会停一停~

坚持学习和输出哦~

记得打卡，在群里分享你的代码和笔记~

![format_png 3][]

好文章，我在看❤

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9xaWFTbDNSVDFSYzJteTB2dm01Y2ZnUHNHbUsxUFNibW84Wlk5RHFicFg4Wm5JZFUyU2pRWEU3YTBBQVZib3RmYkRYcXJJczZLUW83TmhVWHVrd1J6YWcvNjQw?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2dpZi9iOTZDaWJDdDcwaWFaVldMcUtXWXFUb0JCb0xUZU5jMk5tbHk0REJnbmoyb21Vcm5XdWtHZm1DQ1F0VmlhTGlhaktIcDRjQ1VNOUZXZzhzMTRVT1JoY2NVQmcvNjQw?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9xaWFTbDNSVDFSYzFZRmMyckF4ZVFFcFZxcmVpY2liV0dJaFZjcDBzZnFtclFac3hEalVtaFQzUEdaMnpOeVFsSjM0d0VJaWNjTEVnRGhJUnJwU2xkMEhYTHcvNjQw?x-oss-process=image/format,png
[format_png 2 1]: https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzIwMTMxMTQxNQ%3D%3D&action=getalbum&album_id=1339196544410796033#wechat_redirect
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9xaWFTbDNSVDFSYzFlTFVkYjVjenlFcU5kckttRE9pYmxFd2U3OVdOc1ZmNFVpY05LTEJ4TGZpYWFqaEdoNzZEWkV2OWxxdDUySkt4Vm5mUDJZTGliRWliRnJiUS82NDA?x-oss-process=image/format,png