Pandas层次化索引

• 创建多层索引

  • 隐式构造

    • 最常见的方法是给DataFrame构造函数的index参数传递两个或更多的数组

    • df = DataFrame(
          data=np.random.randint(0,100,size=(6,6)),
          index=[['一班','一班','一班','二班','二班','二班'],['张三','李四','王五','赵六','田七','孙八']],
          columns=[['期中','期中','期中','期末','期末','期末'],['语文','数学','英语','政治','历史','地理']]
      )
      

  • 显式构造

    • 使用数组

      • df = DataFrame(
            data=np.random.randint(0,100,size=(6,6)),
            index=pd.MultiIndex.from_arrays([['一班','一班','一班','二班','二班','二班'],['张三','李四','王五','赵六','田七','孙八']]),
            columns=[['期中','期中','期中','期末','期末','期末'],['语文','数学','英语','政治','历史','地理']]
        )
        

    • 使用tuple

      • df = DataFrame(
            data=np.random.randint(0,100,size=(6,6)),
            index=pd.MultiIndex.from_tuples(
                (
                    ('一班','张三'),('一班','李四'),('一班','王五'),
                    ('二班','赵六'),('二班','田七'),('二班','孙八'),
                )
            ),
            columns=[['期中','期中','期中','期末','期末','期末'],['语文','数学','英语','政治','历史','地理']]
        )
        

    • 使用product

      • df = DataFrame(
            data=np.random.randint(0,100,size=(6,6)),
            # 笛卡尔积
            index=pd.MultiIndex.from_product([['一班','二班'],['张三','李四','王五']]),
            columns=pd.MultiIndex.from_product([['期中','期末'],['语文','数学','英语']])
        )
        

  • Series也可以创建多层次索引

    • index=[['一班','一班','一班','二班','二班','二班'],['张三','李四','王五','赵六','田七','孙八']]
      s=Series(data=np.random.randint(0,100,size=6),index=index)
      

  • 多层列索引

    • 除了行索引index，列索引columns也能用同样的方法创建多层索引

  • 多层索引对象的索引与切片操作

    • Series的操作
      • 对于Series来说，直接中括号[]与使用.loc[]完全一样，推荐使用.loc中括号索引和切片
      • 索引
        • 显式索引
          • s['一班']['张三']
          • s['一班','李四']
          • s.loc['一班','李四']
          • s[['一班','二班']]
            • 最外层索引依然保留
          • s.loc[['一班','二班']]
        • 隐式索引
          • s[1]
          • s.iloc[4]
          • s[[2,4]]
            • 最外层索引依然保留
          • s.iloc[[2,4]]
      • 切片
        • 隐式切片
          • s[1:5]
          • s.iloc[1:5]
          • 建议使用隐式切片
            • 直接对最内层索引切片
        • 显示切片
          • 默认只能对外层索引切片
          • s['一班':'二班']
    • DataFrame的操作
      • 索引
        • 可以直接使用列名称来进行列索引
        • 使用索引：优先考虑列索引
          • df['期末']
          • df['期末']['英语']
          • df['期末','英语']
          • df[('期末','英语')]
            • 建议使用
          • df.期末.英语
          • df[('期末','英语')][2]
        • 行索引（必须加loc或iloc）
          • df.loc[('一班','王五'),('期末','英语')]
            • 建议使用
      • 切片
        • 建议使用隐式切片
        • 默认行切片
          • df[1:4]
          • df.iloc[1:4]
          • df['一班':'二班']
          • df.loc['一班':'二班']
          • df[('一班','张三'): ('二班','张三')]
          • df.loc[('一班','张三'): ('二班','张三')]
        • 列切片
          • df.iloc[:,1:4]

  • 索引的堆（stack，行列索引切换）

    • df.stack()
      • df.stack()
        • 将列索引变成行索引，默认将最里层的列索引变成行索引
      • df.stack(level=1)
        • level表示索引的层级，0表示最外层
      • df.stack(level=0)
        • 将最外层的列索引变成行索引
    • df.unstack()
      • df.unstack()
        • 默认将最里层行索引变成列索引
          • df.unstack(level=0)
            • 将最外层的行索引变成列索引
          • df2.unstack(fill_value=0)
            • 用指定的值填充NaN
          • df2.unstack(level=(0,1))
            • 同时将第一层（最外层）行索引转成列索引

  • 聚合操作

    • 需要指定axis
    • axis是列索引的层级，level是行索引的层级
    • df.sum()
      • 默认axis=0
    • df.sum(axis=0)
      • 对每一列的所有行求和
    • df.sum(axis=1)
      • 对每一行的所有列求和
    • df.sum(level=0)
      • 计算一班和二班（最外层）的成绩和
    • df.sum(level=1)
      • 分别计算张三，李四，王五（第二层）的成绩和
    • df.max(axis=1, level=1)[:2]
      • 计算各科目张三李四的最高分

