LOC vs ILOC Pandas: Understanding the Key Differences, Similarities, and More

In Pandas, loc allows you to access data using row and column labels (names), while iloc selects data based on the integer positions of rows and columns.

Understanding the difference between loc vs iloc Pandas is particularly important in data science tasks like feature engineering, filtering data, or performing operations on large datasets.

What is loc in Pandas? Examples and Use Cases

In Pandas, loc is a label-based data selection method that allows you to access rows and columns using their labels or index names. 

loc is used when you want to retrieve specific data from a DataFrame based on the index labels and column names. loc ensures accurate selection based on labels.

Here’s the syntax of .loc in Python.

df.loc[rows, columns]

Where, 

rows specifies the label(s) of the rows to select.

columns specifies the label(s) of the columns to select.

To understand the implementation of loc using the above syntax, check out the following example, including its different use cases.

loc in Pandas Using Example

The use of loc in Pandas can be better understood through an example, where you can perform various operations using its syntax.
Let's begin by creating a DataFrame and then use loc to access specific data.

import pandas as pd
# Sample DataFrame with names
data = {
    'Name': ['Arjun', 'Priya', 'Rajesh', 'Sita'],
    'Age': [25, 28, 22, 30],
    'City': ['Mumbai', 'Delhi', 'Bengaluru', 'Chennai']
}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df)

Output:

       Age           City
Name                       
Arjun    25         Mumbai
Priya    28          Delhi
Rajesh   22     Bengaluru
Sita     30        Chennai

Now that you’ve created a sample DataFrame, let’s use loc to perform various operations such as selecting a particular row or modifying data.

1. Selecting a row by label

You can access specific rows by name (like 'Arjun', 'Priya') rather than by numeric index positions. In case labels are missing, loc raises a KeyError because it requires explicit row and column labels to access data.

# Select row for 'Priya'
print(df.loc['Priya'])

Output:

Age             28
City        Delhi
Name: Priya, dtype: object

2. Selecting specific rows and columns

Use loc to select both rows and columns at the same time, like getting the 'Age' and 'City' for specific names.

# Select Age and City for 'Arjun' and 'Sita'
print(df.loc[['Arjun', 'Sita'], ['Age', 'City']])

Output:

        Age      City
Name                    
Arjun    25    Mumbai
Sita     30   Chennai

3. Conditional selection

You can filter data using conditions like df['Age'] > 25 to get only those people whose age is greater than 25.

# Select rows where Age is greater than 25
print(df.loc[df['Age'] > 25])

Output:

 Age      City
Name                    
Priya    28     Delhi
Sita     30   Chennai

4. Setting values using loc 

Using loc, you can update values for specific rows and columns, which is useful for modifying individual entries in the DataFrame. The use of loc for this task ensures readability and accuracy when working with labeled indices.

# Modify the age for Rajesh to 26
df.loc['Rajesh', 'Age'] = 26
print(df.loc['Rajesh'])

Output:

Age                26
City        Bengaluru
Name: Rajesh, dtype: object

Updated DataFrame:

        Age        City
Name                   
Arjun    25      Mumbai
Priya    28       Delhi
Rajesh   26   Bengaluru
Sita     30     Chennai

5. Selecting a range of rows by label

Using loc, you can easily select a range of rows using the labels, such as from 'Rajesh' to 'Sita'.

# Select rows from 'Rajesh' to 'Sita' inclusively
print(df.loc['Rajesh':'Sita'])

Output:

       Age         City
Name                         
Rajesh   22   Bengaluru
Sita     30     Chennai

Now that you have discovered how loc allows you to access rows and columns using their labels, let’s check out how you can use positional-based indexing to access elements.

What is iloc in Python? Examples and Applications

In Pandas, iloc is an integer-location-based indexing method that selects rows and columns from a DataFrame using their integer positions, not by their labels or names. 

Here’s the syntax for using iloc in Pandas.

df.iloc[rows, columns]

Where, 

rows specifies the integer position(s) of the rows to select.

columns specifies the integer position(s) of the columns to select.

Learn the basics of Python programming and explore its applications for tasks such as data analysis. Join the Learn Basic Python Programming course.

To understand how iloc is used to access elements in a particular row or column, let’s explore a particular example and then consider different use cases.

iloc in Pandas Using Example

The first step is to create a sample DataFrame, which contains the names, ages and cities as data.

Here’s a code snippet for creating the DataFrame.

import pandas as pd
# Sample DataFrame with Indian names
data = {
    'Name': ['Arjun', 'Priya', 'Rajesh', 'Sita'],
    'Age': [25, 28, 22, 30],
    'City': ['Mumbai', 'Delhi', 'Bengaluru', 'Chennai']
}
df = pd.DataFrame(data)
print(df)

