Pandas でループを書かない：試すべき 7 つの高速代替案

**

# Introduction

Row-by-row iteration is one of the most common performance bottlenecks in pandas code. On small datasets it goes unnoticed, but for processing large datasets, this becomes impactful.

pandas is built on top of NumPy, which executes operations on entire arrays at once using compiled C code. Looping through rows in Python bypasses that entirely and forces every operation back into the Python interpreter — one row at a time.

This article covers 7 alternatives to loops in pandas, each suited to a different kind of transformation. By the end, you'll have a clear mental map of which tool to reach for depending on the shape of the problem.

You can get the Colab notebook on GitHub.

# Setting Up the Sample Dataset

We'll use a realistic e-commerce orders dataset throughout this article:

import pandas as pd
import numpy as np

np.random.seed(42)
n = 100_000

categories = ['Electronics', 'Clothing', 'Home & Kitchen', 'Sports', 'Books']
regions = ['North', 'South', 'East', 'West']

df = pd.DataFrame({
    'order_id': range(1, n + 1),
    'customer_age': np.random.randint(18, 70, n),
    'product_category': np.random.choice(categories, n),
    'region': np.random.choice(regions, n),
    'price': np.round(np.random.uniform(5.0, 500.0, n), 2),
    'quantity': np.random.randint(1, 10, n),
    'days_to_ship': np.random.randint(1, 14, n),
})
display(df.head())

Output:

We now have a dataset of 100,000 rows to work with.

# 1. Using Vectorized Operations for Arithmetic

For any arithmetic or comparison on a column, vectorized operations should be your first instinct.

What we want to do**: calculate the total revenue per order.

df['revenue'] = df['price'] * df['quantity']
display(df[['price', 'quantity', 'revenue']].head())

Output:

**

# 2. Applying a Function for Conditional Logic

When your transformation involves some logic that can't be expressed as plain arithmetic, .apply() lets you pass a function over a column or row.

What we want to do**: assign a shipping priority label based on days to ship.

def shipping_label(days):
    if days <= 2:
        return 'Express'
    elif days <= 5:
        return 'Standard'
    else:
        return 'Economy'

df['shipping_tier'] = df['days_to_ship'].apply(shipping_label)
display(df[['days_to_ship', 'shipping_tier']].head())

Output:

Using .apply() is clean, readable, and far easier to debug than a loop. Use it when your logic is conditional and np.where() or np.select() feels too nested.

# 3. Using np.where() for Binary Conditions

**

When you have a binary condition — one outcome if true, another if false — np.where() is the clean, fast choice.

What we want to do**: flag orders where the customer qualifies for a senior discount.

df['senior_discount'] = np.where(df['customer_age'] >= 60, True, False)
display(df[['customer_age', 'senior_discount']].head())

Output:

np.where() is fully vectorized and significantly faster than .apply() for simple true or false conditions. Think of it as a vectorized ternary operator.

# 4. Selecting Across Multiple Conditions with np.select()

**

When you have more than two conditions, np.select() lets you define a list of conditions and corresponding values without any need for nested if/elif chains.

What we want to do**: assign a region-based tax rate.

conditions = [
    df['region'] == 'North',
    df['region'] == 'South',
    df['region'] == 'East',
    df['region'] == 'West',
]
tax_rates = [0.08, 0.06, 0.07, 0.09]

df['tax_rate'] = np.select(conditions, tax_rates, default=0.07)
df['tax_amount'] = df['price'] * df['tax_rate']
display(df[['region', 'price', 'tax_rate', 'tax_amount']].head())

Output:

np.select() evaluates all conditions in order and picks the first match. The default parameter handles anything that doesn't match, which is useful as a safety net.

# 5. Mapping Values with a Dictionary Lookup

**

When you need to translate values in a column — like mapping category names to numeric codes, or replacing keys with labels — .map() with a dictionary is clean and fast.

What we want to do**: map product categories to internal department codes.

category_codes = {
    'Electronics': 'ELEC',
    'Clothing': 'CLTH',
    'Home & Kitchen': 'HOME',
    'Sports': 'SPRT',
    'Books': 'BOOK',
}

df['dept_code'] = df['product_category'].map(category_codes)
display(df[['product_category', 'dept_code']].head())

Output:

.map() works like a lookup table. It's one of the most underused tools in pandas — we often reach for .apply(lambda x: dict[x]) when .map(dict) does the same thing faster.

# 6. Manipulating Strings with the .str Accessor

**

String manipulation is where people most often default to loops or .apply(). The .str accessor lets you run string operations across an entire column without either.

What we want to do**: extract the first word from the product_category column and convert it to lowercase.

df['category_slug'] = df['product_category'].str.split().str[0].str.lower()
display(df[['product_category', 'category_slug']].head())

Output:

# 7. Aggregating Groups with .groupby()

**

A common loop pattern is iterating over subsets of data to compute group-level statistics. .groupby() handles this natively.

What we want to do**: calculate total revenue and average days to ship per product category.

summary = (
    df.groupby('product_category')
    .agg(
        total_revenue=('revenue', 'sum'),
        avg_ship_days=('days_to_ship', 'mean'),
        order_count=('order_id', 'count')
    )
    .round(2)
    .reset_index()
)
summary

Output:

**

# Choosing the Right Tool

Most transformations you'd write a loop for fit cleanly into one of these patterns:

Operation / Method

Use Case / Description

Arithmetic on columns

Perform vectorized math operations like addition, subtraction, multiplication, and division directly on DataFrame columns.

Vectorized operations (*, +, etc.)

Apply element-wise operations across entire columns efficiently without explicit loops.

Simple true/false condition

Evaluate boolean conditions to filter or create conditional columns.

np.where()

Apply conditional (if-else) logic in a vectorized way for arrays and DataFrame columns.

Multiple conditions, multiple outcomes

Handle complex conditional logic with multiple rules and outputs.

np.select()

Select values based on multiple conditions and return corresponding outputs.

Value substitution via lookup

Replace values using mapping dictionaries for fast transformations.

.map(dict)

Map values in a Series using a dictionary or function for substitution.

.apply()

Apply custom functions row-wise or column-wise for flexible transformations.

String manipulation

Use vectorized string operations via the .str accessor for cleaning and transforming text data.

.groupby() + .agg()

Group data and compute aggregated statistics like sum, mean, count, etc.

Once you start thinking in columns rather than rows, you'll find the pandas API starts to feel less like a workaround and more like the actual intended way to work.

Bala Priya C** is a developer and technical writer from India. She likes working at the intersection of math, programming, data science, and content creation. Her areas of interest and expertise include DevOps, data science, and natural language processing. She enjoys reading, writing, coding, and coffee! Currently, she's working on learning and sharing her knowledge with the developer community by authoring tutorials, how-to guides, opinion pieces, and more. Bala also creates engaging resource overviews and coding tutorials.