Pandas的拼接操作

• 使用pd.concat()级联
  • 简单级联
    • 优先增加行数（默认axis=0）
    • pd.concat((df1,df2))
    • pd.concat((df1,df2),axis=1)
      • 增加列数
    • pd.concat((df1, df2), ignore_index=True)
      • 忽略行索引,不用你的行索引
    • pd.concat((df1,df2),keys=['X','Y'])
      • 添加外层索引，默认添加行索引
    • pd.concat((df1,df2),keys=['X','Y'],axis=1)
      • 添加列索引
  • 不匹配级联
    • 不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致
    • 外连接：补NaN（默认模式）
      • pd.concat((df1,df2))
    • pd.concat((df1,df2),join='outer')
      • 默认外连接
    • 内连接：只连接匹配的项
      • pd.concat((df1,df2),join='inner')
    • 连接指定轴
      • 默认axis=0
        • 增加行数
          • 显示所有行
          • 列去重
      • axis=1
        • 增加列数
          • 显示所有列
          • 行去重
        • pd.concat((df1,df2),axis=1)
          • 外连接
        • pd.concat((df1,df2),axis=1,join='inner',sort=True)
          • 内连接
• 使用append()函数添加
  • 由于在后面级联的使用非常普遍，因此有一个函数append专门用于在后面添
  • df1.append(df2)
    • 在原来的基础上追加另一个df
    • 补NaN
• 使用pd.merge()合并
  • 概述
    • merge与concat的区别在于，merge需要依据某一共同的列来进行合并
    • 使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并
    • 注意每一列元素的顺序不要求一致
  • 一对一合并
    • pd.merge(df1,df2)
      • 类似数据库表的连接，默认是内连接
  • 多对一合并
    • pd.merge(df1,df2)
    • df1.merge(df2)
  • 多对多合并
    • pd.merge(df1,df2)
  • key的规范化
    • 使用on=显式指定哪一列为key,当有多个key相同时使用
      • df1.merge(df2,on='age')
    • 使用left_on和right_on指定左右两边的列作为key，当左右两边的key都不想等时使用
      • df1.merge(df2,left_on='id',right_on='id2')
    • 当左边的列和右边的index相同的时候,使用right_index=True
      • df1.merge(df2,left_on='id',right_index=True)
    • 内合并与外合并
      • 内合并：只保留两者都有的key（默认模式）
        • df1.merge(df2,how='inner')
      • 外合并，显示所有数据
        • df1.merge(df2,how='outer')
        • 补NaN
      • 左合并、右合并
        • 左合并
          • df1.merge(df2,how='left')
            • 显示df1的所有数据+公共数据
        • 右合并
          • df1.merge(df2,how='right')
            • 显示df2的所有数据+公共数据
        • 列冲突的解决
          • 当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名
          • df1.merge(df2,on='id',suffixes=['_df1','df_2'])
            • 除id外还有至少一个列名称相同