pandas.Series.iloc — pandas 3.0.0rc0+33.g1fd184de2a documentation (original) (raw)

property Series.iloc[source]#

Purely integer-location based indexing for selection by position.

Changed in version 3.0: Callables which return a tuple are deprecated as input.

.iloc[] is primarily integer position based (from 0 tolength-1 of the axis), but may also be used with a boolean array.

Allowed inputs are:

• An integer, e.g. 5.
• A list or array of integers, e.g. [4, 3, 0].
• A slice object with ints, e.g. 1:7.
• A boolean array.
• A callable function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above). This is useful in method chains, when you don’t have a reference to the calling object, but would like to base your selection on some value.
• A tuple of row and column indexes. The tuple elements consist of one of the above inputs, e.g. (0, 1).

.iloc will raise IndexError if a requested indexer is out-of-bounds, except slice indexers which allow out-of-bounds indexing (this conforms with python/numpy slice semantics).

See more at Selection by Position.

See also

DataFrame.iat

Fast integer location scalar accessor.

DataFrame.loc

Purely label-location based indexer for selection by label.

Series.iloc

Purely integer-location based indexing for selection by position.

Examples

mydict = [ ... {"a": 1, "b": 2, "c": 3, "d": 4}, ... {"a": 100, "b": 200, "c": 300, "d": 400}, ... {"a": 1000, "b": 2000, "c": 3000, "d": 4000}, ... ] df = pd.DataFrame(mydict) df a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000

Indexing just the rows

With a scalar integer.

type(df.iloc[0]) <class 'pandas.Series'> df.iloc[0] a 1 b 2 c 3 d 4 Name: 0, dtype: int64

With a list of integers.

df.iloc[[0]] a b c d 0 1 2 3 4 type(df.iloc[[0]]) <class 'pandas.DataFrame'>

df.iloc[[0, 1]] a b c d 0 1 2 3 4 1 100 200 300 400

With a slice object.

df.iloc[:3] a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000

With a boolean mask the same length as the index.

df.iloc[[True, False, True]] a b c d 0 1 2 3 4 2 1000 2000 3000 4000

With a callable, useful in method chains. The x passed to the lambda is the DataFrame being sliced. This selects the rows whose index label even.

df.iloc[lambda x: x.index % 2 == 0] a b c d 0 1 2 3 4 2 1000 2000 3000 4000

Indexing both axes

You can mix the indexer types for the index and columns. Use : to select the entire axis.

With scalar integers.

df.iloc[0, 1] np.int64(2)

With lists of integers.

df.iloc[[0, 2], [1, 3]] b d 0 2 4 2 2000 4000

With slice objects.

df.iloc[1:3, 0:3] a b c 1 100 200 300 2 1000 2000 3000

With a boolean array whose length matches the columns.

df.iloc[:, [True, False, True, False]] a c 0 1 3 1 100 300 2 1000 3000

With a callable function that expects the Series or DataFrame.

df.iloc[:, lambda df: [0, 2]] a c 0 1 3 1 100 300 2 1000 3000