摘要：它還使用執(zhí)行所謂的鏈?zhǔn)剿饕?，這通常會導(dǎo)致意外的結(jié)果。但這種方法的最大問題是計算的時間成本。這些都是一次產(chǎn)生一行的生成器方法，類似中使用的用法。在這種情況下，所花費的時間大約是方法的一半。根據(jù)每小時所屬的應(yīng)用一組標(biāo)簽。

作者：xiaoyu

微信公眾號：Python數(shù)據(jù)科學(xué)

知乎：python數(shù)據(jù)分析師

當(dāng)大家談到數(shù)據(jù)分析時，提及最多的語言就是Python和SQL。Python之所以適合數(shù)據(jù)分析，是因為它有很多第三方強大的庫來協(xié)助，pandas就是其中之一。pandas的文檔中是這樣描述的：

“快速，靈活，富有表現(xiàn)力的數(shù)據(jù)結(jié)構(gòu)，旨在使”關(guān)系“或”標(biāo)記“數(shù)據(jù)的使用既簡單又直觀?！?/pre>
我們知道pandas的兩個主要數(shù)據(jù)結(jié)構(gòu)：dataframe和series，我們對數(shù)據(jù)的一些操作都是基于這兩個數(shù)據(jù)結(jié)構(gòu)的。但在實際的使用中，我們可能很多時候會感覺運行一些數(shù)據(jù)結(jié)構(gòu)的操作會異常的慢。一個操作慢幾秒可能看不出來什么，但是一整個項目中很多個操作加起來會讓整個開發(fā)工作效率變得很低。有的朋友抱怨pandas簡直太慢了，其實對于pandas的一些操作也是有一定技巧的。
pandas是基于numpy庫的數(shù)組結(jié)構(gòu)上構(gòu)建的，并且它的很多操作都是（通過numpy或者pandas自身由Cpython實現(xiàn)并編譯成C的擴展模塊）在C語言中實現(xiàn)的。因此，如果正確使用pandas的話，它的運行速度應(yīng)該是非?？斓摹?/p>
本篇將要介紹幾種pandas中常用到的方法，對于這些方法使用存在哪些需要注意的問題，以及如何對它們進行速度提升。

將datetime數(shù)據(jù)與時間序列一起使用的優(yōu)點
進行批量計算的最有效途徑
通過HDFStore存儲數(shù)據(jù)節(jié)省時間

使用Datetime數(shù)據(jù)節(jié)省時間
我們來看一個例子。
>>> import pandas as pd
>>> pd.__version__
"0.23.1"

# 導(dǎo)入數(shù)據(jù)集
>>> df = pd.read_csv("demand_profile.csv")
>>> df.head()
     date_time  energy_kwh
0  1/1/13 0:00       0.586
1  1/1/13 1:00       0.580
2  1/1/13 2:00       0.572
3  1/1/13 3:00       0.596
4  1/1/13 4:00       0.592
從運行上面代碼得到的結(jié)果來看，好像沒有什么問題。但實際上pandas和numpy都有一個dtypes 的概念。如果沒有特殊聲明，那么date_time將會使用一個 object 的dtype類型，如下面代碼所示：
>>> df.dtypes
date_time      object
energy_kwh    float64
dtype: object

>>> type(df.iat[0, 0])
str
object 類型像一個大的容器，不僅僅可以承載 str，也可以包含那些不能很好地融進一個數(shù)據(jù)類型的任何特征列。而如果我們將日期作為 str 類型就會極大的影響效率。
因此，對于時間序列的數(shù)據(jù)而言，我們需要讓上面的date_time列格式化為datetime對象數(shù)組（pandas稱之為時間戳）。pandas在這里操作非常簡單，操作如下：
>>> df["date_time"] = pd.to_datetime(df["date_time"])
>>> df["date_time"].dtype
datetime64[ns]
我們來運行一下這個df看看轉(zhuǎn)化后的效果是什么樣的。
>>> df.head()
               date_time    energy_kwh
0    2013-01-01 00:00:00         0.586
1    2013-01-01 01:00:00         0.580
2    2013-01-01 02:00:00         0.572
3    2013-01-01 03:00:00         0.596
4    2013-01-01 04:00:00         0.592
date_time的格式已經(jīng)自動轉(zhuǎn)化了，但這還沒完，在這個基礎(chǔ)上，我們還是可以繼續(xù)提高運行速度的。如何提速呢？為了更好的對比，我們首先通過 timeit 裝飾器來測試一下上面代碼的轉(zhuǎn)化時間。
>>> @timeit(repeat=3, number=10)
... def convert(df, column_name):
...     return pd.to_datetime(df[column_name])

