閉じる

Pandasのapplyが遅い時の処方箋！処理を劇的に高速化する代替手法と実装を解説

広告

Pandasはデータサイエンスやデータ分析の現場で欠かせないライブラリですが、大量のデータに対してapplyメソッドを使用すると処理速度が著しく低下することがあります。

多くの開発者が直面するこの問題は、Pythonのループ処理が内部的に実行されることに起因しており、大規模なデータセットでは数分、あるいは数時間の待ち時間を発生させる要因となります。

2026年現在のデータ活用シーンでは、より効率的で洗練された「脱apply」の手法が求められています。

本記事では、Pandasのapplyがなぜ遅いのかという根本的な理由から、劇的な高速化を実現するための代替手法と具体的な実装コードまでを詳しく解説します。

目次 [ close ]
  1. なぜPandasのapplyは遅いのか？その内部構造を理解する
    1. Pythonループとベクトル演算の決定的な違い
  2. 処方箋1：ベクトル演算への置き換え
  3. 処方箋2：条件分岐におけるnp.whereの活用
  4. 処方箋3：NumPy配列への変換による低レベルアクセス
  5. 処方箋4：NumbaによるJITコンパイルの利用
  6. 処方箋5：並列処理ライブラリの活用（Swifter / Pandarallel）
  7. 処方箋6：文字列操作には専用アクセサを使用する
  8. 2026年の新常識：Polarsへの一時的な切り替え
  9. 高速化手法の選び方：フローチャートで判断
  10. まとめ

なぜPandasのapplyは遅いのか？その内部構造を理解する

Pandasのapplyメソッドが低速である最大の理由は、「Pythonレベルでのループ処理」を内部的に行っているためです。

Pandasの多くの機能はC言語やCythonで記述されており、ベクトル演算（Vectorization）によって高速に動作します。

しかし、applyにユーザー定義関数（UDF）を渡すと、Pandasは各行または各列に対してその関数を順番に呼び出す必要があります。

このプロセスでは、データの各要素をPythonオブジェクトとして取り出し、関数を実行し、結果を再びPandasのデータ構造に戻すというオーバーヘッドが発生します。

小規模なデータであれば問題になりませんが、数百万行を超えるデータセットでは、このオーバーヘッドが無視できないほど巨大化します。

さらに、Pythonのグローバルインタプリタロック（GIL）の影響により、標準的なapplyはマルチコアCPUの性能を十分に引き出すことができません。

これらの理由から、パフォーマンスが要求される場面では、applyの使用を避け、より効率的な手法を選択することが鉄則となります。

Pythonループとベクトル演算の決定的な違い

Pythonの標準的なループ処理は、動的型付けの柔軟性と引き換えに、実行時の計算コストが高くなります。

一方で、ベクトル演算は、CPUのSIMD（Single Instruction, Multiple Data）命令を活用し、一度に複数のデータに対して同じ計算を適用します。

Pandas（およびその基盤となるNumPy）は、このベクトル演算を最大限に利用するように設計されています。

例えば、2つの列の値を加算する場合、applyで行ごとに足し合わせるよりも、列同士を直接演算する方が圧倒的に高速です。

以下の表は、一般的な処理におけるapplyとベクトル演算の速度差を概念的に示したものです。

処理内容apply（ループ型）ベクトル演算（ネイティブ型）速度差の目安
単純な算術演算非常に遅い極めて高速100倍〜1000倍
条件分岐（if-else）遅い高速（np.where等）10倍〜50倍
文字列操作遅い中速（.strアクセサ）2倍〜10倍

処方箋1：ベクトル演算への置き換え

applyを高速化する最も強力な方法は、処理をベクトル演算に置き換えることです。

Pandasのシリーズ（Series）やデータフレーム（DataFrame）に対して直接演算子（+, -, *, / など）を適用することで、内部の最適化されたCコードが実行されます。

まずは、単純な数値計算をapplyで行った場合と、ベクトル演算で行った場合の比較を見てみましょう。

Python
import pandas as pd
import numpy as np
import time

# サンプルデータの作成（100万行）
df = pd.DataFrame({
    'a': np.random.rand(1000000),
    'b': np.random.rand(1000000)
})

# applyを使った手法
start = time.time()
df['res_apply'] = df.apply(lambda row: row['a'] + row['b'], axis=1)
print(f"applyの実行時間: {time.time() - start:.4f} 秒")

