python

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

Pandas教程

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

2020-10-29 129赞 老董笔记
每篇文章努力于解决一个问题!更多精品可移步文章底部。

  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,切片,布尔索引,条件判断等文章写得不错,值得赞赏