文章目录

• 前言
• 一、DataFrame创建
• • 1.1 字典创建
  • 1.2 NumPy二维数组创建
  • 二、DataFrame切片
  • • 2.1 行切片
    • 2.2 列切片
    • 2.3 行列切片
    • 三、DataFrame运算
    • • 3.1 DataFrame和标量的运算
      • 3.2 DataFrame之间的运算
      • 3.3 Series和DataFrame之间的运算
      • 四、DataFrame多层次索引
      • • 4.1 多层次索引构造
        • • • 1.隐式构造
            • 2.显式构造
            • 4.2 DataFrame多层索引的索引
            • • • 1.获取元素
                • 2.列索引&行索引
                • 4.3 DataFrame多层索引的切片操作
                • 五、索引的堆叠
                • 六、聚合操作
                • 结语
                • 相关导读

                  前言

                  大家好！我是一朵向阳花（花花花）🍭，本期跟大家分享的知识是 pandas 数据结构——DataFrame。

                  作者的【 Python 数据分析】专栏正在火热更新中🔥，如果本文对您有帮助，欢迎大家点赞 + 评论 + 收藏 ！

                  每日金句分享：慢慢来，谁还没有一个努力的过程。』—— pony「网易云音乐」。

                  一、DataFrame创建

                  DataFrame 是一个表格型的数据结构，DataFrame 既有行索引，又有列索引。

                  • index：行索引
                  • column：列索引
                  • values：二维 NumPy 数组

                  1.1 字典创建

                  字典创建时，字典的键变成 column ，值一般要是一个可迭代对象。

                  d = {
                      'name':['John','marry','kitty','smith'],
                      'age':[21,32,43,31]
                  }
                  df = pd.DataFrame(d)
                  df
                  

                  

                  1.2 NumPy二维数组创建

                  NumPy 二维数组创建时，只需要将二维数组赋值给 DataFrame 的 values，然后指定 index 行索引和 column 列索引即可。

                  df = pd.DataFrame(
                      data=np.random.randint(10,100,size=(4,6)),
                      index=['小明','小红','小黄','小绿'],
                      columns=['语文','数学','英语','化学','物理','生物']
                  )
                  df
                  

                  

                  二、DataFrame切片

                  对于 DataFrame 的切片操作，因为是表格型，因此可以分为行切片，列切片，行列切片。

                  df = pd.DataFrame(
                      data=np.random.randint(10,100,size=(4,6)),
                      index=['小明','小红','小黄','小绿'],
                      columns=['语文','数学','英语','化学','物理','生物']
                  )
                  print(df)
                  

                  

                  2.1 行切片

                  既然是切片，也是分为显式切片和隐式切片，下面分别演示。

                  显式切片：

                  df['小红':'小黄'] 
                  df.loc['小红':'小黄']
                  

                  

                  隐式切片：

                  df[1:3] # 数字是左闭右开
                  df.iloc[1:3]
                  

                  

                  2.2 列切片

                  对于列切片，即不管第一个维度（使用:,实现），需要特别注意的是，对列切片不能使用中括号 [] ，只能使用 loc 或 iloc。

                  • 显式切片

                    df.loc[:,'语文':'英语']
                    

                    

                    使用中括号报错：

                    

                    • 隐式切片

                      df.iloc[:,0:3]
                      

                      

                      使用中括号报错：

                      

                      2.3 行列切片

                      行列切片同时涉及对行和对列的切片，因此，对行列切片也只有两种方式，loc & iloc。

                      df.loc['小明':'小红','语文':'数学']
                      

                      

                      df.iloc[0:2,0:2]
                      

                      

                      三、DataFrame运算

                      3.1 DataFrame和标量的运算

                      DataFrame和标量之间的运算（±*/ // % **），正常对每个元素运算即可。

                      df1 = pd.DataFrame(
                          data=np.random.randint(0,10,(2,3))
                      )
                      display(df1)
                      df1 + 10
                      

                      

                      3.2 DataFrame之间的运算

                      DataFrame的运算需要注意：

                      • 1.DataFrame没有广播机制，因此它不会为缺失的行列补充数据
                      • 2.如果索引对应，那么正常运算
                      • 3.如果索引不对应，那么是 NaN
                      • 4.如果想给没有索引的地方填充数据，使用 add 函数

                      df1 = pd.DataFrame(
                          data=np.random.randint(0,10,(2,3))
                      )
                      df2 = pd.DataFrame(
                          data=np.random.randint(0,10,(3,2))
                      )
                      display(df1,df2)
                      df1 + df2
                      

                      

                      使用 add 函数填充数据：

                      df1.add(df2,fill_value=0)
                      

                      

                      3.3 Series和DataFrame之间的运算

                      Series 的行索引会自动匹配 DataFrame 的列索引，匹配成功后，会对 DataFrame 的每一行都做相同的运算。

                      s = pd.Series([100,10,1],index=df1.columns)
                      df = pd.DataFrame(data=np.random.randint(2,10,(3,3)))
                      display(s,df)
                      df + s
                      

                      

                      四、DataFrame多层次索引

                      4.1 多层次索引构造

                      多层次索引创建包括隐式构造和显式构造，隐式构造是直接指定一个多维 index 和多维 column 的构造方式，显式构造是通过 MultiIndex 类来构造的，有三种方式，分别是 数组、元组、笛卡尔积。

                      1.隐式构造

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

                      

                      2.显式构造

                      显式构造在隐式构造的基础上，只改变 index ，不改变其他。

                      • <1> 数组

                        index = pd.MultiIndex.from_arrays([
                            ['一班','一班','一班','二班','二班','二班'],
                            ['张三','李四','王五','赵六','孙七','王八']
                        ])
                        

                        • <2> 元组

                          index = pd.MultiIndex.from_tuples(
                              (
                                  ('一班','张三'),('一班','李四'),('一班','王五'),
                                  ('二班','赵六'),('二班','孙七'),('二班','王八')
                              )
                          )
                          

                          • <3> 笛卡尔积

                            笛卡尔积构造出来的是 2 x 3 = 6 个 index 。

                            index = pd.MultiIndex.from_product([
                                ['一班','二班'],
                                ['张三','李四','王五']
                            ])
                            

                            三种构造方法的运行结果和显式构造相同。

                            4.2 DataFrame多层索引的索引

                            1.获取元素

                            多层次索引中，如果使用 中括号 ，那么是列列行行；如果使用 loc ，那么是行列列行，如果使用 iloc ，那么是行列。

                            还是使用上面构造的期中、期末成绩表格演示。

                            # 显式索引
                            print(df['期中']['语文']['一班']['张三'])
                            print(df.loc['一班']['期中']['语文']['张三'])
                            # 隐式索引
                            print(df.iloc[1])
                            

                            

                            2.列索引&行索引

                            只需要牢牢记住中括号 [] 、loc、iloc 在多层索引中的使用规则即可。

                            df['期中']
                            df.loc['一班']['期中']
                            df.iloc[:,[1]]
                            

                            4.3 DataFrame多层索引的切片操作

                            DataFrame 多层次索引切片较为复杂，可以参考这篇博客 【数据分析day03】pandas“层次化索引对象”的多层索引,切片,stack。

                            五、索引的堆叠

                            索引的堆叠是指将行变成列，或将列变成行的操作，列变行由 stack 函数实现，行变列由 unstack 函数实现。

                            stack：将列索引变成行索引，默认是将最里层的列索引变成行索引，可以通过level控制，level默认等于 -1 并且变成的行索引也是在最里层。

                            首先构造 dataframe 对象：

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

                            

                            然后使用 stack 函数将列索引变成行索引：

                            df.stack()
                            

                            

                            和下列写法等价：

                            df.stack(level=-1)
                            

                            将最外层列索引变成行索引：

                            df.stack(level=0)
                            

                            

                            unstack：将行索引变成列索引（反堆叠），并且变成的列索引在最里层

                            还是使用上面的 dataframe 对象，进行反堆叠：

                            df.unstack()
                            

                            

                            level 属性：level默认等于 -1 ，最外层是0，最往里数值越大，-1就是指最里层

                            fill_value 属性：是stack、unstack方法的属性，用于填充NaN值。

                            不填充空值时：

                            df.unstack(level=0)
                            

                            

                            添加 fill_value 属性填充：

                            df.unstack(level=0,fill_value=0)
                            

                            

                            六、聚合操作

                            dataframe 聚合操作就是指 dataframe 聚合函数，有 sum、mean、max、min 等，主要有两个属性：aixs 控制行列，level 控制层级。

                            axis 属性：控制行列，axis = 0 表示行，axis = 1 表示列。

                            level 属性：控制层级，从外到里，依次增大，-1 表示最里层。

                            构造 dataframe 对象：

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

                            

                            使用 sum 函数聚合：

                            df.sum()
                            

                            

                            和下列写法等价：

                            df.sum(axis=0)
                            

                            保留第一层列，求行的和：

                            df.sum(axis=1,level=0)
                            

                            

                            结语

                            💕 本期跟大家分享的 “芝士” 就到此结束了，关于 DataFrame 数据结构，你学会了吗？✨

                            🍻 我是向阳花花花花，在学习的路上一直前行，期待与你一起进步。~ 🍻

                            🔥 如果文中有些地方不清楚的话，欢迎联系我，我会给大家提供思路及解答。🔥

                            相关导读

                            文章直达	链接
                            上期回顾	【数据分析 - 基础入门之pandas篇②】- pandas数据结构——Series

                             
                             网站开发报价  seo最新  制作网站一般多少钱  制作网站制作公司  网页制作与设计教程  长春网站制作方案定制