Skip to content

Effortlessly Iterate Over Rows in pandas


How to Iterate Over Rows in pandas, and Why You Shouldn’t

In this tutorial, we will explore how to iterate over rows in pandas DataFrames and discuss why it’s generally recommended to avoid iteration. We will also cover alternative methods that offer better performance and efficiency.

How to Iterate Over DataFrame Rows in pandas

While it is possible to iterate over DataFrame rows using methods like .itertuples() and .iterrows(), this approach may not be the most effective way to work with pandas DataFrames. There are certain cases where iteration can be useful, such as when you need to feed information sequentially into another API, when you require side effects on each row like making HTTP requests, or when you need to perform complex operations involving multiple columns.

To iterate over rows using .iterrows(), you can use the following code:

import pandas as pd
# Create a sample DataFrame
data = {'Name': ['John', 'Alice', 'Bob'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
# Iterate over rows
for index, row in df.iterrows():
print(row['Name'], row['Age'])


John 25
Alice 30
Bob 35

However, it’s important to note that iterating over DataFrame rows can be slow and inefficient, especially for large datasets. It introduces a performance penalty because pandas is optimized for vectorized operations rather than row-by-row iteration.

Why You Should Generally Avoid Iterating Over Rows in pandas

While iteration may initially seem like a convenient way to work with DataFrames, there are several reasons why it’s recommended to avoid it:

  1. Performance: Iterating over rows has a significant performance penalty compared to using vectorized operations. Pandas provides optimized methods that can process the entire DataFrame or large chunks of it at once, resulting in faster execution times.

  2. Code simplicity: Vectorized operations allow for cleaner and more concise code. Built-in pandas methods and functions can perform complex operations with fewer lines of code compared to manually iterating over rows.

  3. Readability: Vectorized operations make your code easier to understand and interpret. It’s easier to see the intent and logic behind vectorized operations compared to looping over rows, which can make your code more maintainable in the long term.

  4. Functionality: Iteration limits the functionality and flexibility available in pandas. Vectorized operations offer a wide range of functions and methods that can handle different data types, missing values, and perform operations across multiple columns simultaneously.

Use Vectorized Methods Over Iteration

Instead of iterating over DataFrame rows, it’s generally recommended to use vectorized methods and functions provided by pandas. These methods can operate on entire columns or chunks of data, leading to improved performance and code efficiency.

Here are some examples of vectorized methods commonly used in pandas:

  • df['new_column'] = df['column1'] + df['column2']: Add values from two columns and create a new column.
  • df['column1'].apply(lambda x: x * 2): Apply a function to each value in a column and return the modified values.
  • df['column1'].str.upper(): Convert all values in a string column to uppercase.

By using these vectorized methods, you can perform operations on the entire DataFrame or specific columns efficiently, eliminating the need for iterative row-by-row processing.

Use Intermediate Columns So You Can Use Vectorized Methods

In cases where you need to perform complex operations involving multiple columns, it’s often possible to create intermediate columns to simplify the task and utilize vectorized methods.

For example, suppose you have a DataFrame with columns ‘Height’ and ‘Weight’, and you want to calculate the body mass index (BMI) for each person. Instead of iterating over rows, you can create an intermediate column ‘BMI’ using vectorized operations:

import pandas as pd
# Create a sample DataFrame
data = {'Height': [160, 170, 180], 'Weight': [60, 70, 80]}
df = pd.DataFrame(data)
# Calculate BMI using an intermediate column
df['BMI'] = df['Weight'] / ((df['Height'] / 100) ** 2)
# Print the DataFrame


Height Weight BMI
0 160 60 23.437500
1 170 70 24.221453
2 180 80 24.691358

By using an intermediate column ‘BMI’, we can apply vectorized operations to calculate the BMI for each person without the need for iteration.


While it’s possible to iterate over rows in pandas DataFrames, it’s generally recommended to avoid iteration due to its performance penalty and limitations. Instead, it’s recommended to use vectorized methods and functions that operate on entire columns or chunks of data. These methods offer better performance, code efficiency, readability, and functionality compared to iterative row-by-row processing.

By utilizing the power of vectorized operations in pandas, you can effectively work with DataFrames and perform complex operations more efficiently.