如果你曾經使用過Pandas處理表格數據，你可能會熟悉導入數據、清洗和轉換的過程，然后將其用作模型的輸入。然而，當你需要擴展和將代碼投入生產時，你的Pandas管道很可能開始崩潰并運行緩慢。在這篇文章中，筆者將分享2個技巧，幫助你讓Pandas代碼快得離譜，提升數據處理效率并避免常見的陷阱。
技巧1：矢量化操作
在Pandas中，矢量化操作是一種強大的工具，它可以用一種更簡潔和高效的方式處理整個數據框的列，而不是逐行循環。
它是如何工作的？
廣播是矢量化操作的一個關鍵要素，它允許您直觀地操作具有不同形狀的對象。
eg1: 具有3個元素的數組a與標量b相乘，得到與Source形狀相同的數組。
eg2: 在進行加法運算時，將形狀為(4,1)的數組a與形狀為(3,)的數組b相加，結果會得到一個形狀為(4,3)的數組。
關于這一點已經有很多文章，并且在深度學習中，大規模的矩陣乘法是非常常見的。在本文中，我們將利用兩個簡短的例子上進行討論。
首先，假設您想要計算給定整數在列中出現的次數。以下是 2 種可能的方法。
"""
計算DataFrame X 中 "column_1" 列中等于目標值 target 的元素個數。
參數：
X: DataFrame，包含要計算的列 "column_1"。
target: int，目標值。
返回值：
int，等于目標值 target 的元素個數。
"""
# 使用循環計數
def count_loop(X, target: int) -> int:
return sum(x == target for x in X["column_1"])
# 使用矢量化操作計數
def count_vectorized(X, target: int) -> int:
return (X["column_1"] == target).sum()
現在假設有一個DataFrame帶有日期列并希望將其偏移給定的天數。使用矢量化操作計算如下：
def offset_loop(X, days: int) -> pd.DataFrame:
d = pd.Timedelta(days=days)
X["column_const"] = [x + d for x in X["column_10"]]
return X
def offset_vectorized(X, days: int) -> pd.DataFrame:
X["column_const"] = X["column_10"] + pd.Timedelta(days=days)
return X
技巧2：迭代
「for循環」
第一個也是最直觀的迭代方法是使用Python/ target=_blank class=infotextkey>Python for循環。
def loop(df: pd.DataFrame, remove_col: str, words_to_remove_col: str) -> list[str]:
res = []
i_remove_col = df.columns.get_loc(remove_col)
i_words_to_remove_col = df.columns.get_loc(words_to_remove_col)
for i_row in range(df.shape[0]):
res.Append(
remove_words(
df.iat[i_row, i_remove_col], df.iat[i_row, i_words_to_remove_col]
)
)
return result
「apply」
def apply(df: pd.DataFrame, remove_col: str, words_to_remove_col: str) -> list[str]:
return df.apply(
func=lambda x: remove_words(x[remove_col], x[words_to_remove_col]), axis=1
).tolist()
在 df.apply 的每次迭代中，提供的可調用函數獲取一個 Series，其索引為 df.columns，其值是行的。這意味著 pandas 必須在每個循環中生成該序列，這是昂貴的。為了降低成本，最好對您知道將使用的 df 子集調用 apply，如下所示：
def apply_only_used_cols(df: pd.DataFrame, remove_col: str, words_to_remove_col: str) -> list[str]:
return df[[remove_col, words_to_remove_col]].apply(
func=lambda x: remove_words(x[remove_col], x[words_to_remove_col]), axis=1
)
「列表組合+itertuples」
使用itertuples與列表相結合進行迭代肯定會更好。itertuples生成帶有行數據的（命名）元組。
def itertuples_only_used_cols(df: pd.DataFrame, remove_col: str, words_to_remove_col: str) -> list[str]:
return [
remove_words(x[0], x[1])
for x in df[[remove_col, words_to_remove_col]].itertuples(
index=False, name=None
)
]
「列表組合+zip」
zip接受可迭代對象并生成元組，其中第i個元組按順序包含所有給定可迭代對象的第i個元素。
def zip_only_used_cols(df: pd.DataFrame, remove_col: str, words_to_remove_col: str) -> list[str]:
return [remove_words(x, y) for x, y in zip(df[remove_col], df[words_to_remove_col])]
「列表組合+to_dict」
def to_dict_only_used_columns(df: pd.DataFrame) -> list[str]:
return [
remove_words(row[remove_col], row[words_to_remove_col])
for row in df[[remove_col, words_to_remove_col]].to_dict(orient="records")
]
「緩存」
除了我們討論的迭代技術之外，另外兩種方法可以幫助提高代碼的性能：緩存和并行化。如果使用相同的參數多次調用 pandas 函數，緩存會特別有用。例如，如果remove_words應用于具有許多重復值的數據集，您可以使用它functools.lru_cache來存儲函數的結果并避免每次都重新計算它們。要使用lru_cache，只需將@lru_cache裝飾器添加到 的聲明中remove_words，然后使用您首選的迭代方法將該函數應用于您的數據集。這可以顯著提高代碼的速度和效率。以下面的代碼為例：
@lru_cache
def remove_words(...):
... # Same implementation as before
def zip_only_used_cols_cached(df: pd.DataFrame, remove_col: str, words_to_remove_col: str) -> list[str]:
return [remove_words(x, y) for x, y in zip(df[remove_col], df[words_to_remove_col])]
添加此裝飾器會生成一個函數，該函數會“記住”之前遇到的輸入的輸出，從而無需再次運行所有代碼。
「并行化」
最后一張王牌是使用 pandarallel 跨多個獨立的 df 塊并行化我們的函數調用。該工具易于使用：您只需導入并初始化它，然后將所有 .applys 更改為 .parallel_applys。
from pandarallel import pandarallel
pandarallel.initialize(nb_workers=min(os.cpu_count(), 12))
def parapply_only_used_cols(df: pd.DataFrame, remove_col: str, words_to_remove_col: str) -> list[str]:
return df[[remove_col, words_to_remove_col]].parallel_apply(
lambda x: remove_words(x[remove_col], x[words_to_remove_col]), axis=1
)
