Pandas.DataFrame.iloc[ ] 筛选数据-自然索引法 详解 含代码 含测试数据集 随Pandas版本持续更新

关于Pandas版本： 本文基于 pandas2.1.2 编写。

关于本文内容更新： 随着pandas的stable版本更迭，本文持续更新，不断完善补充。

Pandas稳定版更新及变动内容整合专题： Pandas稳定版更新及变动迭持续更新。

Pandas API参考所有内容目录

Pandas.DataFrame.iloc[ ]

Pandas.DataFrame.iloc[ ] 方法用于通过 自然索引 ^自然索引 筛选 DataFrame 数据。

• 注意！在此方法中，你传递的整数，会被理解为 自然索引 ^自然索引，表示的是从0开始的整数位置。

• ?? 注意 :

  • 具有 多层索引 的 DataFrame , 不再需要像 DataFrame.loc[ ] 那样区分索引层次。DataFrame.iloc[0] 代表第1行，DataFrame.iloc[:,0] 代表第1列。相对DataFrame.loc[ ]而言，更容易理解。^例2
  • 支持筛选后赋值 ^例7

语法：

DataFrame.iloc [行索引,列索引]

返回值：

• Series or DataFrame or Scalar
  • 筛选范围、DataFrame 是否具有多层索引等都会影响具体的返回形式。
  • 如果筛选结果是 Series 或 Scalar 时，筛选条件套上 [ ] 方括号，可以强制以 DataFrame 样式返回。^例1

语法说明：

1、筛选1行，筛选1列，筛选单元格

• DataFrame.iloc[行索引,列索引] ^例1

  行索引、列名索引，用英文逗号分隔。

  • 筛选1行： DataFrame.iloc[行索引,: ] ^{红色的冒号表示所有列。只传行索引时，红色逗号、冒号可以省略。}
  • 筛选1列： DataFrame.iloc[:, 列索引] ^{红色冒号必须有，表示所有行。}
  • 筛选单元格： DataFrame.iloc[行索引**,** 列索引]

2、筛选多行，筛选多列

• DataFrame.loc[[行索引1’,'行索引2, …],[列索引1,列索引2, …]]^例3

  多个行索引筛选条件用方括号包裹、多个列名索引筛选条件用方括号包裹。两种条件用英文逗号分隔。

  • 筛选多行： DataFrame.iloc[[行索引1,行索引2, …], ] ^{只传行递行索引条件时，红色逗号可以省略。}
  • 筛选多列： DataFrame.iloc[, [‘列索引1’,‘列索引2’, …]]
  • 同时筛选多行多列： DataFrame.loc[[‘行索引1’,‘行索引2’, …], [‘列索引1’,‘列索引2’, …]]

  • ?? 注意 :

    • 多个条件，必须用 [ ] 方括号包裹！

    • 与 Python切片 不同，被 [ ] 包裹的多个位置的索引，都会包含在筛选条件内。

3、范围筛选

• DataFrame.iloc[[行索引1:行索引x],[列索引1:列索引x]] ^例4

  开始和结束的范围用英文冒号分隔。

  • 行和列都支持范围筛选： DataFrame.iloc[[行索引1:行索引x], [列索引1:列索引x ]] ^{只传递行索引条件时，红色逗号可以省略。}

  • 范围筛选可以和单条筛选混用： DataFrame.iloc[[行索引1:行索引x], 列索引 ]]

  • 范围筛选可以和多条筛选混用： DataFrame.iloc[[行索引1:行索引x], [‘列索引1’,‘列索引2’, …]]

  • ?? 注意 :

    • 开始和结束的范围，必须用 : 英文冒号分隔！

    • 索引范围，不能用 [ ] 方括号包裹！

    • 左闭右开： 在使用范围筛选时，需要注意，范围筛选遵循 Python切片 的 左闭右开 原则。例如你传递了 [0:5] 的范围，这个范围的实际位置区间是 0 ≤ 位置 < 5 ^例4

4、布尔筛选

• DataFrame.iloc[行掩码列表,列掩码列表]

  • 掩码筛选： 可以传递一个与行索引长度相同的 布尔列表 表示哪些行留下(True对应的位置留下)，哪些行舍弃（False对应的位置舍弃）。^例5

5、Callable 筛选

• DataFrame.iloc[Callable]

  可以使用 Callable 进行筛选，原理上这也是一种布尔筛选。 ^例6

相关方法：

?? 相关方法

---

• DataFrame.iat

  Access a single value for a row/column label pair.

• DataFrame.loc

  筛选数据-标签法

• Series.iloc

  Access group of values using labels.

示例：

测试文件下载：

本文所涉及的测试文件，如有需要，可在文章顶部的绑定资源处下载。

若发现文件无法下载，应该是资源包有内容更新，正在审核，请稍后再试。或站内私信作者索要。

例1：只有单层索引的DataFrame，筛选单条数据

• 1、筛选1行，默认返回 Series，把筛选条件套上 [ ],可以强制返回 DataFrame。

import pandas as pd

# 构建DF
df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['cobra', 'viper', 'sidewinder'],
     columns=['max_speed', 'shield'])

