コードでpandas apply（）をいつ使用したいですか？
Pandasメソッドapplyの使用を含むスタックオーバーフローに関する質問に投稿された多くの回答を見てきました。また、 "applyは遅いため、避ける必要があります。」.
パフォーマンスのトピックについて、applyが遅いことを説明する多くの記事を読みました。また、applyがUDFを渡すための便利な関数であるというドキュメントの免責事項も見ました（今は見つかりません）。したがって、一般的なコンセンサスは、可能であればapplyは避けるべきであるということです。ただし、これにより次の質問が生じます。
applyがひどい場合、なぜAPIにあるのですか？- いつ、どのようにコードを
apply- freeにする必要がありますか？ applyがgood（他の可能な解決策よりも優れている）になる状況はありますか？
apply、これまでにない便利な機能
まず、OPの質問に1つずつ対処します。
「 /適用が非常に悪い場合、なぜそれがAPIにあるのですか？」
_DataFrame.apply_ および _Series.apply_ は、それぞれDataFrameオブジェクトおよびSeriesオブジェクトで定義された便利な関数です。 applyは、DataFrameに変換/集約を適用するユーザー定義関数を受け入れます。 applyは、既存のpandas関数では実行できないこと）を実行する効果的な特効薬です。
applyができることのいくつか：
- DataFrameまたはシリーズでユーザー定義関数を実行する
- DataFrameに関数を行単位（_
axis=1_）または列単位（_axis=0_）で適用します - 関数を適用しながらインデックスの整列を実行する
- ユーザー定義関数を使用して集計を実行します（ただし、これらの場合は通常
aggまたはtransformを優先します） - 要素ごとの変換を実行する
- 集計結果を元の行にブロードキャストします（_
result_type_引数を参照）。 - ユーザー定義関数に渡す位置/キーワード引数を受け入れます。
...とりわけ。詳細については、ドキュメントの RowまたはColumn-wise Function Application を参照してください。
では、これらすべての機能を備えた場合、なぜapplyが悪いのでしょうかapply isslowであるためです。 Pandasは、関数の性質についての仮定を行わないため、必要に応じて、各行/列に関数を繰り返し適用します。さらに、の処理上記の状況のすべては、applyが各反復でいくつかの大きなオーバーヘッドを招くことを意味します。さらに、applyはメモリを多く消費するため、メモリ制限のあるアプリケーションにとっては課題となります。
applyを使用するのが適切な状況はほとんどありません（詳細は以下を参照）。 applyを使用する必要があるかどうかわからない場合は、使用しないでください。
次の質問に取り組みましょう。
「いつどのようにコードを作成する必要がありますか適用-free？」
言い換えると、applyへの呼び出しを get rid したい一般的な状況を以下に示します。
数値データ
数値データを使用している場合は、すでに実行しようとしていることを正確に実行するベクトル化されたcython関数がすでにある可能性があります（そうでない場合は、Stack Overflowで質問するか、GitHubで機能リクエストを開いてください）。
単純な加算演算のapplyのパフォーマンスを比較してください。
_df = pd.DataFrame({"A": [9, 4, 2, 1], "B": [12, 7, 5, 4]})
df
A B
0 9 12
1 4 7
2 2 5
3 1 4
__df.apply(np.sum)
A 16
B 28
dtype: int64
df.sum()
A 16
B 28
dtype: int64
_パフォーマンスに関しては、比較はありません。cythonizedの同等物ははるかに高速です。おもちゃのデータでもその違いは明らかなので、グラフは必要ありません。
_%timeit df.apply(np.sum)
%timeit df.sum()
2.22 ms ± 41.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
471 µs ± 8.16 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
_raw引数を使用して生の配列を渡すことができる場合でも、速度は2倍になります。
_%timeit df.apply(np.sum, raw=True)
840 µs ± 691 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
_もう一つの例：
_df.apply(lambda x: x.max() - x.min())
A 8
B 8
dtype: int64
df.max() - df.min()
A 8
B 8
dtype: int64
%timeit df.apply(lambda x: x.max() - x.min())
%timeit df.max() - df.min()
2.43 ms ± 450 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
1.23 ms ± 14.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
_一般に、可能な場合はベクトル化された代替案を探します。
文字列/正規表現
Pandasは、ほとんどの状況で「ベクトル化された」文字列関数を提供しますが、これらの関数が機能しない場合があります...いわば「適用」されます。
一般的な問題は、列の値が同じ行の別の列に存在するかどうかを確認することです。
_df = pd.DataFrame({
'Name': ['mickey', 'donald', 'minnie'],
'Title': ['wonderland', "welcome to donald's castle", 'Minnie mouse clubhouse'],
'Value': [20, 10, 86]})
df
Name Value Title
0 mickey 20 wonderland
1 donald 10 welcome to donald's castle
2 minnie 86 Minnie mouse clubhouse
_「donald」と「minnie」がそれぞれの「タイトル」列に存在するため、これは2番目と3番目の行を返すはずです。
適用を使用すると、これは
_df.apply(lambda x: x['Name'].lower() in x['Title'].lower(), axis=1)
0 False
1 True
2 True
dtype: bool
df[df.apply(lambda x: x['Name'].lower() in x['Title'].lower(), axis=1)]
Name Title Value
1 donald welcome to donald's castle 10
2 minnie Minnie mouse clubhouse 86
_ただし、リスト内包表記を使用するより良い解決策があります。
_df[[y.lower() in x.lower() for x, y in Zip(df['Title'], df['Name'])]]
Name Title Value
1 donald welcome to donald's castle 10
2 minnie Minnie mouse clubhouse 86
__%timeit df[df.apply(lambda x: x['Name'].lower() in x['Title'].lower(), axis=1)]
%timeit df[[y.lower() in x.lower() for x, y in Zip(df['Title'], df['Name'])]]
2.85 ms ± 38.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
788 µs ± 16.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
_ここで注意すべきことは、オーバーヘッドが低いため、反復ルーチンはたまたまapplyよりも高速であることです。 NaNおよび無効なdtypeを処理する必要がある場合は、カスタム関数を使用してこれを構築し、リスト内包内の引数を使用して呼び出すことができます。
リスト内包表記を適切なオプションと見なす必要がある場合の詳細については、私の記述を参照してください： pandasのループの場合-いつ気にする必要がありますか？ 。
メモ
日付および日時の操作にもベクトル化されたバージョンがあります。したがって、たとえば、pd.to_datetime(df['date'])よりもdf['date'].apply(pd.to_datetime)を優先する必要があります。詳しくは docs をご覧ください。
よくある落とし穴：リストの列の爆発
_s = pd.Series([[1, 2]] * 3)
s
0 [1, 2]
1 [1, 2]
2 [1, 2]
dtype: object
_人々はapply(pd.Series)を使いたくなります。これはパフォーマンスの点で horrible です。
_s.apply(pd.Series)
0 1
0 1 2
1 1 2
2 1 2
_より良いオプションは、列をリスト化してpd.DataFrameに渡すことです。
_pd.DataFrame(s.tolist())
0 1
0 1 2
1 1 2
2 1 2
__%timeit s.apply(pd.Series)
%timeit pd.DataFrame(s.tolist())
2.65 ms ± 294 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
816 µs ± 40.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
_最後に、
「
applyが良い状況はありますか？」
適用は便利な関数であるため、オーバーヘッドが許すほど無視できる状況があります。これは、関数が呼び出される回数に実際に依存します。
データフレームではなくシリーズ用にベクトル化された関数
複数の列に文字列操作を適用したい場合はどうなりますか？複数の列を日時に変換する場合はどうでしょうか？これらの関数はシリーズに対してのみベクトル化されているため、変換/操作する各列に applied を適用する必要があります。
_df = pd.DataFrame(
pd.date_range('2018-12-31','2019-01-31', freq='2D').date.astype(str).reshape(-1, 2),
columns=['date1', 'date2'])
df
date1 date2
0 2018-12-31 2019-01-02
1 2019-01-04 2019-01-06
2 2019-01-08 2019-01-10
3 2019-01-12 2019-01-14
4 2019-01-16 2019-01-18
5 2019-01-20 2019-01-22
6 2019-01-24 2019-01-26
7 2019-01-28 2019-01-30
df.dtypes
date1 object
date2 object
dtype: object
_これはapplyの許容ケースです：
_df.apply(pd.to_datetime, errors='coerce').dtypes
date1 datetime64[ns]
date2 datetime64[ns]
dtype: object
_stackにも意味があるか、明示的なループを使用することに注意してください。これらのオプションはすべてapplyを使用するよりもわずかに高速ですが、違いは許されるほど小さいものです。
_%timeit df.apply(pd.to_datetime, errors='coerce')
%timeit pd.to_datetime(df.stack(), errors='coerce').unstack()
%timeit pd.concat([pd.to_datetime(df[c], errors='coerce') for c in df], axis=1)
%timeit for c in df.columns: df[c] = pd.to_datetime(df[c], errors='coerce')
5.49 ms ± 247 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.94 ms ± 48.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.16 ms ± 216 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.41 ms ± 1.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
_文字列操作やカテゴリへの変換など、他の操作についても同様のケースを作成できます。
_u = df.apply(lambda x: x.str.contains(...))
v = df.apply(lambda x: x.astype(category))
_v/s
_u = pd.concat([df[c].str.contains(...) for c in df], axis=1)
v = df.copy()
for c in df:
v[c] = df[c].astype(category)
_等々...
シリーズをstrに変換：astypeとapply
これはAPIの特異性のようです。 applyを使用してSeriesの整数を文字列に変換することは、astypeを使用することと比較できます（場合によっては高速です）。
perfplot ライブラリを使用してグラフがプロットされました。
_import perfplot
perfplot.show(
setup=lambda n: pd.Series(np.random.randint(0, n, n)),
kernels=[
lambda s: s.astype(str),
lambda s: s.apply(str)
],
labels=['astype', 'apply'],
n_range=[2**k for k in range(1, 20)],
xlabel='N',
logx=True,
logy=True,
equality_check=lambda x, y: (x == y).all())
_フロートを使用すると、astypeは一貫してapplyと同じかわずかに速いことがわかります。これは、テストのデータが整数型であることと関係があります。
GroupBy演算と連鎖変換
_GroupBy.apply_についてはこれまで説明していませんが、_GroupBy.apply_は、既存のGroupBy関数では処理できないものを処理するための反復型の便利な関数でもあります。
一般的な要件の1つは、GroupByを実行してから、「遅れ累積」などの2つの主要な操作を実行することです。
_df = pd.DataFrame({"A": list('aabcccddee'), "B": [12, 7, 5, 4, 5, 4, 3, 2, 1, 10]})
df
A B
0 a 12
1 a 7
2 b 5
3 c 4
4 c 5
5 c 4
6 d 3
7 d 2
8 e 1
9 e 10
_ここでは、2つの連続したgroupby呼び出しが必要です。
_df.groupby('A').B.cumsum().groupby(df.A).shift()
0 NaN
1 12.0
2 NaN
3 NaN
4 4.0
5 9.0
6 NaN
7 3.0
8 NaN
9 1.0
Name: B, dtype: float64
_applyを使用すると、これを1回の呼び出しに短縮できます。
_df.groupby('A').B.apply(lambda x: x.cumsum().shift())
0 NaN
1 12.0
2 NaN
3 NaN
4 4.0
5 9.0
6 NaN
7 3.0
8 NaN
9 1.0
Name: B, dtype: float64
_データに依存するため、パフォーマンスを定量化することは非常に困難です。しかし、一般的に、applyは、groupbyの呼び出しを減らすことを目的とする場合、許容されるソリューションです（groupbyも非常に高価であるため）。
その他の警告
上記の警告以外に、applyは最初の行（または列）を2回操作することにも言及する価値があります。これは、関数に副作用があるかどうかを判断するために行われます。そうでない場合、applyは結果を評価するために高速パスを使用できる可能性があります。そうでない場合、低速の実装にフォールバックします。
_df = pd.DataFrame({
'A': [1, 2],
'B': ['x', 'y']
})
def func(x):
print(x['A'])
return x
df.apply(func, axis=1)
# 1
# 1
# 2
A B
0 1 x
1 2 y
_この動作は、pandasバージョン<0.25の_GroupBy.apply_でも見られます（0.25で修正されました 詳細はこちらを参照 ）。）
すべてのapplysが似ているわけではありません
以下の表は、applyを検討するタイミングを示しています1。緑はおそらく効率的であることを意味します。赤は避けます。
Someこれは直感的です：_pd.Series.apply_はPythonレベルの行単位のループで、_pd.DataFrame.apply_行単位の（_axis=1_）です。これらの誤用は多数あり、多岐にわたります。もう1つの投稿では、それらについて詳しく説明しています。一般的な解決策は、ベクトル化されたメソッド、リスト内包表記（クリーンなデータを想定）、または_pd.DataFrame_コンストラクターなどの効率的なツールを使用することです（例：apply(pd.Series)）。
_pd.DataFrame.apply_を行単位で使用している場合、_raw=True_（可能な場合）を指定すると効果的です。この段階では、通常 numba の方が適しています。
_GroupBy.apply_：一般的に好まれる
groupby操作を繰り返してapplyを回避すると、パフォーマンスが低下します。カスタム関数で使用するメソッド自体がベクトル化されている場合、_GroupBy.apply_は通常ここで問題ありません。場合によっては、適用するグループごとの集約にネイティブPandasメソッドがない場合があります。この場合、カスタム関数を含む少数のグループapplyでも、妥当なパフォーマンスが得られる場合があります。
_pd.DataFrame.apply_列ごと：混合バッグ
_pd.DataFrame.apply_列ごとの（_axis=0_）は興味深いケースです。少数の行と多数の列では、ほとんどの場合コストがかかります。列に比べて行数が多い場合、より一般的なケースとして、時々applyを使用するとパフォーマンスが大幅に向上する場合があります。
_# Python 3.7, Pandas 0.23.4
np.random.seed(0)
df = pd.DataFrame(np.random.random((10**7, 3))) # Scenario_1, many rows
df = pd.DataFrame(np.random.random((10**4, 10**3))) # Scenario_2, many columns
# Scenario_1 | Scenario_2
%timeit df.sum() # 800 ms | 109 ms
%timeit df.apply(pd.Series.sum) # 568 ms | 325 ms
%timeit df.max() - df.min() # 1.63 s | 314 ms
%timeit df.apply(lambda x: x.max() - x.min()) # 838 ms | 473 ms
%timeit df.mean() # 108 ms | 94.4 ms
%timeit df.apply(pd.Series.mean) # 276 ms | 233 ms
_1 例外はありますが、これらは通常、わずかであるか一般的ではありません。いくつかの例：
df['col'].apply(str)はdf['col'].astype(str)をわずかに上回る場合があります。- 文字列での
df.apply(pd.to_datetime)の処理は、通常のforループと比較して、行で適切にスケーリングされません。
ために axis=1（つまり、行単位の関数）の場合、applyの代わりに次の関数を使用できます。なぜこれがpandasの動作ではないのでしょうか。 （複合インデックスではテストされていませんが、applyよりもはるかに高速に見えます）
def faster_df_apply(df, func):
cols = list(df.columns)
data, index = [], []
for row in df.itertuples(index=True):
row_dict = {f:v for f,v in Zip(cols, row[1:])}
data.append(func(row_dict))
index.append(row[0])
return pd.Series(data, index=index)
applyが良い状況はありますか？はい、時々。
タスク：Unicode文字列をデコードします。
import numpy as np
import pandas as pd
import unidecode
s = pd.Series(['mañana','Ceñía'])
s.head()
0 mañana
1 Ceñía
s.apply(unidecode.unidecode)
0 manana
1 Cenia
更新applyは上記の状況に対処できないため、NumPyの使用を推奨することは決してせず、pandas apply。しかし、@ jppによるリマインダーのおかげで、わかりやすいolリストの理解を忘れていました。