Output:

     Name  Age         City
0   Arjun   25       Mumbai
1   Priya   28        Delhi
2  Rajesh   22   Bengaluru
3    Sita   30      Chennai

Now that you’ve created a sample dataset, let’s understand how to use iloc for specific use cases, such as selecting rows, modifying data, or slicing the dataset.

1. Selecting a row by integer position

iloc is particularly useful when you need to access rows by their position in the DataFrame.

# Select the second row using the indexing method (index 1)
print(df.iloc[1])

Output:

Name       Priya
Age          28
City       Delhi
Name: 1, dtype: object

2. Selecting specific rows and columns

Just like rows, columns can also be accessed using their integer positions.

# Select the Age and City columns for the first two rows (index 0 and 1)
print(df.iloc[0:2, [1, 2]])

Output:

Age         City
0   25       Mumbai
1   28        Delhi

3. Using negative indices

Similar to Python lists, you can use negative indices with iloc. 

# Select the last row using position-based negative indexing(using -1 to get the last position)
print(df.iloc[-1])

Output:

Name        Sita
Age          30
City     Chennai
Name: 3, dtype: object

4. Selecting a single element

You can use iloc to access a specific cell by passing the row index and column index.

# Select the element from the second row and the third column (Age for 'Priya')
print(df.iloc[1, 1])

Output:

28

5. Slicing rows

You can slice rows using iloc, just like list slicing in Python. For example, df.iloc[0:3] will return the first three rows.

# Implement slicing by selecting the first three rows
print(df.iloc[:3])

Output:

     Name  Age         City
0   Arjun   25       Mumbai
1   Priya   28        Delhi
2  Rajesh   22   Bengaluru

6. Modify Data

You can also modify specific rows and columns in the DataFrame using integer positions with iloc.

# Modify data of Arjun's age and Rajesh's city using .iloc
df.iloc[0, 1] = 26  # Changing 'Age' of Arjun (first row) to 26
df.iloc[2, 2] = 'Hyderabad'  # Changing 'City' of Rajesh (third row) to 'Hyderabad'
print(df)

Output:        

             Name  Age         City
CustomerID                         
C001        Arjun   26       Mumbai
C002        Priya   28        Delhi
C003       Rajesh   22   Hyderabad
C004        Sita   30      Chennai

Also Read: Pandas Cheat Sheet in Python for Data Science: Complete List for 2025

Now that you’ve seen how to use loc and iloc to access elements in a particular row or column, let’s understand the difference between loc and iloc in Pandas.

upGrad’s Exclusive Data Science Webinar for you –

Watch our Webinar on How to Build Digital & Data Mindset?

Difference Between loc and iloc in Pandas: Key Differences Explained

The difference between loc and iloc is mainly based on the way elements are selected. While loc supports selection based on labels, iloc uses indices for selection. 

Here are the loc vs iloc differences.

Also Read: Mastering Pandas: Important Pandas Functions For Your Next Project

While LOC and ILOC differ in their methods for selecting elements, they share similarities in selecting non-contiguous rows and columns. Let’s explore these similarities in more detail.

loc vs iloc Pandas: Similarities

The loc and iloc methods show similarities when it comes to selecting non-contiguous rows and columns or handling out-of-bound errors.

Here are the similarities between loc vs iloc.

• Simultaneous Selection of Row and Column 

Both loc and iloc allow you to select both rows and columns at the same time, providing flexibility in data retrieval. This is especially useful in scenarios where you need to access a specific data point from a large dataset.

Example: For loc, you can use df.loc['row1', 'col1'] to select a specific value using label-based indexing. iloc uses df.iloc[0, 0] to select a specific value using position-based indexing.

• Handling of Out-of-Bounds Errors

Both loc and iloc throw similar error types when invalid rows or columns are selected. This is useful during debugging when you mistakenly reference non-existent rows/columns.

Example: The loc raises KeyError when an invalid label is provided, while iloc raises IndexError when the out-of-bound index is accessed.

• Accessing Single and Multiple Cells

Both loc and iloc enable the selection of both single values and multiple values from DataFrames.  This will help streamline data extraction when working with subsets of a dataset.

Example: loc uses df.loc['row1', ['col1', 'col2']] to select multiple columns for a specific row. The iloc uses df.iloc[0, [0, 1]] to select multiple columns for the first row.

• Selecting Multiple Rows and Columns

Both loc and iloc support selecting multiple rows and columns by providing a list of label positions. This is beneficial if you need to extract or analyze subsets of the data for modeling or visualization.

