Loading

3-Pandas层次化索引&拼接

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外还有至少一个列名称相同
posted @ 2020-12-12 17:55  lotuslaw  阅读(311)  评论(0)  编辑  收藏  举报