# 筛选'cobra'行,其索引位置是0，默认返回Series
df.iloc[0]
# ... max_speed    1
# ... shield       2
# ... Name: cobra, dtype: int64


# 单行筛选,条件套上[ ]，强制返回 DataFrame
df.iloc[[0]]
# ...        max_speed  shield
# ... cobra          1       2

• 2、筛选1列，默认返回 Series，把筛选条件套上 [ ],可以强制返回 DataFrame。

# 筛选'max_speed'列,其列名索引位置是0，默认返回Series
# df.iloc[:,0]
# ... cobra         1
# ... viper         4
# ... sidewinder    7
# ... Name: max_speed, dtype: int64


# 筛选'max_speed'列,条件套上[ ]，强制返回 DataFrame
df.iloc[:,[0]]
# ...	        max_speed
# ... cobra	1
# ... viper	4
# ... sidewinder	7

• 3、筛选单元格,默认返回标量值 Scalar，把筛选条件套上 [ ],可以强制返回 DataFrame。

# 常规单元格筛选，返回标量值
df.iloc[0, 0]
# ... 1


# 把筛选条件套上 [ ],可以强制返回 DataFrame
df.iloc[[0], [0]]
# ... 	    max_speed
# ... cobra	    1

例2：多层索引的DataFrame，筛选单条数据

• 1、构建演示数据并观察数据内容

import pandas as pd

# 构建演示数据
tuples = [
   ('射手', '巨魔族'), ('射手', '死灵族'),
   ('法师', '巨魔族'), ('法师', '死灵族'),
   ('战士', '巨魔族'), ('战士', '死灵族')
]
index = pd.MultiIndex.from_tuples(tuples)
values = [[9, 20], [10, 18], [7, 23],
        [6, 25], [4, 30], [3, 35]]
df = pd.DataFrame(values, columns=[['属性1','属性2'], ['攻速','攻击力']], index=index)

# 观察数据内容
df

		属性1	属性2
		攻速	攻击力
射手	巨魔族	9	20
	死灵族	10	18
法师	巨魔族	7	23
	死灵族	6	25
战士	巨魔族	4	30
	死灵族	3	35

• 2、筛选1行、或1列、或某个单元格

# 筛选第1行，默认返回Series
df.iloc[0]
# ... 属性1  攻速      9
# ... 属性2  攻击力    20
# ... Name: (射手, 巨魔族), dtype: int64

# 筛选第1列，默认返回Series
df.iloc[:,0]
# ... 射手	巨魔族	   9
# ...       死灵族	  10
# ... 法师	巨魔族	   7
# ...       死灵族	   6
# ... 战士	巨魔族	   4
# ...       死灵族	   3