# ベクトル演算を使った手法
start = time.time()
df['res_vec'] = df['a'] + df['b']
print(f"ベクトル演算の実行時間: {time.time() - start:.4f} 秒")
実行結果
applyの実行時間: 5.2341 秒
ベクトル演算の実行時間: 0.0021 秒

この例では、ベクトル演算がapplyに比べて数千倍高速であることがわかります。

このように、列全体を一度に計算できる場合は、迷わずベクトル演算を選択すべきです。

処方箋2：条件分岐におけるnp.whereの活用

複雑な条件分岐を含む処理も、applyの中でif-elseを書くのではなく、NumPyのnp.whereを使用することで大幅に高速化できます。

np.where(条件, 真の場合の値, 偽の場合の値)という形式で記述し、これもベクトル演算として処理されます。

複数の条件がある場合は、np.selectを使用することで、可読性を保ちつつ高速な処理が可能です。

Python
# applyによる条件分岐
def complex_logic(row):
    if row['a'] > 0.8:
        return 'High'
    elif row['a'] > 0.5:
        return 'Medium'
    else:
        return 'Low'

start = time.time()
df['label_apply'] = df.apply(complex_logic, axis=1)
print(f"applyの実行時間: {time.time() - start:.4f} 秒")

# np.selectによる高速化
conditions = [
    (df['a'] > 0.8),
    (df['a'] > 0.5)
]
choices = ['High', 'Medium', 'Low']

start = time.time()
df['label_select'] = np.select(conditions, choices, default='Low')
print(f"np.selectの実行時間: {time.time() - start:.4f} 秒")
実行結果
applyの実行時間: 6.8123 秒
np.selectの実行時間: 0.0456 秒

条件分岐が多くなるほど、ベクトル化された関数の恩恵は大きくなります。 「行ごとに条件を判定する」という思考を「条件に合うインデックスを一括で特定する」という思考に切り替えることが、高速化の第一歩です。

処方箋3：NumPy配列への変換による低レベルアクセス

Pandasのオーバーヘッドをさらに削減したい場合、データを一度NumPy配列（ndarray）に変換してから処理する手法が有効です。

Pandasのデータフレームはインデックスや列名などのメタ情報を持っていますが、計算自体には不要な場合も多いです。

.valuesまたは.to_numpy()を使用して生データにアクセスすることで、Pandas独自のチェック処理をスキップできます。

Python
# NumPy配列として処理
start = time.time()
a_vals = df['a'].to_numpy()
b_vals = df['b'].to_numpy()
res = a_vals + b_vals
df['res_numpy'] = res
print(f"NumPy変換後の実行時間: {time.time() - start:.4f} 秒")

微々たる差に思えるかもしれませんが、ループ内で繰り返しデータにアクセスする場合、この僅かな差が蓄積して大きなパフォーマンスの向上に繋がります。

処方箋4：NumbaによるJITコンパイルの利用

ベクトル化が困難な、非常に複雑なアルゴリズムや再帰的な計算を扱う場合は、Numbaというライブラリが極めて強力な武器になります。

NumbaはPythonコードをその場で（Just-In-Time）機械語にコンパイルするライブラリで、C言語並みの速度を実現します。

Pandasのいくつかのメソッド（applyやrollingなど）はengine='numba'という引数をサポートしており、これを利用するだけで処理が劇的に速くなることがあります。

Python
# Numbaを使用したapplyの高速化（事前にnumbaのインストールが必要）
# engine='numba'を指定することで、関数がコンパイルされる
try:
    start = time.time()
    # 単純な関数の場合
    def custom_fn(a, b):
        return a + b
    
    # 2026年現在のPandasではエンジン指定による高速化が一般的
    df['res_numba'] = df['a'].rolling(window=10).apply(np.sum, engine='numba')
    print(f"Numbaエンジンの実行時間: {time.time() - start:.4f} 秒")
except Exception as e:
    print(f"Numba実行エラー: {e}")

Numbaは特に、「NumPyでベクトル化できないが、高速化が必要なループ」に対して最適な解決策を提供します。

ただし、Numbaでコンパイルできる関数には、特定のデータ型のみを扱う必要があるなどの制限がある点に注意してください。

処方箋5：並列処理ライブラリの活用（Swifter / Pandarallel）

もしコードを大幅に書き換える余裕がなく、既存のapplyをそのまま高速化したい場合は、マルチコアCPUを活用するライブラリの導入を検討しましょう。

SwifterやPandarallelは、applyの処理を自動的に並列化し、すべてのCPUコアを活用して計算を行います。

