谢谢你留下时光匆匆
Pandas 选取行、选取列方式梳理
2023-06-12想法与笔记3697 字

这篇笔记对Pandas DataFrame取数的各种写法与对应的各种返回结果做一个梳理。

如没有特殊声明，df变量的数据如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> df

   col_1 col_2
a      0   foo
b      1   foo
c      2   bar
d      3   bar
e      4   foo
f      5   foo
g      6   bar
h      7   bar

df.loc[] 基于标签的筛选

single label 单一标签

输入为某个单一行标签label时，返回label所对应单一的行，返回类型为Series（如果行标签与行一一对应）。

1
2
3
4

>>> df.loc['a']

col_1      0
col_2    foo

注1：如果没有对应参数的label，则报KeyError。

1
2
3

>>> df.loc['z']

KeyError: 'z'

注2：如果index中label不唯一，多个行有相同的行标签时，则返回所有有该标签的行，返回类型为DataFrame，如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> df_duplicate_index

   col_1 col_2
a      0   foo
a      1   foo
b      2   bar

>>> df_duplicate_index.loc['a']

   col_1 col_2
a      0   foo
a      1   foo

list of labels 标签

输入为一个行标签list时，按照list中顺序，返回这些标签对应的所有行，返回类型为DataFrame。

1
2
3
4
5
6

>>> df.loc[['a', 'b', 'c']]

   col_1 col_2
a      0   foo
b      1   foo
c      2   bar

注1：如果list里没有对应参数的标签，则报KeyError。

1
2
3

>>> df.loc[['a', 'b', 'z']]

KeyError: "['z'] not in index"

注2：与单一标签一致的，如果index中label不唯一时，则所有带入参标签的行都会被返回。

注3：loc入参list中的label是可以重复的，通过这样来得到重复选取某行的返回结果。

1
2
3
4
5
6

>>> df.loc[['a', 'a', 'a']]

   col_1 col_2
a      0   foo
a      0   foo
a      0   foo

slice object 切片对象

slice 对象是指Python中带冒号的表达式，如1:5。返回类型为DataFrame。

返回结果的需要根据index是否有序，分情况讨论：

  • 当index是有序的，slice中的参数无需为index中某一个label，返回label在slice区间内的行，返回类型为DataFrame。
  • 当index是无序的，slice中的参数必须为index中某个label，否则会报KeyError，返回label为slice参数中的行，以及这两行中间的行，返回类型为DataFrame。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

>>> df.loc["a":"e"]

   col_1 col_2
a      0   foo
b      1   foo
c      2   bar
d      3   bar
e      4   foo

>>> df.loc["a":"z"]  # 注意z不在index里

   col_1 col_2
a      0   foo
b      1   foo
c      2   bar
d      3   bar
e      4   foo
f      5   foo
g      6   bar
h      7   bar

>>> df_unsorted_index = df.loc[['f', 'a', 'c', 'g', 'h', 'd', 'e', 'b']]
>>> df_unsorted_index.loc["a":"e"]

   col_1 col_2
a      0   foo
c      2   bar
g      6   bar
h      7   bar
d      3   bar
e      4   foo

注1：loc中slice两端端点的处理与Python中slice有些不同，python中slice是“左开右闭”的，即冒号右边的值不会囊括，如 [i for i in range(10)][0:3] 返回 [0, 1, 2]，而在loc中slice是both inclusive的，意味着冒号前后的值都会被囊括。

注2：可以用df.index.is_monotonic_increasing或 df.index.is_monotonic_decreasing（是一个属性非方法，不带括号）来判断dataframe是否已经按照index排好序。

注3：如果slice中冒号前一个label对应行在冒号后一个label对应行的后面，则会返回一个空的DataFrame。

1
2
3
4
5

>>> df.loc["e":"a"]

Empty DataFrame
Columns: [col_1, col_2]
Index: []

注4：当index中label不唯一时，使用slice可能会报错。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> df_duplicate_index_2

   col_1 col_2
a      0   foo
b      1   foo
c      2   bar
a      3   bar

>>> df_duplicate_index_2["a":"b"]

