pandas.Series.loc#

property Series.loc[源代码]#

通过标签或布尔数组访问一组行和列。

.loc[] 主要是基于标签的,但也可以与布尔数组一起使用。

允许的输入是:

  • 一个单独的标签,例如 5'a' ,(注意 5 被解释为索引的 标签 ,并且 绝不是 作为索引沿线的整数位置)。

  • 标签的列表或数组,例如 ['a', 'b', 'c']

  • 带有标签的切片对象,例如 'a':'f'

    警告

    请注意,与通常的 python 切片相反,两者 起始和结束都包括在内

  • 一个与被切片轴长度相同的布尔数组,例如 [True, False, True]

  • 一个可对齐的布尔序列。键的索引在对齐掩码之前将对齐。

  • 一个可对齐的索引。返回选择项的索引将是输入。

  • 一个带有单个参数(调用的 Series 或 DataFrame)的 callable 函数,并返回有效的索引输出(上述之一)

更多信息请参见 按标签选择

引发:
KeyError

如果任何项目未找到。

索引错误

如果传递了一个索引键,但其索引无法与帧索引对齐。

参见

DataFrame.at

访问行/列标签对的一个单一值。

DataFrame.iloc

通过整数位置访问行和列的组。

DataFrame.xs

返回 Series/DataFrame 的一个横截面(行或列)。

Series.loc

使用标签访问值组。

例子

获取值

>>> 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

单一标签。注意这返回的是一行作为 Series。

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

标签列表。注意使用 [[]] 返回一个 DataFrame。

>>> 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

可对齐的布尔序列:

>>> 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

返回布尔序列的条件

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

返回一个布尔序列的条件,带有指定的列标签

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

使用 & 返回布尔序列的多个条件

>>> df.loc[(df["max_speed"] > 1) & (df["shield"] < 8)]
            max_speed  shield
viper          4       5

使用 | 的多个条件返回一个布尔序列

>>> df.loc[(df["max_speed"] > 4) | (df["shield"] < 5)]
            max_speed  shield
cobra               1       2
sidewinder          7       8

请确保每个条件都用括号 () 包裹。有关布尔索引的更多详细信息和解释,请参阅 用户指南

备注

如果你发现自己在一个 .loc[] 中使用了3个或更多的条件,考虑使用 高级索引

请参见下方关于在 MultiIndex DataFrame 上使用 .loc[] 的内容。

返回布尔序列的可调用对象

>>> 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

添加值匹配位置

>>> df.loc["viper", "shield"] += 5
>>> df
            max_speed  shield
cobra              30      10
viper               0       5
sidewinder          0       0

使用 SeriesDataFrame 设置值时,设置的是与索引标签匹配的值,而不是索引位置。

>>> shuffled_df = df.loc[["viper", "cobra", "sidewinder"]]
>>> df.loc[:] += shuffled_df
>>> df
            max_speed  shield
cobra              60      20
viper               0      10
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 获取值

使用带有 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

单一索引元组。注意这返回一个 Series。

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

行和列的单一标签。类似于传递一个元组,这将返回一个 Series。

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

单个元组。注意使用 [[]] 返回一个 DataFrame。

>>> 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

更多详细信息和高级索引的解释,请参见 用户指南