How Are Iloc and Loc Different?

Question

Can someone explain how these two methods of slicing are different?
I've seen the docs, and I've seen these answers, but I still find myself unable to understand how the three are different. To me, they seem interchangeable in large part, because they are at the lower levels of slicing.

For example, say we want to get the first five rows of a DataFrame. How is it that these two work?

df.loc[:5]
df.iloc[:5]

Can someone present three cases where the distinction in uses are clearer?

Once upon a time, I also wanted to know how these two functions differ from df.ix[:5] but ix has been removed from pandas 1.0, so I don't care anymore.

Accepted Answer

Must Read

Label vs. Location

The main distinction between the two methods is:

loc gets rows (and/or columns) with particular labels.
iloc gets rows (and/or columns) at integer locations.

To demonstrate, consider a series s of characters with a non-monotonic integer index:

>>> s = pd.Series(list("abcdef"), index=[49, 48, 47, 0, 1, 2]) 
49    a
48    b
47    c
0     d
1     e
2     f

>>> s.loc[0]    # value at index label 0
'd'

>>> s.iloc[0]   # value at index location 0
'a'

>>> s.loc[0:1]  # rows at index labels between 0 and 1 (inclusive)
0    d
1    e

>>> s.iloc[0:1] # rows at index location between 0 and 1 (exclusive)
49    a

Here are some of the differences/similarities between s.loc and s.iloc when passed various objects:

<object>	description	`s.loc[<object>]`	`s.iloc[<object>]`
`0`	single item	Value at index label `0` (the string `'d'`)	Value at index location 0 (the string `'a'`)
`0:1`	slice	Two rows (labels `0` and `1`)	One row (first row at location 0)
`1:47`	slice with out-of-bounds end	Zero rows (empty Series)	Five rows (location 1 onwards)
`1:47:-1`	slice with negative step	three rows (labels `1` back to `47`)	Zero rows (empty Series)
`[2, 0]`	integer list	Two rows with given labels	Two rows with given locations
`s > 'e'`	Bool series (indicating which values have the property)	One row (containing `'f'`)	`NotImplementedError`
`(s>'e').values`	Bool array	One row (containing `'f'`)	Same as `loc`
`999`	int object not in index	`KeyError`	`IndexError` (out of bounds)
`-1`	int object not in index	`KeyError`	Returns last value in `s`
`lambda x: x.index[3]`	callable applied to series (here returning 3^rd item in index)	`s.loc[s.index[3]]`	`s.iloc[s.index[3]]`

loc's label-querying capabilities extend well-beyond integer indexes and it's worth highlighting a couple of additional examples.

Here's a Series where the index contains string objects:

>>> s2 = pd.Series(s.index, index=s.values)
>>> s2
a    49
b    48
c    47
d     0
e     1
f     2

Since loc is label-based, it can fetch the first value in the Series using s2.loc['a']. It can also slice with non-integer objects:

>>> s2.loc['c':'e']  # all rows lying between 'c' and 'e' (inclusive)
c    47
d     0
e     1

For DateTime indexes, we don't need to pass the exact date/time to fetch by label. For example:

>>> s3 = pd.Series(list('abcde'), pd.date_range('now', periods=5, freq='M')) 
>>> s3
2021-01-31 16:41:31.879768    a
2021-02-28 16:41:31.879768    b
2021-03-31 16:41:31.879768    c
2021-04-30 16:41:31.879768    d
2021-05-31 16:41:31.879768    e

Then to fetch the row(s) for March/April 2021 we only need:

>>> s3.loc['2021-03':'2021-04']
2021-03-31 17:04:30.742316    c
2021-04-30 17:04:30.742316    d

How Are Iloc and Loc Different?

6 Answers

Must Read

Label vs. Location

Marcus Vance