pandas loc[] 查询数据行和列

看过来

《pandas 教程》持续更新中，提供建议、纠错、催更等加作者微信: gairuo123（备注：pandas教程）和关注公众号「盖若」ID: gairuo。跟作者学习，请进入 Python学习课程。欢迎关注作者出版的书籍：《深入浅出Pandas》和《Python之光》。

loc[] 是基于标签的数据选择方法，这意味着我们必须传递要选择的行或列的名称，按标签或布尔数组访问一组行和列，.loc[] 主要基于标签，但也可以与布尔数组一起使用。DataFrame 和 Series 都支持这个方法。

DataFrame

由于 DataFrame 有两个维度，所以用逗号分隔分别选取行和列的数据。

功能图示

图示如下：

Pandas loc[] 查询数据行和列

语法

loc 是以 DataFrame 的属性形式存在的：

property DataFrame.loc: pandas.core.indexing._LocIndexer

对于 DataFrame 来说可以可以支持行和列两个元素:

pandas.DataFrame.loc[row_lable, column_label]

每个元素可以为以下形式：

单个标签，例如 5 或 “A”（5 被解释为索引的标签，而不是索引上的整数自然位置）。
标签的列表或数组，如 ['a', 'b', 'c']，标签可以重复，如 df.loc[[0,0,1]]，索引 0 显示两次
带有标签的切片对象，例如 'a':'f' (start 和 stop 都包含在内)
与被切片轴长度相同的布尔数组，例如[True, False, True]
一个索引与之对齐的布尔 Series
可对齐的索引类型（Index），返回的选择的索引将作为输入
一个带有一个参数（调用Series或DataFrame）的可调用函数，它返回有效的索引输出

常用方法

df.iloc 与 df.loc 相似，但只能用自然索引（行和列的 0 - n 索引），不能用标签。

df.iloc[:3]
df.iloc[:]
df.iloc[:, [1, 2]]
df.iloc[2:20:3]
s.iloc[:3]

如果想筛选多个不连续的行列数据（使用 np.r_），可以使用以下方法：

# 筛选索引0-4&10&5-29每两行取一个&70-74
df.iloc[np.r_[:5, 10, 15:30:2, 70:75]] # 行
df.iloc[:, np.r_[0, 2:6]] # 列，0列和第2-5列
# 也可以使用追加的方式拼接
df.loc[:5].append(df.loc[10]).append(df.loc[15:30:2])

案例

相关案例如下：

# 获取数据
df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
      index=['cobra', 'viper', 'sidewinder'],
      columns=['max_speed', 'shield'])
df
'''
            max_speed  shield
cobra               1       2
viper               4       5
sidewinder          7       8
'''

单一标签，注意：这会将行作为一个序列返回。

df.loc['viper']
'''
max_speed    4
shield       5
Name: viper, dtype: int64
'''

标签列表，注意使用 [[]] 返回数据帧。

df.loc[['viper', 'sidewinder']]
'''
            max_speed  shield
viper               4       5
sidewinder          7       8
'''

行和列的单个标签：

df.loc['cobra', 'shield']
# 2

行标签切片，列用单个标签切片。如上所述，请注意，切片的开始和停止都包括在内。

df.loc['cobra':'viper', 'max_speed']
'''
cobra    1
viper    4
Name: max_speed, dtype: int64
'''

与行轴长度相同的布尔列表

df.loc[[False, False, True]]
'''
            max_speed  shield
sidewinder          7       8
'''

可对齐布尔 Series:

df.loc[pd.Series([False, True, False],
        index=['viper', 'sidewinder', 'cobra'])]
'''
max_speed  shield
sidewinder          7       8
'''

索引（与 df.reindex 行为相同）

df.loc[pd.Index(["cobra", "viper"], name="foo")]
'''
       max_speed  shield
foo
cobra          1       2
viper          4       5
'''

条件表达式返回布尔 Series

df.loc[df['shield'] > 6]
            max_speed  shield
sidewinder          7       8

返回指定了列标签的布尔 Series 的条件

df.loc[df['shield'] > 6, ['max_speed']]
'''
            max_speed
sidewinder          7
'''

可调用函数返回布尔 Series

df.loc[lambda df: df['shield'] == 8]
'''
            max_speed  shield
sidewinder          7       8
'''

接下来我们看看设定值，修改数据。

设置与标签列表匹配的所有项的值：

df.loc[['viper', 'sidewinder'], ['shield']] = 50
df
'''
            max_speed  shield
cobra               1       2
viper               4      50
sidewinder          7      50
'''

整行的设置值

df.loc['cobra'] = 10
df
'''
            max_speed  shield
cobra              10      10
viper               4      50
sidewinder          7      50
'''

设置整列的值

df.loc[:, 'max_speed'] = 30
df
'''
            max_speed  shield
cobra              30      10
viper              30      50
sidewinder         30      50
'''

为匹配可调用条件的行设置值

df.loc[df['shield'] > 35] = 0
df
'''
            max_speed  shield
cobra              30      10
viper               0       0
sidewinder          0       0
'''

获取具有整数标签的索引的 DataFrame 上的值，另一个使用整数作为索引的示例

df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
      index=[7, 8, 9], columns=['max_speed', 'shield'])
df
'''
   max_speed  shield
7          1       2
8          4       5
9          7       8
'''

对行使用整数标签进行切片。如上所述，请注意，切片的开始和停止都包括在内。

df.loc[7:9]
'''
   max_speed  shield
7          1       2
8          4       5
9          7       8
'''

接下来看看使用多重索引（MultiIndex）获取值，使用带有多索引的 DataFrame 的示例

tuples = [
    ('cobra', 'mark i'), ('cobra', 'mark ii'),
    ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'),
    ('viper', 'mark ii'), ('viper', 'mark iii')
]
index = pd.MultiIndex.from_tuples(tuples)
values = [[12, 2], [0, 4], [10, 20],
         [1, 4], [7, 1], [16, 36]]
df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index)
df
'''
                     max_speed  shield
cobra      mark i           12       2
           mark ii           0       4
sidewinder mark i           10      20
           mark ii           1       4
viper      mark ii           7       1
           mark iii         16      36
'''

单一标签。注意这将返回一个带有单个索引的 DataFrame

df.loc['cobra']
'''
         max_speed  shield
mark i          12       2
mark ii          0       4
'''

单索引元组。注意，这将返回一个序列。

df.loc[('cobra', 'mark ii')]
'''
max_speed    0
shield       4
Name: (cobra, mark ii), dtype: int64
'''

行和列的单个标签。类似于传递元组，它返回一个序列。

df.loc['cobra', 'mark i']
'''
max_speed    12
shield        2
Name: (cobra, mark i), dtype: int64
'''

单元组。注意使用[[]]返回数据帧。

df.loc[[('cobra', 'mark ii')]]
'''
               max_speed  shield
cobra mark ii          0       4
'''

索引的单个元组，列的单个标签

df.loc[('cobra', 'mark i'), 'shield']
# 2

从索引元组切片到单个标签

df.loc[('cobra', 'mark i'):'viper']
'''
                     max_speed  shield
cobra      mark i           12       2
           mark ii           0       4
sidewinder mark i           10      20
           mark ii           1       4
viper      mark ii           7       1
           mark iii         16      36
'''

从索引元组到索引元组切片

df.loc[('cobra', 'mark i'):('viper', 'mark ii')]
'''
                    max_speed  shield
cobra      mark i          12       2
           mark ii          0       4
sidewinder mark i          10      20
           mark ii          1       4
viper      mark ii          7       1
'''

Series

由于 Series 是一维的，因此，Series 使用 loc 时只需要传入一个元素，不能传入多个元素。

与 iloc 的区别

iloc[] 是一种基于自然索引的选择方法，这意味着我们必须在方法中传递整数索引才能选择特定的行/列。

loc iloc

支持对象

可以调用 loc[] 的对象还有以下对象：

pandas.DataFrame.loc
pandas.Series.loc