DataFrame.iloc ⚬

|↑| DataFrame ⚬ᵖᵈ | DataFrame.iloc ⚬ ⦍֎_⦎
⮞ 🟣 𓂃𓂃𓂃
⮞ ➔ DataFrame.loc ⚬
⮞ ⛛ 𓂃𓂃𓂃

⤷ ・・・ ・・・ ・・・

---

---

Entries

၊၊||၊|။

DataFrame.iloc ⚬｜Documentation｜1st｜20251021134634-00-⌔

pandas.DataFrame.iloc — pandas 2.3.3 documentation#pandas.DataFrame.iloc

property DataFrame.iloc

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

Printed 2026-06-28.

(echo:: @ ᯤ)

Link to original

⤷ ・・・・・・・・・

---

Fields

admin::|[[|⚐]],[[|⚐]],[[|⚐]],[[|⚐]],[[|⚐]],
withheld::|————
relation::|————
parent_::|————
parent::|↑| DataFrame ⚬ᵖᵈ | DataFrame.iloc ⚬ ⦍֎_⦎