KeyError: "Cannot get left slice bound for non-unique label: 'a'"

boolean array 布尔列表

输入为一个数量与表行数相同（必须相同）的布尔列表时，返回对应位置为True的行，返回类型为DataFrame。

这种调用方式常用于按照某个条件过滤dataFrame。

1
2
3
4
5
6
7

>>> df.loc[df["col_2"] == "foo"]

   col_1 col_2
a      0   foo
b      1   foo
e      4   foo
f      5   foo

注1：条件的逻辑运算或与非需要用位运算符&, | , ~，在进行两个条件运算时，因为Python运算优先级，需要将条件语句用圆括号括起来。

1
2
3
4
5
6
7
8
9

>>> df.loc[df["col_1"] > 1 & df["col_2"] == "foo"] #直接做位运算会报错

TypeError: Cannot perform 'rand_' with a dtyped [object] array and scalar of type [bool]

>>> df.loc[(df["col_1"] > 1) & (df["col_2"] == "foo")]      #将条件语句括起来提高运算优先级

   col_1 col_2
e      4   foo
f      5   foo

callable 函数

输入为一个函数时，会将dataframe传入函数的返回结果作为loc的入参，返回对应的结果。函数的返回类型可以为上面提到4种（单一label、label列表、slice对象、布尔列表）中的任意一种。

函数入参主要是为了支持链式写法，当我们需要多重筛选dataframe时，使用链式写法进行代码开发不需要存储中间的dataframe结果，使得我们的代码更加简洁。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 常规写法
df_mid_1 = df.loc[df["col_1"] > 1]
df_mid_2 = df_mid_1.loc[df_mid_1.groupby("col_2")["col_2"].transform("count") > 2]
df_mid_2.loc[df_mid_2.index.isin(["a", "d", "g"])]

# 链式写法
(
    df.loc[df["col_1"] > 1]
        .loc[lambda x: x.groupby("col_2")["col_2"].transform("count") > 2]
        .loc[lambda x: x.index.isin(["a", "d", "g"])]
)

df.iloc[] 基于行号的筛选

iloc与loc最大的不同在于，loc接受的参数是index中的label，而iloc接受的参数是整数，代表dataframe的行号（从0开始）。

single integer 单一整数

输入为单一行数时，返回代数所在单一的行，返回类型为Series。

1
2
3
4

>>> df.iloc[0]

col_1      0
col_2    foo

注1：入参的整数可以为负数，会返回倒数第x行。

1
2
3

>>> df.iloc[-1] 

col_1      7 col_2    bar

注2：如果整数超过了dataframe的总行数，则报IndexError。

1
2
3

>>> df.iloc[10]

IndexError: single positional indexer is out-of-bounds

list of labels 整数列表

输入为一个整数list时，按照list中顺序，返回这些行数对应的所有行，返回类型为DataFrame。

1
2
3
4
5
6

>>> df.iloc[[0, 1, 2]]

   col_1 col_2
a      0   foo
b      1   foo
c      2   bar

注1：如果list里面的整数超过了dataframe的总行数，则报IndexError。

1
2
3

>>> (df.iloc[[0, 10]]

IndexError: positional indexers are out-of-bounds

注2：iloc入参list中的整数是可以重复的，通过这样来得到重复选取某行的返回结果。

1
2
3
4
5
6

>>> df.iloc[[0, 0, 0]]

   col_1 col_2
a      0   foo
a      0   foo
a      0   foo

slice object 切片对象

输入为一个整数slice时，返回slice对应的行数（左闭右开，只包含冒号前面的行），返回类型为DataFrame。

1
2
3
4
5
6
7

>>> df.iloc[1:5]

   col_1 col_2
b      1   foo
c      2   bar
d      3   bar
e      4   foo

注1：需要注意的是，与loc slice入参冒号前后的label都会被返回不同，iloc中冒号后面的整数对应的行不会被返回。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

>>> df_int_index = pd.DataFrame(["a", "b", "c"], columns=["col"], index=[0, 1, 2])
>>> df_int_index.iloc[0:2]

  col
0   a
1   b

>>> df_int_index.loc[0:2]

  col
0   a
1   b
2   c

boolean array 布尔列表

与loc中 boolean array 布尔列表用法完全相同。

callalbe 函数

与loc中callable函数用法基本相同，唯一不同是函数的返回类型需要为单一整数、整数列表、整数slice、布尔列表四种中的一种。

df[] 筛选

当直接在df[]输入筛选语句时，需要注意输入的参数类型对应的是筛选行还是筛选列，具体情况如下：

single label 单一标签 - 返回列

输入为某个单一标签label，返回label所对应的列，返回类型为Series（如果列标签与列一一对应）。df["a"]等价于df.loc[:, "a"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

>>> df['col_1']

a    0
b    1
c    2
d    3
e    4
f    5
g    6
h    7

>>> df['col_1'].equals(df.loc[:, 'col_1'])

True

list of labels 标签 - 返回列

输入为一个标签list时，按照list中顺序，返回这些标签对应的所有列，返回类型为DataFrame，df[['col_2', 'col_1']] 等价于 df.loc[:, ['col_2', 'col_1']]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

>>> df[['col_2', 'col_1']]

  col_2  col_1
a   foo      0
b   foo      1
c   bar      2
d   bar      3
e   foo      4
f   foo      5
g   bar      6
h   bar      7

>>> df[['col_2', 'col_1']].equals(df.loc[:, ['col_2', 'col_1']])

True

label slice 标签的切片对象 - 返回行

输入为一个 label slice 标签时(e.g. df["d":"g"])，返回slice对应的行，返回类型为DataFrame。df["d":"g"] 等价于 df.loc["d":"g"]，具体逻辑可以参考 loc 部分的slice-object-切片对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> df["d":"g"]

   col_1 col_2
d      3   bar
e      4   foo
f      5   foo
g      6   bar

>>> df["d":"g"].equals(df.loc["d":"g"])

True

integer slice 整数的切片对象 - 返回行

输入为一个整数slice(e.g. df[1:5]) 时，返回slice对应行数所在的行，返回类型为DataFrame。df[1:5] 等价于 df.iloc[1:5]，具体逻辑可以参考 .iloc 部分的slice-object-切片对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>>> df[2:5]

   col_1 col_2
c      2   bar
d      3   bar
e      4   foo

>>> df[2:5].equals(df.iloc[2:5])

True

boolean array 布尔列表 - 返回行

输入为时，返回对应位置为True的行(布尔列表长度需与dataFrame行数一致)，返回类型为DataFrame。df[df['col_1'] > 3] 等价于 df.loc[df['col_1'] > 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> df[df['col_1'] > 3]

   col_1 col_2
e      4   foo
f      5   foo
g      6   bar
h      7   bar

>>> df[df['col_1'] > 3].equals(df.loc[df['col_1'] > 3])

True

callable 函数

我们可以传一个函数，与loc iloc情况类似，会将dataframe传入函数的返回结果作为loc的入参，返回对应的结果。

1
2
3
4
5
6
7

>>> df[lambda x: x['col_1'] > 3]

   col_1 col_2
e      4   foo
f      5   foo
g      6   bar
h      7   bar

其它

整数与label的混用

在筛选行于列一同筛选时，有时候为了方便，在筛选行时用输入整数行数进行选取，在筛选列时输入label进行选取。loc与iloc是不允许同时输入两种类型的，但我们可以借助一些辅助函数完成两种类型的混用。

在.iloc[]中，使用dataFrame.columns.get_loc()（单一label）或 dataFrame.columns.get_indexer([])（label列表），将label转换为对应的列数。

1
2
3
4
5

>>> df.iloc[[0, 1], [df.columns.get_loc('col_1')]]

   col_1
a      0
b      1

在.loc[]中，使用dataFrame.index[[]]，将行数转换为对应的label。

1
2
3
4
5

>>> df.loc[df.index[[0, 1]], ['col_1']

   col_1
a      0
b      1

注意：如果一个lable对应多个行，dataFrame.index[[]]可能会返回某行数label对应的所有的行。