loc vs iloc in Pandas. Here’s The Difference.

How to select rows and columns in Pandas with loc and iloc

When it comes to selecting data in Pandas, there are different alternatives. One of the most popular is using loc and iloc, but what are the differences between them?

I had the same question when I started learning Pandas and, in this article, I’ll show you the main differences between selecting data with loc and iloc in Pandas and also show some examples to make it clear.

By the end of this article, you’ll know how to select single values, multiple rows, and columns using both loc and iloc.

Differences between loc and iloc

The main difference between loc and iloc is that loc is label-based (you need to specify the row and column labels) while iloc is integer-position based (you need to specify the row and column by the integer position values, which start with 0)

Below are practical examples to understand this much better. You can either watch my YouTube video or continue reading this article.

Consider the dataframe with the following row labels and row positions:

Now let’s see how we’d select a random element using loc and iloc:

In the examples above, loc and iloc return the same output except for the slicing where the last element is included in the loc and excluded in the iloc.

Selecting elements from a Dataframe using loc and iloc

To see in detail de differences between loc and iloc let’s create a dataframe with basic information about top football players.

Here’s the code to create this little dataframe:

And here’s the dataframe you should obtain after running the code:

Now let’s see how we can select elements from a dataframe with a single value, list, and slicing.

Selecting data with a single value

We can locate elements with loc and iloc by adding a single value as input. Here’s the syntax to follow:

• loc[row_label, column_label]
• iloc[row_position, column_position]

Say we want to get the height of Lionel Messi.

# get the height of L.Messi

# loc
>>> df.loc['L. Messi', 'height_cm']
# iloc
>>> df.iloc[0, 1]

170

As you can see loc needs the “L.Messi” and “height_cm” because they’re their row/column labels, while iloc needs 0 and 1 because they’re the row/column position. Both methods get the same output 170, which is the height of Lionel Messi.

Now let’s get the height of Cristiano Ronaldo.

# get the height of Cristiano Ronaldo

# loc
>>> df.loc['Cristiano Ronaldo', 'height_cm']
# iloc
>>> df.iloc[1, 1]

187

In case you want to get all the data of a specific row/column, use the : in both loc and iloc.

# get all the data about L.Messi

# loc
>>> df.loc['L. Messi', :]
# iloc
>>> df.iloc[0, :]

age                             32
height_cm                      170
nationality              Argentina
club           Paris Saint-Germain

Selecting multiple rows/columns with a list

We can use a list of labels/positions to select multiple rows and columns with loc and iloc respectively.

# get all data about L.Messi and Cristiano Ronaldo

# loc
>>> df.loc[['L. Messi', 'Cristiano Ronaldo']]
# iloc
>>> df.iloc[[0, 1]]

Here’s the output of our selection:

Now let’s get only the height of these two players by adding the ‘height_cm’ column label/‘1’ column position to loc and iloc respectively.

# get the height of L.Messi and Cristiano Ronaldo

# loc
>>> df.loc[['L. Messi', 'Cristiano Ronaldo'], 'height_cm']
# iloc
>>> df.iloc[[0, 1], 1]

L. Messi             170
Cristiano Ronaldo    187

Selecting multiple rows/columns with a slice

We can also select multiple rows and columns with a slice with both loc and iloc.

Let’s do a slice that gets the column ‘age’, ‘height_cm’, and ‘nationality’.

# slice column labels: from age to nationality

# loc
>>> players = ['L. Messi', 'Cristiano Ronaldo']
>>> df.loc[players, 'age':'nationality']
# iloc
>>> players = [0, 1]
>>> df.iloc[players, 0:3] # age:nationality+1

Unlike lists, when we select elements with a slice the last element “nationality” is included in the loc method, while the last element “3” is excluded in the iloc.

Here’s the output we get for both loc and iloc:

Selecting with conditions

Whenever you want to select elements based on certain conditions, keep in mind that iloc needs a boolean list, so we have to use the list() function to convert our Series to a boolean list.

# one condition: select player with height above 180cm

# loc
columns = ['age', 'height_cm', 'club']
df.loc[df['height_cm']>180, columns]
# iloc
columns = [0,1,3]
df.iloc[list(df['height_cm']>180), columns]

Here’s the output we get for both loc and iloc:

The same rule goes in case you want to apply multiple conditions. Say we want to obtain players with a height above 180cm that played in PSG.

# multiple conditions: select player with height above 180cm that played in PSG

# loc
df.loc[(df['height_cm']>170) & (df['club']=='Paris Saint-Germain'), :]
# iloc
df.iloc[list((df['height_cm']>170) & (df['club']=='Paris Saint-Germain')), :]

Here’s the output we get for both loc and iloc:

That’s it! Now you’re ready to select elements from dataframes using loc and iloc. You can find all the code written in this article on my Github.

Join my email list with 10k+ people to get my Python for Data Science Cheat Sheet I use in all my tutorials (Free PDF)

If you enjoy reading stories like these and want to support me as a writer, consider signing up to become a Medium member. It’s $5 a month, giving you unlimited access to thousands of Python guides and Data science articles. If you sign up using my link, I’ll earn a small commission with no extra cost to you.