>>> df["date_time"] = convert(df, "date_time")
Best of 3 trials with 10 function calls per trial:
Function `convert` ran in average of 1.610 seconds.
1.61s，看上去挺快，但其實可以更快，我們來看一下下面的方法。
>>> @timeit(repeat=3, number=100)
>>> def convert_with_format(df, column_name):
...     return pd.to_datetime(df[column_name],
...                           format="%d/%m/%y %H:%M")
Best of 3 trials with 100 function calls per trial:
Function `convert_with_format` ran in average of 0.032 seconds.
結(jié)果只有0.032s，快了將近50倍。原因是：我們設(shè)置了轉(zhuǎn)化的格式format。由于在CSV中的datetimes并不是 ISO 8601 格式的，如果不進行設(shè)置的話，那么pandas將使用 dateutil 包把每個字符串str轉(zhuǎn)化成date日期。
相反，如果原始數(shù)據(jù)datetime已經(jīng)是 ISO 8601 格式了，那么pandas就可以立即使用最快速的方法來解析日期。這也就是為什么提前設(shè)置好格式format可以提升這么多。
pandas數(shù)據(jù)的循環(huán)操作
仍然基于上面的數(shù)據(jù)，我們想添加一個新的特征，但這個新的特征是基于一些時間條件的，根據(jù)時長（小時）而變化，如下：

因此，按照我們正常的做法就是使用apply方法寫一個函數(shù)，函數(shù)里面寫好時間條件的邏輯代碼。
def apply_tariff(kwh, hour):
 """計算每個小時的電費"""  
    if 0 <= hour < 7:
        rate = 12
    elif 7 <= hour < 17:
        rate = 20
    elif 17 <= hour < 24:
        rate = 28
    else:
        raise ValueError(f"Invalid hour: {hour}")
    return rate * kwh
然后使用for循環(huán)來遍歷df，根據(jù)apply函數(shù)邏輯添加新的特征，如下：
>>> # 不贊同這種操作
>>> @timeit(repeat=3, number=100)
... def apply_tariff_loop(df):
...     """Calculate costs in loop.  Modifies `df` inplace."""
...     energy_cost_list = []
...     for i in range(len(df)):
...         # 獲取用電量和時間（小時）
...         energy_used = df.iloc[i]["energy_kwh"]
...         hour = df.iloc[i]["date_time"].hour
...         energy_cost = apply_tariff(energy_used, hour)
...         energy_cost_list.append(energy_cost)
...     df["cost_cents"] = energy_cost_list
... 
>>> apply_tariff_loop(df)
Best of 3 trials with 100 function calls per trial:
Function `apply_tariff_loop` ran in average of 3.152 seconds.
對于那些寫Pythonic風(fēng)格的人來說，這個設(shè)計看起來很自然。然而，這個循環(huán)將會嚴(yán)重影響效率，也是不贊同這么做。原因有幾個：

首先，它需要初始化一個將記錄輸出的列表。
其次，它使用不透明對象范圍(0，len(df))循環(huán)，然后在應(yīng)用apply_tariff()之后，它必須將結(jié)果附加到用于創(chuàng)建新DataFrame列的列表中。它還使用df.iloc [i] ["date_time"]執(zhí)行所謂的鏈?zhǔn)剿饕?，這通常會導(dǎo)致意外的結(jié)果。
但這種方法的最大問題是計算的時間成本。對于8760行數(shù)據(jù)，此循環(huán)花費了3秒鐘。接下來，你將看到一些改進的Pandas結(jié)構(gòu)迭代解決方案。

