1. <em id="yud1w"><acronym id="yud1w"><u id="yud1w"></u></acronym></em>
      
      
      <button id="yud1w"></button>

      python

      当前位置:首页?>?Pandas教程?>?当前文章

      Pandas教程

      Dataframe选择行列loc,iloc,切片,布尔索引,条件判断等

      2020-10-29 89赞 python中国网
      每篇文章努力于解决一个问题!python高级、python面试全套、操作系统经典课等可移步文章底部。

        Dataframe的行标签和列标签其实都是一种索引,每一行也对应位置索引(0到length-1)。Dataframe是dict-like类型,可以通过df[xx]的形式选择单列、多列(传入列表)。Dataframe也是list-list类型,可以通过切片选择数据。基于这些特性,我们可以用直接索引、loc、iloc三个方式来选择数据!

        1、直接索引和切片

        假设有个二维数据,行索引为A、B、C,列索引为AA、BB、CC,我们按照直接索引或者选取数据,先看一下:

      df['A']和df[0] # 都是错误 KeyError
      df['BB'] #单列,是Series
      df[['BB']] #单列,是DataFrame
      df[['BB','CC']] # 两列
      df['A':'C'] # 行标签切片,末端包含,返回3行
      df[0:2] # 行位置索引切片,末端不包含,返回2行
      df[::-1] # 切片,行索引倒过来为CBA
      df[[True,False,True]] #选择2行,布尔值是根据行来的
      

        注意事项:df切片是按照行标签或者行的位置索引来的。标签索引切片为末端包含,位置索引切片为末端不包含(切片特性等同于列表)。下面看看代码演示:

      df = pd.DataFrame([[1, 2,3], [4, 5,6], [7, 8,9]],
           index=['A', 'B', 'C'],
           columns=['AA', 'BB','CC'])
      
      print(df['BB'])
      print('---------')
      print(df[['BB']])
      print('---------')
      print(df[['BB','CC']])
      print('---------')
      print(df[0::2])
      print('---------')
      print(df['A':'C':2])
      print('---------')
      print(df[::-1])
      
      A    2
      B    5
      C    8
      Name: BB, dtype: int64
      ---------
         BB
      A   2
      B   5
      C   8
      ---------
         BB  CC
      A   2   3
      B   5   6
      C   8   9
      ---------
         AA  BB  CC
      A   1   2   3
      C   7   8   9
      ---------
         AA  BB  CC
      A   1   2   3
      C   7   8   9
      ---------
         AA  BB  CC
      C   7   8   9
      B   4   5   6
      A   1   2   3
      
      

        2、loc方式

        loc方式比较灵活,可以传入2个"参数"作为条件来分别控制行列选取。

        假设有个二维数据,行索引为A、B、C,列索引为AA、BB、CC,loc方式可以有很多花样,先看下

      df.loc['A'] # 1行,返回series
      df.loc[['A']] # 这是个dataframe,行数是1行
      df.loc[['A','B']] # 2行
      df.loc['A','AA'] # 标量,单元格的值
      df.loc[['A','B'],['AA','CC']] # 2行2列
      df.loc['A':'C','AA':'CC'] # 3行3列(切片方式)
      df.loc['A':'C',::-1] # 3行3列(切片方式),列顺序翻转
      df.loc[[True,True,False],[True,False,True]] # 2行2列(布尔方式)
      df.loc['fun1','fun2'] #函数的方式不常用
      

      # -*- coding: utf-8 -*-
      import pandas as pd
      df = pd.DataFrame([[1, 2,3], [4, 5,6], [7, 8,9]],
           index=['A', 'B', 'C'],
           columns=['AA', 'BB','CC'])
      
      print(df.loc['A'])
      print('-----------')
      print(df.loc[['A']])
      print('-----------')
      print(df.loc[['A','B']])
      print('-----------')
      print(df.loc['A','AA'])
      print('-----------')
      print(df.loc[['A','B'],['AA','CC']])
      print('-----------')
      print(df.loc['A':'C','AA':'CC'])
      print('-----------')
      print(df.loc['A':'C',::-1])
      print('-----------')
      print(df.loc[[True,True,False],[True,False,True]])
      
      AA    1
      BB    2
      CC    3
      Name: A, dtype: int64
      -----------
         AA  BB  CC
      A   1   2   3
      -----------
         AA  BB  CC
      A   1   2   3
      B   4   5   6
      -----------
      1
      -----------
         AA  CC
      A   1   3
      B   4   6
      -----------
         AA  BB  CC
      A   1   2   3
      B   4   5   6
      C   7   8   9
      -----------
         CC  BB  AA
      A   3   2   1
      B   6   5   4
      C   9   8   7
      -----------
         AA  CC
      A   1   3
      B   4   6
      
      

        说明:loc可以传入一个函数,函数参数是df。该方法不常用。有兴趣可以看官方文档说明!

      mydict = [{'a': 11, 'b': 22},
                {'a': 33, 'b': 44},
                {'a': 55, 'b': 66}]
      df = pd.DataFrame(mydict)
      print(df)
      print('-----------')
      print(df.loc[lambda x: x.index > 1])#行索引大于1
      
          a   b
      0  11  22
      1  33  44
      2  55  66
      -----------
          a   b
      2  55  66
      

        3.iloc方式

        假设有个二维数据,行索引为A、B、C,列索引为AA、BB、CC,我们按照位置索引来选取数据,也有不少花样,看一下:

      df.iloc[0] # 1行,是series
      df.loc[[0]] # 这是个dataframe,行也是1行
      df.iloc[[0,1]] # 2行
      df.iloc[0,1] # 标量,单元格的值
      df.iloc[[0,1],[0,1]] # 2行2列
      df.iloc[0:2,0:2]] # 2行2列(iiloc切片末端不包含)
      df.iloc[0:2,::-1] # 2行3列(列索引顺序翻转)
      df.iloc[[True,True,False],[True,False,True]] # 2行2列(布尔方式)
      df.iloc['fun1','fun2'] #函数的方式不常用
      

        通过行号和列号选取数据,iloc方式可以传入行号和列号来分别控制行列选取,行号和列号从0开始到 length-1。

        1)选择单行和多行

      # -*- coding: utf-8 -*-
      import pandas as pd
      df = pd.DataFrame([[1, 2,3], [4, 5,6], [7, 8,9]],
           index=['A', 'B', 'C'],
           columns=['AA', 'BB','CC'])
      
      print(df.iloc[0])
      print('-----------')
      print(df.iloc[[0]])
      print('-----------')
      print(df.iloc[[0,1]])
      print('-----------')
      print(df.iloc[0,1])
      print('-----------')
      print(df.iloc[[0,1],[0,1]])
      print('-----------')
      print(df.iloc[0:2,0:2])
      print('-----------')
      print(df.iloc[0:2,::-1])
      print('-----------')
      print(df.iloc[[True,True,False],[True,False,True]])
      
      AA    1
      BB    2
      CC    3
      Name: A, dtype: int64
      -----------
         AA  BB  CC
      A   1   2   3
      -----------
         AA  BB  CC
      A   1   2   3
      B   4   5   6
      -----------
      2
      -----------
         AA  BB
      A   1   2
      B   4   5
      -----------
         AA  BB
      A   1   2
      B   4   5
      -----------
         CC  BB  AA
      A   3   2   1
      B   6   5   4
      -----------
         AA  CC
      A   1   3
      B   4   6
      
      

        说明:iloc可以传入1个函数,该函数的参数为df本身。这种方式使用频率很低。

      # -*- coding: utf-8 -*-
      import pandas as pd
      mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
                {'a': 10, 'b': 20, 'c': 30, 'd': 40},
                {'a': 100, 'b': 200, 'c': 300, 'd': 400}]
      df = pd.DataFrame(mydict)
      print(df)
      print('-----------')
      print(df.iloc[lambda x: x.index % 2 == 0])#行索引除以2余数为0
      
      
           a    b    c    d
      0    1    2    3    4
      1   10   20   30   40
      2  100  200  300  400
      -----------
           a    b    c    d
      0    1    2    3    4
      2  100  200  300  400
      

        4.条件判断

        上述案例可知loc和iloc可以"传参"布尔值,不过其类型并不限于列表,可以是Series、df、np数组,只要他们的值为布尔值即可。

        实际中常常进行条件判断(大于等于小于或者其他)来筛选数据(对df条件判断的结果就是布尔值组成的Series或者Dataframe)。在多条件判断中,&代表且,|代表或,~代表取反。如果2个条件运算需要加上小括号防止出错。如:df[(df['b']>44) & (df['b'] < 99)]、df[~(df['b']>44)]。

       

        1)单列做判断

      # -*- coding: utf-8 -*-
      import pandas as pd
      mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
                {'a': 10, 'b': 20, 'c': 30, 'd': 40},
                {'a': 100, 'b': 200, 'c': 300, 'd': 400}]
      df = pd.DataFrame(mydict)
      print(df)
      print('-----------')
      
      res = df['a'] > 5
      print(df[res])
      
      
           a    b    c    d
      0    1    2    3    4
      1   10   20   30   40
      2  100  200  300  400
      -----------
           a    b    c    d
      1   10   20   30   40
      2  100  200  300  400
      

        2)多行多列做判断

      # -*- coding: utf-8 -*-
      import pandas as pd
      mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
                {'a': 10, 'b': 20, 'c': 30, 'd': 40},
                {'a': 100, 'b': 200, 'c': 300, 'd': 400}]
      df = pd.DataFrame(mydict)
      print(df)
      print('-----------')
      
      res = df.iloc[[1,2]] > 20 # 你可以打印res看下结果
      print(df[res])
      print('------------')
      
      res = df > 30
      print(df[res])
      
           a    b    c    d
      0    1    2    3    4
      1   10   20   30   40
      2  100  200  300  400
      -----------
             a      b      c      d
      0    NaN    NaN    NaN    NaN
      1    NaN    NaN   30.0   40.0
      2  100.0  200.0  300.0  400.0
      ------------
             a      b      c      d
      0    NaN    NaN    NaN    NaN
      1    NaN    NaN    NaN   40.0
      2  100.0  200.0  300.0  400.0
      

        3)多条件判断

      # -*- coding: utf-8 -*-
      import pandas as pd
      
      mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
                {'a': 10, 'b': 20, 'c': 30, 'd': 40},
                {'a': 100, 'b': 200, 'c': 300, 'd': 400}]
      df = pd.DataFrame(mydict)
      print(df)
      print('-----------')
      
      res0 = (df['a'] > 0) & (df['c']< 400)
      res1 = df['c'] > 100
      print(df[res0 & res1])
      
           a    b    c    d
      0    1    2    3    4
      1   10   20   30   40
      2  100  200  300  400
      -----------
           a    b    c    d
      2  100  200  300  400
      

        自定义布尔值的Series或者Datadrame或者列表去对df做筛选,确保自定义的Series元素数和df行数一致。

      # -*- coding: utf-8 -*-
      import pandas as pd
      
      d = {'col1': [1,2,3], 'col2': [4,'66',6],'col3':[7,8,9]}
      df = pd.DataFrame(data=d)
      print(df)
      print('------------------')
      
      lis=[True,False,True]
      s  = pd.Series(lis,index=[0,1,2])
      print(df[s])
      
         col1 col2  col3
      0     1    4     7
      1     2   66     8
      2     3    6     9
      ------------------
         col1 col2  col3
      0     1    4     7
      2     3    6     9
      
      # -*- coding: utf-8 -*-
      import pandas as pd
      
      d = {'col1': [1,2,3], 'col2': [4,'66',6],'col3':[7,8,9]}
      df = pd.DataFrame(data=d,index=[1,2,3])
      print(df)
      print('------------------')
      
      d2 = {'col1': [True,False,True], 'col2': [True,False,False]}
      df2 = pd.DataFrame(d2,index=[0,1,2])
      print(df2)
      print('==================')
      print(df[df2])
      
         col1 col2  col3
      1     1    4     7
      2     2   66     8
      3     3    6     9
      ------------------
          col1   col2
      0   True   True
      1  False  False
      2   True  False
      ==================
         col1 col2  col3
      1   NaN  NaN   NaN
      2   2.0  NaN   NaN
      3   NaN  NaN   NaN
      


        4)综合练习

      # -*- coding: utf-8 -*-
      import pandas as pd
      mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
                {'a': 10, 'b': 20, 'c': 30, 'd': 40},
                {'a': 100, 'b': 200, 'c': 300, 'd': 400}]
      df = pd.DataFrame(mydict)
      print(df)
      print('-----------')
      
      print(df[df > 5].loc[1:2]['a'])
      
           a    b    c    d
      0    1    2    3    4
      1   10   20   30   40
      2  100  200  300  400
      -----------
      1     10.0
      2    100.0
      Name: a, dtype: float64
      

      文章评论

      Dataframe选择行列loc,iloc,切片,布尔索引,条件判断等文章写得不错,值得赞赏
      国产99视频精品免视看6