Using positional indexing in pandas DataFrames is essential for effective data manipulation. The iloc indexer allows you to access rows and columns by integer position, which is particularly useful when you want to ignore the actual labels of the DataFrame.
To illustrate this, let’s create a simple DataFrame and explore how iloc works. First, we’ll import the necessary library and create a DataFrame.
import pandas as pd
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 27, 22, 32],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df = pd.DataFrame(data)
print(df)
This will output a DataFrame with names, ages, and cities. Now, if you want to access the first row of data, you can use iloc like this:
first_row = df.iloc[0] print(first_row)
What you get is a Series containing the data for Alice. You can also retrieve a specific column by its index. For example, to get the ‘Age’ column:
age_column = df.iloc[:, 1] print(age_column)
This syntax uses a colon for rows and specifies the column index. It’s worth noting that iloc is zero-based, meaning the first column is index 0. You can also access a specific cell by combining row and column indices.
alice_age = df.iloc[0, 1] print(alice_age)
The above code will yield the age of Alice directly. The flexibility of iloc allows you to slice DataFrames easily. For instance, if you want to access the first two rows of the DataFrame:
first_two_rows = df.iloc[0:2] print(first_two_rows)
Here, 0:2 indicates that you want rows at index 0 and 1. This slicing technique can be extended to both rows and columns. If you need a specific range of rows and columns, you can specify it like this:
subset = df.iloc[0:3, 1:3] print(subset)
This retrieves the first three rows and the second and third columns, essentially giving you a sub-DataFrame focused on age and city. As you can see, iloc is a powerful tool for positional indexing, and mastering it can greatly enhance your data manipulation capabilities.
With this understanding, you can efficiently navigate through your DataFrame, making data extraction both intuitive and precise. The best practice is to combine iloc with other DataFrame operations for more complex data analysis tasks, such as filtering and aggregating. Next, let’s explore the nuances of slicing rows and columns with iloc in more detail.
Now retrieving an image set.
Apple 2026 MacBook Neo 13-inch Laptop with A18 Pro chip: Built for AI and Apple Intelligence, Liquid Retina Display, 8GB Unified Memory, 256GB SSD Storage, 1080p FaceTime HD Camera; Indigo
$657.41 (as of July 16, 2026 15:40 GMT +00:00 - More infoProduct prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on [relevant Amazon Site(s), as applicable] at the time of purchase will apply to the purchase of this product.)Mastering row and column slicing with iloc
When slicing with iloc, remember that the end index is exclusive, just like standard Python slicing. This means df.iloc[0:3] returns rows at positions 0, 1, and 2, but not 3. This behavior applies to both row and column slicing.
You can also mix single indices with slices. For example, to select a single row but multiple columns:
row_1_cols_0_to_2 = df.iloc[1, 0:2] print(row_1_cols_0_to_2)
This extracts the second row (Bob) and the first two columns (‘Name’ and ‘Age’). The result is a Series containing those values.
Conversely, selecting multiple rows but a single column is just as straightforward:
rows_1_to_3_col_2 = df.iloc[1:4, 2] print(rows_1_to_3_col_2)
This returns the ‘City’ values for rows 1 through 3 (Bob, Charlie, and David). Because you selected a single column, the output is a Series indexed by the row positions.
For more complex slicing, you can combine lists of indices with slices. For example, if you want specific rows and columns:
subset = df.iloc[[0, 2], 0:2] print(subset)
This selects rows 0 and 2 (Alice and Charlie), and columns 0 and 1 (‘Name’ and ‘Age’). The result is a DataFrame with just those entries.
Using negative indices with iloc works similarly to Python lists. For instance, df.iloc[-1] returns the last row, and df.iloc[-3:-1] slices from the third-last up to (but not including) the last row.
Keep in mind that iloc does not support boolean indexing. If you want to filter based on conditions, use loc instead. However, you can combine boolean indexing with iloc by first filtering rows, then applying positional slicing:
filtered = df[df['Age'] > 23] subset = filtered.iloc[0:2, 0:2] print(subset)
This filters the DataFrame to rows where ‘Age’ is greater than 23, then selects the first two rows and first two columns of that filtered DataFrame.
To summarize the slicing syntax:
df.iloc[row_slice, column_slice] # Examples: df.iloc[2] # single row (3rd row) df.iloc[:, 1] # entire second column df.iloc[1:4, 0:2] # rows 1-3, columns 0-1 df.iloc[[0, 3], [1, 2]] # rows 0 and 3, columns 1 and 2
Mastering these patterns lets you extract exactly the data you want, no matter how complex your DataFrame structure is.