使用itertuples() 和iterrows() 循環(huán)
那么推薦做法是什么樣的呢？
實際上可以通過pandas引入itertuples和iterrows方法可以使效率更快。這些都是一次產(chǎn)生一行的生成器方法，類似scrapy中使用的yield用法。
.itertuples為每一行產(chǎn)生一個namedtuple，并且行的索引值作為元組的第一個元素。nametuple是Python的collections模塊中的一種數(shù)據(jù)結(jié)構(gòu)，其行為類似于Python元組，但具有可通過屬性查找訪問的字段。
.iterrows為DataFrame中的每一行產(chǎn)生（index，series）這樣的元組。
雖然.itertuples往往會更快一些，但是在這個例子中使用.iterrows，我們看看這使用iterrows后效果如何。
>>> @timeit(repeat=3, number=100)
... def apply_tariff_iterrows(df):
...     energy_cost_list = []
...     for index, row in df.iterrows():
...         # 獲取用電量和時間（小時）
...         energy_used = row["energy_kwh"]
...         hour = row["date_time"].hour
...         # 添加cost列表
...         energy_cost = apply_tariff(energy_used, hour)
...         energy_cost_list.append(energy_cost)
...     df["cost_cents"] = energy_cost_list
...
>>> apply_tariff_iterrows(df)
Best of 3 trials with 100 function calls per trial:
Function `apply_tariff_iterrows` ran in average of 0.713 seconds.
語法方面：這樣的語法更明確，并且行值引用中的混亂更少，因此它更具可讀性。
在時間收益方面：快了近5倍！ 但是，還有更多的改進空間。我們?nèi)匀辉谑褂媚撤N形式的Python for循環(huán)，這意味著每個函數(shù)調(diào)用都是在Python中完成的，理想情況是它可以用Pandas內(nèi)部架構(gòu)中內(nèi)置的更快的語言完成。
Pandas的 .apply()方法
我們可以使用.apply方法而不是.iterrows進一步改進此操作。Pandas的.apply方法接受函數(shù)(callables)并沿DataFrame的軸(所有行或所有列)應(yīng)用它們。在此示例中，lambda函數(shù)將幫助你將兩列數(shù)據(jù)傳遞給apply_tariff()：
>>> @timeit(repeat=3, number=100)
... def apply_tariff_withapply(df):
...     df["cost_cents"] = df.apply(
...         lambda row: apply_tariff(
...             kwh=row["energy_kwh"],
...             hour=row["date_time"].hour),
...         axis=1)
...
>>> apply_tariff_withapply(df)
Best of 3 trials with 100 function calls per trial:
Function `apply_tariff_withapply` ran in average of 0.272 seconds.
.apply的語法優(yōu)點很明顯，行數(shù)少，代碼可讀性高。在這種情況下，所花費的時間大約是.iterrows方法的一半。
但是，這還不是“非?？臁?。一個原因是.apply()將在內(nèi)部嘗試循環(huán)遍歷Cython迭代器。但是在這種情況下，傳遞的lambda不是可以在Cython中處理的東西，因此它在Python中調(diào)用，因此并不是那么快。
如果你使用.apply()獲取10年的小時數(shù)據(jù)，那么你將需要大約15分鐘的處理時間。如果這個計算只是大型模型的一小部分，那么你真的應(yīng)該加快速度。這也就是矢量化操作派上用場的地方。
矢量化操作：使用.isin()選擇數(shù)據(jù)
什么是矢量化操作？如果你不基于一些條件，而是可以在一行代碼中將所有電力消耗數(shù)據(jù)應(yīng)用于該價格(df ["energy_kwh"] * 28)，類似這種。這個特定的操作就是矢量化操作的一個例子，它是在Pandas中執(zhí)行的最快方法。
但是如何將條件計算應(yīng)用為Pandas中的矢量化運算？一個技巧是根據(jù)你的條件選擇和分組DataFrame，然后對每個選定的組應(yīng)用矢量化操作。 在下一個示例中，你將看到如何使用Pandas的.isin()方法選擇行，然后在向量化操作中實現(xiàn)上面新特征的添加。在執(zhí)行此操作之前，如果將date_time列設(shè)置為DataFrame的索引，則會使事情更方便：
df.set_index("date_time", inplace=True)

@timeit(repeat=3, number=100)
def apply_tariff_isin(df):
# 定義小時范圍Boolean數(shù)組
    peak_hours = df.index.hour.isin(range(17, 24))
    shoulder_hours = df.index.hour.isin(range(7, 17))
    off_peak_hours = df.index.hour.isin(range(0, 7))

    # 使用上面的定義
    df.loc[peak_hours, "cost_cents"] = df.loc[peak_hours, "energy_kwh"] * 28
    df.loc[shoulder_hours,"cost_cents"] = df.loc[shoulder_hours, "energy_kwh"] * 20
    df.loc[off_peak_hours,"cost_cents"] = df.loc[off_peak_hours, "energy_kwh"] * 12
我們來看一下結(jié)果如何。
>>> apply_tariff_isin(df)
Best of 3 trials with 100 function calls per trial:
Function `apply_tariff_isin` ran in average of 0.010 seconds.
為了了解剛才代碼中發(fā)生的情況，我們需要知道.isin()方法返回的是一個布爾值數(shù)組，如下所示：
[False, False, False, ..., True, True, True]
這些值標(biāo)識哪些DataFrame索引(datetimes)落在指定的小時范圍內(nèi)。然后，當(dāng)你將這些布爾數(shù)組傳遞給DataFrame的.loc索引器時，你將獲得一個僅包含與這些小時匹配的行的DataFrame切片。在那之后，僅僅是將切片乘以適當(dāng)?shù)馁M率，這是一種快速的矢量化操作。
這與我們上面的循環(huán)操作相比如何？首先，你可能會注意到不再需要apply_tariff()，因為所有條件邏輯都應(yīng)用于行的選擇。因此，你必須編寫的代碼行和調(diào)用的Python代碼會大大減少。
處理時間怎么樣？比不是Pythonic的循環(huán)快315倍，比.iterrows快71倍，比.apply快27倍。
還可以做的更好嗎？
在apply_tariff_isin中，我們?nèi)匀豢梢酝ㄟ^調(diào)用df.loc和df.index.hour.isin三次來進行一些“手動工作”。如果我們有更精細(xì)的時隙范圍，你可能會爭辯說這個解決方案是不可擴展的。幸運的是，在這種情況下，你可以使用Pandas的pd.cut() 函數(shù)以編程方式執(zhí)行更多操作：
@timeit(repeat=3, number=100)
def apply_tariff_cut(df):
    cents_per_kwh = pd.cut(x=df.index.hour,
                           bins=[0, 7, 17, 24],
                           include_lowest=True,
                           labels=[12, 20, 28]).astype(int)
    df["cost_cents"] = cents_per_kwh * df["energy_kwh"]
讓我們看看這里發(fā)生了什么。pd.cut() 根據(jù)每小時所屬的bin應(yīng)用一組標(biāo)簽(costs)。
注意include_lowest參數(shù)表示第一個間隔是否應(yīng)該是包含左邊的(您希望在組中包含時間= 0)。
這是一種完全矢量化的方式來獲得我們的預(yù)期結(jié)果，它在時間方面是最快的：
>>> apply_tariff_cut(df)
Best of 3 trials with 100 function calls per trial:
Function `apply_tariff_cut` ran in average of 0.003 seconds. 
到目前為止，時間上基本快達到極限了，只需要花費不到一秒的時間來處理完整的10年的小時數(shù)據(jù)集。但是，最后一個選項是使用 NumPy 函數(shù)來操作每個DataFrame的底層NumPy數(shù)組，然后將結(jié)果集成回Pandas數(shù)據(jù)結(jié)構(gòu)中。
使用Numpy繼續(xù)加速
使用Pandas時不應(yīng)忘記的一點是Pandas Series和DataFrames是在NumPy庫之上設(shè)計的。這為你提供了更多的計算靈活性，因為Pandas可以與NumPy陣列和操作無縫銜接。
下面，我們將使用NumPy的 digitize() 函數(shù)。它類似于Pandas的cut()，因為數(shù)據(jù)將被分箱，但這次它將由一個索引數(shù)組表示，這些索引表示每小時所屬的bin。然后將這些索引應(yīng)用于價格數(shù)組：
@timeit(repeat=3, number=100)
def apply_tariff_digitize(df):
    prices = np.array([12, 20, 28])
    bins = np.digitize(df.index.hour.values, bins=[7, 17, 24])
    df["cost_cents"] = prices[bins] * df["energy_kwh"].values
與cut函數(shù)一樣，這種語法非常簡潔易讀。但它在速度方面有何比較？讓我們來看看：
>>> apply_tariff_digitize(df)
Best of 3 trials with 100 function calls per trial:
Function `apply_tariff_digitize` ran in average of 0.002 seconds.
在這一點上，仍然有性能提升，但它本質(zhì)上變得更加邊緣化。使用Pandas，它可以幫助維持“層次結(jié)構(gòu)”，如果你愿意，可以像在此處一樣進行批量計算，這些通常排名從最快到最慢（最靈活到最不靈活）：
1. 使用向量化操作：沒有for循環(huán)的Pandas方法和函數(shù)。
2. 將.apply方法：與可調(diào)用方法一起使用。
3. 使用.itertuples：從Python的集合模塊迭代DataFrame行作為namedTuples。
4. 使用.iterrows：迭代DataFrame行作為(index，Series)對。雖然Pandas系列是一種靈活的數(shù)據(jù)結(jié)構(gòu)，但將每一行構(gòu)建到一個系列中然后訪問它可能會很昂貴。
5. 使用“element-by-element”循環(huán)：使用df.loc或df.iloc一次更新一個單元格或行。

使用HDFStore防止重新處理
現(xiàn)在你已經(jīng)了解了Pandas中的加速數(shù)據(jù)流程，接著讓我們探討如何避免與最近集成到Pandas中的HDFStore一起重新處理時間。
通常，在構(gòu)建復(fù)雜數(shù)據(jù)模型時，可以方便地對數(shù)據(jù)進行一些預(yù)處理。例如，如果您有10年的分鐘頻率耗電量數(shù)據(jù)，即使你指定格式參數(shù)，只需將日期和時間轉(zhuǎn)換為日期時間可能需要20分鐘。你真的只想做一次，而不是每次運行你的模型，進行測試或分析。
你可以在此處執(zhí)行的一項非常有用的操作是預(yù)處理，然后將數(shù)據(jù)存儲在已處理的表單中，以便在需要時使用。但是，如何以正確的格式存儲數(shù)據(jù)而無需再次重新處理？如果你要另存為CSV，則只會丟失datetimes對象，并且在再次訪問時必須重新處理它。
Pandas有一個內(nèi)置的解決方案，它使用 HDF5，這是一種專門用于存儲表格數(shù)據(jù)陣列的高性能存儲格式。 Pandas的 HDFStore 類允許你將DataFrame存儲在HDF5文件中，以便可以有效地訪問它，同時仍保留列類型和其他元數(shù)據(jù)。它是一個類似字典的類，因此您可以像讀取Python dict對象一樣進行讀寫。
以下是將預(yù)處理電力消耗DataFrame df存儲在HDF5文件中的方法：
# 創(chuàng)建儲存對象，并存為 processed_data
data_store = pd.HDFStore("processed_data.h5")

# 將 DataFrame 放進對象中，并設(shè)置 key 為 preprocessed_df
data_store["preprocessed_df"] = df
data_store.close()
現(xiàn)在，你可以關(guān)閉計算機并休息一下。等你回來的時候，你處理的數(shù)據(jù)將在你需要時為你所用，而無需再次加工。以下是如何從HDF5文件訪問數(shù)據(jù)，并保留數(shù)據(jù)類型：
# 獲取數(shù)據(jù)儲存對象
data_store = pd.HDFStore("processed_data.h5")

# 通過key獲取數(shù)據(jù)
preprocessed_df = data_store["preprocessed_df"]
data_store.close()
數(shù)據(jù)存儲可以容納多個表，每個表的名稱作為鍵。
關(guān)于在Pandas中使用HDFStore的注意事項：您需要安裝PyTables> = 3.0.0，因此在安裝Pandas之后，請確保更新PyTables，如下所示：
pip install --upgrade tables
結(jié)論
如果你覺得你的Pandas項目不夠快速，靈活，簡單和直觀，請考慮重新考慮你使用該庫的方式。
這里探討的示例相當(dāng)簡單，但說明了Pandas功能的正確應(yīng)用如何能夠大大改進運行時和速度的代碼可讀性。以下是一些經(jīng)驗，可以在下次使用Pandas中的大型數(shù)據(jù)集時應(yīng)用這些經(jīng)驗法則：

嘗試盡可能使用矢量化操作，而不是在df 中解決for x的問題。如果你的代碼是許多for循環(huán)，那么它可能更適合使用本機Python數(shù)據(jù)結(jié)構(gòu)，因為Pandas會帶來很多開銷。
如果你有更復(fù)雜的操作，其中矢量化根本不可能或太難以有效地解決，請使用.apply方法。
如果必須循環(huán)遍歷數(shù)組（確實發(fā)生了這種情況），請使用.iterrows()或.itertuples()來提高速度和語法。
Pandas有很多可選性，幾乎總有幾種方法可以從A到B。請注意這一點，比較不同方法的執(zhí)行方式，并選擇在項目環(huán)境中效果最佳的路線。
一旦建立了數(shù)據(jù)清理腳本，就可以通過使用HDFStore存儲中間結(jié)果來避免重新處理。
將NumPy集成到Pandas操作中通?？梢蕴岣咚俣炔⒑喕Z法。

參考：https://realpython.com/fast-f...

如果覺得有幫助，還請給點個贊！
歡迎關(guān)注我的個人公眾號：Python數(shù)據(jù)科學(xué)