Example: loc uses df.loc[['row1', 'row2'], ['col1', 'col2']] to select multiple rows and columns, whereas iloc uses df.iloc[[0, 1], [0, 2]] to perform the same.

• Supports Slicing

Both loc and iloc allow slicing to be performed, allowing you to select a range of rows and columns. It is useful in cases like analyzing data within a specific range or time period.

Example: loc uses df.loc['row1':'row3'] to select all rows from 'row1' to 'row3', including both endpoints. iloc performs slicing with integer positions, where df.iloc[0:3] selects the first three rows but excludes the endpoints. 

While there are differences, loc and iloc provide similar functionality for accessing, modifying, and slicing data in Pandas DataFrames. To understand the behavior of these methods, let’s explore a real-world example.

In-Depth Example: loc and iloc in Pandas

For an in-depth understanding of loc and iloc in Pandas, let’s perform operations on a Telco Customer dataset, which can be sourced from platforms like Kaggle. 

Here’s a step-by-step process to understand the working of loc and iloc for the telecom customer dataset.

1. Adding the Dataset to the DataFrame

The first step is to load the Telco customer dataset into a Pandas DataFrame. You can either create a simple DataFrame from a dictionary or load it from an external CSV or Excel file. In this case, you will create the dataset manually.

import pandas as pd
# Sample Telco Customer DataFrame
data = {
    'CustomerID': ['C001', 'C002', 'C003', 'C004'],
    'Name': ['Rahul', 'Priya', 'Amit', 'Anjali'],
    'Age': [28, 34, 22, 45],
    'City': ['Delhi', 'Mumbai', 'Bengaluru', 'Chennai'],
    'Subscription': ['Basic', 'Premium', 'Basic', 'Premium']
}

# Create a DataFrame
df = pd.DataFrame(data)

# Set 'CustomerID' as the index for better readability
df.set_index('CustomerID', inplace=True)

# Display the DataFrame
print(df)

Output:

            Name  Age           City Subscription
CustomerID                                      
C001        Rahul   28         Delhi       Basic
C002        Priya   34        Mumbai     Premium
C003        Amit   22    Bengaluru       Basic
C004      Anjali   45       Chennai     Premium

Also Read: Pandas Dataframe Astype: Syntax, Data Types, Creating Dataframe

2. Selecting a specific row

The loc selects rows based on their labels (names), while the iloc uses the index to select. Let’s see how loc and iloc is used to select data for different cases.

• Select a specific row using loc

# Select a specific row using loc (based on CustomerID)
loc_result = df.loc['C003']
print("\nSelected Row using loc (CustomerID = C003):")
print(loc_result)

Output:

Selected Row using loc (CustomerID = C003):
Name              Amit
Age                22
City       Bengaluru
Subscription      Basic
Name: C003, dtype: object

Here, loc selects the row corresponding to customer 'C003' using the label.

• Select specific rows using iloc

# Select a specific row using iloc (based on index position, 2nd index)
iloc_result = df.iloc[2]
print("\nSelected Row using iloc (Index position = 2):")
print(iloc_result)

Output:

Selected Row using iloc (Index position = 2):
Name              Amit
Age                22
City       Bengaluru
Subscription      Basic
Name: C003, dtype: object

Here, iloc selects the rows for 'C003' based on index position 2.

3. Difference between loc and iloc for this example

To understand how loc and iloc work, you’ll perform the same operation using both these methods.

• Using loc to select 'Name' and 'City' for 'C003':

loc_result = df.loc['C003', ['Name', 'City']]
print(loc_result)

Output:

Name           Amit
City          Bengaluru
Name: C003, dtype: object

• Using iloc to select 'Name' and 'City' for the third row

iloc_result = df.iloc[2, [0, 3]]
print(iloc_result)

Output:

Name           Amit
City           Bengaluru
Name: C003, dtype: object

You can observe that loc uses the label 'C003' to select data, while iloc uses the integer position (2) to select the third row. To access columns, loc uses their labels ('Name' and 'City'), while iloc uses the column positions (0 for 'Name' and 3 for 'City').

Now that you’ve understood the workings of loc and iloc through a practical example, let’s now explore ways to boost your knowledge in this field.

Transform Your Career with upGrad’s Expert-Led Programs

In data analytics and machine learning, loc and iloc are essential tools for selecting and manipulating data within Pandas DataFrames. upGrad’s specialized courses will provide you with hands-on learning opportunities to learn tools like Python, Pandas, loc, iloc, and more to solve real-world challenges.

Here are some courses that can help you learn data handling:

• Learn Python Libraries: NumPy, Matplotlib & Pandas
• Programming with Python: Introduction for Beginners
• Introduction to Data Analysis using Excel
• Data Structures & Algorithms

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Stay informed and inspired  with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals