modin.pandas.Series.loc

property Series.loc[source] (https://github.com/snowflakedb/snowpark-python/blob/v1.26.0/snowpark-python/src/snowflake/snowpark/modin/plugin/extensions/base_overrides.py#L1510-L1523)

Access a group of rows and columns by label(s) or a boolean array.

.loc[] is primarily label based, but may also be used with a boolean array.

Allowed inputs are:

  • A single label, e.g. 5 or 'a', (note that 5 is interpreted as a label of the index, and never as an integer position along the index).

  • A list or array of labels, e.g. ['a', 'b', 'c'].

  • A slice object with labels, e.g. 'a':'f'.

    Warning

    Note that contrary to usual python slices, both the start and the stop are included

  • A boolean array of the same length as the axis being sliced, e.g. [True, False, True].

  • An alignable boolean Series. The index of the key will be aligned before masking.

  • An alignable Index. The Index of the returned selection will be the input.

  • A callable function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above)

Notes

To meet the nature of lazy evaluation:

  • Snowpark pandas .loc ignores out-of-bounds indexing for row indexers (while pandas .loc may raise KeyError). If all values are out-of-bound, an empty result will be returned.

  • Out-of-bounds indexing for columns will still raise a KeyError the same way pandas does.

  • In Snowpark pandas .loc, unalignable boolean Series provided as indexer will perform a join on the index of the main dataframe or series. (while pandas will raise an IndexingError)

  • When there is a slice key, Snowpark pandas .loc performs the same as native pandas when both the start and stop are labels present in the index or either one is absent but the index is sorted. When any of the two labels is absent from an unsorted index, Snowpark pandas will return rows in between while native pandas will raise a KeyError.

  • Special indexing for DatetimeIndex is unsupported in Snowpark pandas, e.g., partial string indexing (https://pandas.pydata.org/docs/user_guide/timeseries.html#partial-string-indexing).

  • While setting rows with duplicated index, Snowpark pandas won’t raise ValueError for duplicate labels to avoid eager evaluation.

  • When using .loc to set values with a Series key and Series item, the index of the item is ignored, and values are set positionally.

  • pandas .loc may sometimes raise a ValueError when using .loc to set values in a DataFrame from a Series using a Series as the column key, but Snowpark pandas .loc supports this type of operation according to the rules specified above.

  • .loc with boolean indexers for columns is currently unsupported.

  • When using .loc to set column values for a Series item, with a slice(None) for the row columns, Snowpark pandas sets the value for each row from the Series.

See also

DataFrame.at

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

DataFrame.iloc

Access group of rows and columns by integer position(s).

DataFrame.xs

Returns a cross-section (row(s) or column(s)) from the Series/DataFrame.

Series.loc

Access group of values using labels.

Examples

Getting values

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

Single label. Note this returns the row as a Series.

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

List of labels. Note using [[]] returns a DataFrame.

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

Single label for row and column

>>> df.loc['cobra', 'shield']
2
Copy

Slice with labels for row and single label for column. As mentioned above, note that both the start and stop of the slice are included.

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

Boolean list with the same length as the row axis

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

Alignable boolean Series:

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

Index (same behavior as df.reindex)

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

Conditional that returns a boolean Series

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

Conditional that returns a boolean Series with column labels specified

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

Callable that returns a boolean Series

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

Setting values

Set value for all items matching the list of labels

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

Set value for an entire row

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

Set value for an entire column

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

Set value for rows matching callable condition

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

Setting the values with a Series item.

>>> df.loc["viper"] = pd.Series([99, 99], index=["max_speed", "shield"])
>>> df
            max_speed  shield
cobra              30      10
viper              99      99
sidewinder          0       0
Copy

Getting values on a DataFrame with an index that has integer labels

Another example using integers for the index

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

Slice with integer labels for rows. As mentioned above, note that both the start and stop of the slice are included.

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

Getting values with a MultiIndex

A number of examples using a DataFrame with a MultiIndex

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

Single label. Note this returns a DataFrame with a single index.

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

Single index tuple. Note this returns a Series.

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

Single label for row and column. Similar to passing in a tuple, this returns a Series.

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

Single tuple. Note using [[]] returns a DataFrame.

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

Single tuple for the index with a single label for the column

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

Slice from index tuple to single label

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

Slice from index tuple to index tuple

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

Set column values from Series with Series key.

>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=list("ABC"))
>>> df.loc[:, pd.Series(list("ABC"))] = pd.Series([-10, -20, -30])
>>> df
    A   B   C
0 -10 -20 -30
1 -10 -20 -30
>>> df.loc[:, pd.Series(list("ABC"))] = pd.Series([10, 20, 30], index=list("CBA"))
>>> df
    A   B   C
0  10  20  30
1  10  20  30
>>> df.loc[:, pd.Series(list("BAC"))] = pd.Series([-10, -20, -30], index=list("ABC"))
>>> df
    A   B   C
0 -20 -10 -30
1 -20 -10 -30
Copy

Set column values from Series with list key.

>>> df.loc[:, list("ABC")] = pd.Series([1, 3, 5], index=list("CAB"))
>>> df
   A  B  C
0  3  5  1
1  3  5  1
Copy

Set column values for all rows from Series item.

>>> df.loc[:, "A":"B"] = pd.Series([10, 20, 30], index=list("ABC"))
>>> df
    A   B  C
0  10  20  1
1  10  20  1
Copy
Language: English