Pandas: How to get column position/index by name

Updated: February 17, 2024 By: Guest Contributor Post a comment


Pandas, a cornerstone library in Python for data manipulation and analysis, offers a plethora of functionalities to work with tabular data. One common task that users frequently encounter is finding the position or index of a column by its name. Recognizing the correct position of a column in a DataFrame can be crucial for various tasks, such as data filtering, column reordering, or when applying functions that are position-dependent. This tutorial delves into several approaches to retrieve a column’s position, tailored for both beginners and advanced users, featuring detailed examples and their respective outputs.

Preparing a DataFrame

Before delving into the specifics of finding a column’s position, it’s essential to understand the basic structure of a Pandas DataFrame. A DataFrame is a two-dimensional, size-mutable, and potentially heterogeneous tabular data structure with labeled axes (rows and columns). You can think of it as a spreadsheet or SQL table. Let’s start by creating a simple DataFrame:

import pandas as pd

df = pd.DataFrame({
    'Name': ['John', 'Anna', 'Peter', 'Linda'],
    'Age': [28, 34, 29, 32],
    'Profession': ['Engineer', 'Doctor', 'Artist', 'Lawyer']

This displays:

    Name  Age Profession
0   John   28   Engineer
1   Anna   34     Doctor
2  Peter   29     Artist
3  Linda   32     Lawyer

Basic Method: Using get_loc()

One basic method to find the position of a column is through the get_loc() method available on the DataFrame’s columns attribute. This method returns the integer position of the column for the requested label. For example:

pos = df.columns.get_loc('Age')
print('Position of the column \'Age\':', pos)

This prints:

Position of the column 'Age': 1

The get_loc() method is straightforward and efficient for retrieving the position of a single column. However, if you need the positions of multiple columns, you might consider other approaches.

Advanced Method: Using List Comprehensions

For obtaining the positions of multiple columns by name, list comprehensions can be highly effective. This approach leverages Python’s list comprehension feature to iterate over the columns’ names, applying the get_loc() method to each. An example is shown below:

columns = ['Age', 'Profession']
positions = [df.columns.get_loc(c) for c in columns]
print('Positions of columns:', positions)

This prints:

Positions of columns: [1, 2]

Using list comprehensions is a powerful way to handle multiple columns at once, providing a concise and readable solution.

Working with Column Selection and Data Manipulation

Knowing the position of the columns, you can easily manipulate the DataFrame. For instance, selecting columns, reordering them, or applying functions. Let’s look at an example of how to reorder columns based on their positions:

df = df[[df.columns[2], df.columns[1], df.columns[0]]]

This displays a reordered DataFrame:

  Profession  Age   Name
0   Engineer   28   John
1     Doctor   34   Anna
2     Artist   29  Peter
3     Lawyer   32  Linda

Moreover, understanding column positions can assist in slicing the DataFrame or in applying vectorized operations that depend on column arrangement.


Finding the position of a column in a Pandas DataFrame is a fundamental step in many data manipulation tasks. Starting from the basic get_loc() method to more advanced techniques involving list comprehensions and DataFrame manipulation, this tutorial provided a detailed walkthrough for users at various proficiency levels. Mastering these strategies ensures efficient and precise data handling, enhancing your data analysis workflows.