# 筛选第1个单元格，默认返回标量值
df.iloc[0,0]
# ... 9

• 3、多层索引的DataFrame,如果想强制返回DataFrame，可以用[ ]把筛选条件套起来

# 筛选第1个单元格，默认返回标量值，用[ ]把筛选条件套起来强制返回DataFrame
df.iloc[[0],[0]]
# ... 	            属性1
# ...               攻速
# ... 射手	巨魔族     9	             

例3：筛选多条数据

import pandas as pd

# 构建DF
df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['cobra', 'viper', 'sidewinder'],
     columns=['max_speed', 'shield'])

# 筛选多行
df.iloc[[0, 1]]
# ... 	    max_speed	shield
# ... cobra	        1	     2
# ... viper	        4	     5


# 筛选多行、单列
df.iloc[[0, 1],0]
# ... cobra    1
# ... viper    4
# ... Name: max_speed, dtype: int64


# 筛选多行、多列
df.iloc[[0, 1],[0, 1]]
# ... 	     max_speed	shield
# ... cobra	         1	     2
# ... viper	         4	     5

例4：范围筛选，以及和其他形式筛选的混用。注意左闭右开原则对右边界索引值的影响

import pandas as pd

# 构建DF
df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['第1行', '第2行', '第3行'],
     columns=['第1列', '第2列'])

# 筛选第1行到第2行
df.iloc[0:2]
# ...      第1列	第2列
# ... 第1行	   1	   2
# ... 第2行	   4	   5


# 筛选第1列到第2列
df.iloc[:,0:2]
# ...       第1列	第2列
# ... 第1行	    1	   2
# ... 第2行	    4	   5
# ... 第3行	    7	   8


# 筛选第1行到第2行，+ 筛选第1列到第2列
df.iloc[0:2,0:2]
# ...       第1列	第2列
# ... 第1行	    1	   2
# ... 第2行	    4	   5



# 筛选第1行到第2行 + 第1列  强制返回DataFrame，
# df.iloc[0:2,[0]]  # 0:2是个范围，不能套[ ]
# ... 	   第1列
# ... 第1行	   1
# ... 第2行	   4


# 筛选第1行到第2行 + 筛选第1列和第2列
# df.iloc[0:2,[0,1]]
# ...      第1列	第2列
# ... 第1行	   1	   2
# ... 第2行	   4	   5

例5：使用由布尔值组成的掩码列表，表示哪些行或哪些列被筛选。

import pandas as pd

# 构建DF
df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['第1行', '第2行', '第3行'],
     columns=['第1列', '第2列'])

# 筛选第1行和第3行
list_mask = [True, False, True]
df.iloc[list_mask]
# ... 	     第1列	第2列
# ... 第1行	    1       2
# ... 第2行	    7       8

# 筛选第1行和第3行 + 第1列
list_mask_line = [True, False, True]
list_mask_col = [True, True]
df.iloc[list_mask_line, list_mask_col]
# ... 	     第1列	第2列
# ... 第1行	    1       2
# ... 第2行	    7       8

例6：布尔运算筛选

import pandas as pd

# 构建DF
df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['第1行', '第2行', '第3行'],
     columns=['第1列', '第2列'])

# 筛选第1行
df.iloc[lambda x: x.index == '第1行']
# ... 	   第1列	第2列
# ... 第1行	   1	    2

# 筛选所有、第1列
df.iloc[:,lambda x: x.columns == '第1列']
# ...       第1列
# ... 第1行	    1
# ... 第2行	    4
# ... 第3行	    7

示例7：筛选后赋值，更改数据内容

import pandas as pd

# 构建演示数据
df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['cobra', 'viper', 'sidewinder'],
     columns=['移速', '护甲'])

# 筛选后，批量修改数据
df.iloc[[1,2]] = 50
df
# ...             移速	护甲
# ... cobra	         1	  2
# ... viper	        50	  50
# ... sidewinder	50	  50