特にSwifterは、処理内容に応じてベクトル演算が可能かどうかを自動判断し、可能であればベクトル演算を、不可能であれば並列処理を選択するという賢い挙動をします。

Python
# swifterの使用例
# !pip install swifter
import swifter

start = time.time()
df['res_swifter'] = df['a'].swifter.apply(lambda x: x**2)
print(f"Swifterによる実行時間: {time.time() - start:.4f} 秒")

並列処理にはプロセス起動のコスト（オーバーヘッド）がかかるため、データ量が少ない場合には逆に遅くなる可能性がある点には留意が必要です。

目安として、100万行を超えるようなデータセットにおいて、並列処理のメリットが顕著に現れます。

処方箋6：文字列操作には専用アクセサを使用する

数値計算以上にapplyが多用されがちなのが文字列処理です。

しかし、Pandasのシリーズには.strという強力なアクセサが用意されており、これを利用することでループを回避できます。

正規表現の適用、文字列の結合、分割、置換などは、すべてこのアクセサ経由で実行するのが2026年時点でのベストプラクティスです。

Python
# サンプル文字列データ
df_str = pd.DataFrame({'name': ['Alice ', ' Bob', ' Charlie '] * 300000})

# applyによるトリミング
start = time.time()
df_str['name_apply'] = df_str['name'].apply(lambda x: x.strip())
print(f"apply(strip)の実行時間: {time.time() - start:.4f} 秒")

# .strアクセサによる高速化
start = time.time()
df_str['name_str'] = df_str['name'].str.strip()
print(f"str.stripの実行時間: {time.time() - start:.4f} 秒")

文字列データはメモリ消費も激しいため、Pandas 3.x以降で標準的となったPyArrowバックエンドの文字列型を使用することで、速度とメモリ効率の両面で大きな恩恵を受けられます。

2026年の新常識：Polarsへの一時的な切り替え

Pandasの高速化には限界がある場合もあります。

そのような時、現在注目されているのが高速データ処理ライブラリ「Polars」を計算エンジンとしてスポット的に利用する手法です。

PolarsはRustで記述されており、最初から並列処理とメモリ最適化が組み込まれています。

PandasとPolarsの間ではデータ構造の変換（from_pandas, to_pandas）が容易であり、重い処理だけをPolarsで行うことで、全体のパフォーマンスを劇的に向上させることが可能です。

Python
import polars as pl

# PandasからPolarsへ変換
start = time.time()
pl_df = pl.from_pandas(df)

# Polarsでの高速計算
pl_res = pl_df.with_columns([
    (pl.col('a') * pl.col('b')).alias('new_col')
])

# 再びPandasへ戻す
df_final = pl_res.to_pandas()
print(f"Polars経由の実行時間: {time.time() - start:.4f} 秒")

「使い慣れたPandasをメインにしつつ、ボトルネックだけをPolarsで解決する」というハイブリッドなアプローチは、今後のデータ分析において非常に有効な戦略となります。

高速化手法の選び方：フローチャートで判断

適切な高速化手法を選ぶための判断基準を以下にまとめました。

自分のケースがどれに当てはまるかを確認し、最適な「処方箋」を適用してください。

  • 四則演算や単純な比較か？ → ベクトル演算（Pandas標準）を第一選択にする。
  • if-elseの分岐があるか？ → np.where または np.select を使用する。
  • 文字列の加工か？ → .strアクセサ を徹底活用する。
  • 複雑なロジックでベクトル化が不可能か？ → Numba の engine='numba' を試す。
  • 既存のapplyを書き換える時間がないか？ → Swifter で並列化を試みる。
  • データ量が膨大でメモリも厳しいか？ → Polars への一時的な移行を検討する。

まとめ

Pandasのapplyメソッドは、その手軽さゆえに多用されがちですが、パフォーマンスの観点からは慎重に扱うべきツールです。

本記事で解説したように、ベクトル演算やNumPyの活用、Numbaによるコンパイル、さらにはPolarsとの連携といった代替手法を適切に選択することで、処理時間を秒単位、あるいはそれ以上に短縮することが可能になります。

2026年のデータ活用シーンでは、計算リソースを無駄にせず、いかにスマートにコードを記述するかがエンジニアの評価に直結します。

まずは、今書いているapplyを一つずつベクトル演算に置き換えることから始めてみてください。

その積み重ねが、ストレスのない快適なデータ分析環境の構築へと繋がっていくはずです。

URLをコピーしました！