在 Pandas 中，資料對齊是進行資料運算的基礎。無論是 Series 還是 DataFrame，運算都會根據索引和欄位自動對齊。當索引或欄位不匹配時，Pandas 會以 NaN 填充缺失值，確保運算結果的完整性。開發者可以利用 fill_value 引數指定自定義的填充值，避免 NaN 的出現，提升資料處理的靈活性。合併多個資料集時，Pandas 提供了強大的合併功能，方便資料整合與分析。實際應用中，資料常包含缺失值，Pandas 提供了 isnull、notnull、dropna 和 fillna 等方法來偵測、刪除和填充缺失值，確保資料的品質和分析結果的可靠性。理解 NaN 和 None 的區別，並根據資料型別選擇合適的填充方法，對於有效處理缺失值至關重要。
資料對齊與運算
在 Pandas 中，當進行資料運算時，索引（index）和欄位（columns）對齊是一個重要的概念。這意味著當兩個 Series 或 DataFrame 進行運算時，Pandas 會根據索引和欄位名稱進行對齊。
Series 運算
讓我們首先考慮 Series 的運算。假設我們有兩個 Series，A 和 B，它們的索引不同：
import pandas as pd
A = pd.Series([2, 4, 6], index=[1, 2, 3])
B = pd.Series([1, 3, 5], index=[1, 2, 3])
當我們將 A 和 B 相加時，Pandas 會根據索引進行對齊：
A + B
輸出結果為：
1 3.0
2 7.0
3 11.0
dtype: float64
如果索引不匹配，Pandas 會使用 NaN（Not a Number）填充缺失的值：
A = pd.Series([2, 4, 6], index=[1, 2, 3])
B = pd.Series([1, 3, 5], index=[1, 2, 4])
A + B
輸出結果為：
1 3.0
2 7.0
3 NaN
4 NaN
dtype: float64
使用 fill_value 修改缺失值
如果不想要使用 NaN 作為缺失值，可以使用 add() 方法的 fill_value 引數指定一個填充值：
A.add(B, fill_value=0)
輸出結果為：
1 3.0
2 7.0
3 6.0
4 5.0
dtype: float64
DataFrame 運算
DataFrame 的運算也會根據索引和欄位進行對齊。假設我們有兩個 DataFrame，A 和 B，它們的索引和欄位不同：
A = pd.DataFrame({'a': [1, 2], 'b': [3, 4]}, index=[1, 2])
B = pd.DataFrame({'a': [5, 6], 'b': [7, 8]}, index=[1, 2])
當我們將 A 和 B 相加時，Pandas 會根據索引和欄位進行對齊：
A + B
輸出結果為：
a b
1 6 10
2 8 12
如果索引或欄位不匹配，Pandas 會使用 NaN 填充缺失的值。
圖表翻譯：
內容解密：
在上面的例子中，我們可以看到 Pandas 如何根據索引和欄位進行對齊。當進行運算時，Pandas 會根據索引和欄位名稱進行對齊，如果索引或欄位不匹配，Pandas 會使用 NaN 填充缺失的值。同時，我們也可以使用 add() 方法的 fill_value 引數指定一個填充值，以避免使用 NaN。
資料合併與運算
當我們處理多個資料集時，瞭解如何正確地合併和運算這些資料是非常重要的。Pandas 提供了強大的工具來處理這些任務，包括資料框架（DataFrame）的合併和運算。
資料框架的加法運算
在上面的例子中，我們看到兩個資料框架 A 和 B 如何進行加法運算。這個運算是根據索引（index）進行的，這意味著即使 A 和 B 的列順序不同，Pandas 仍然可以正確地對齊這些資料並進行運算。
import pandas as pd
import numpy as np
# 建立隨機資料
rng = np.random.default_rng()
# 建立資料框架 A
A = pd.DataFrame(rng.integers(0, 10, (3, 3)), columns=['a', 'b', 'c'])
# 建立資料框架 B
B = pd.DataFrame(rng.integers(0, 10, (3, 3)), columns=['b', 'a', 'c'])
# 進行加法運算
result = A + B
print(result)
處理缺失值
在進行加法運算時，如果兩個資料框架中有一個位置的值缺失，則結果在那個位置也會是缺失值（NaN）。為了避免這種情況，我們可以使用 add 方法並指定 fill_value 引數來填充缺失值。
# 計算 A 中所有值的平均
fill_value = A.values.mean()
# 進行加法運算並填充缺失值
result = A.add(B, fill_value=fill_value)
print(result)
Pandas資料操作：運算元與方法的對應
Pandas是一個強大的資料操作函式庫，提供了多種方法來進行資料運算。在本文中，我們將探討Pandas中運算元的使用方法，以及它們與相應的Pandas方法之間的對應關係。
運算元與方法的對應
下表列出了Python運算元與其相應的Pandas方法：
| Python運算元 | Pandas方法 |
|---|---|
| + | add |
| - | sub, subtract |
| * | mul, multiply |
| / | truediv, div, divide |
| // | floordiv |
| % | mod |
| ** | pow |
這些方法可以用於DataFrame和Series之間的運算。例如，假設我們有兩個DataFrame，df1和df2，我們可以使用+運算元或add()方法來計算它們的和：
import pandas as pd
# 建立兩個DataFrame
df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'A': [7, 8, 9], 'B': [10, 11, 12]})
# 使用+運算元
result1 = df1 + df2
# 使用add()方法
result2 = df1.add(df2)
print(result1)
print(result2)
DataFrame和Series之間的運算
當我們進行DataFrame和Series之間的運算時，Pandas會根據索引和欄位進行對齊。結果將是一個新的DataFrame或Series。例如：
import pandas as pd
import numpy as np
# 建立一個DataFrame
df = pd.DataFrame(np.random.randint(0, 10, size=(3, 4)), columns=['Q', 'R', 'S', 'T'])
# 建立一個Series
s = pd.Series([1, 2, 3, 4], index=['Q', 'R', 'S', 'T'])
# 進行運算
result = df - s
print(result)
在這個例子中，Pandas會根據索引和欄位進行對齊，然後進行減法運算。
內容解密：
當我們進行資料操作時，常常需要對整個 DataFrame 或 Series 進行元素級別的運算。 Pandas 提供了多種方法來實作這種運算，包括使用運算子（如 -）和呼叫對應的物件方法（如 subtract）。
在上面的例子中，我們首先建立了一個 DataFrame df，然後使用減法運算子 (-) 對其進行元素級別的減法運算。具體來說，我們計算了 df 與其第一行 (df.iloc[0]) 的差值。結果是一個新的 DataFrame，其中每個元素都是原始 DataFrame 中對應元素與第一行中對應元素的差值。
import pandas as pd
# 建立一個示例DataFrame
data = {'Q': [0, 1, 4],
'R': [0, 4, -2],
'S': [0, -2, 4],
'T': [0, 8, 1]}
df = pd.DataFrame(data)
# 計算df與其第一行的差值
result = df - df.iloc[0]
print(result)
圖表翻譯：
此圖示為上述程式碼的執行結果，展示了原始 DataFrame df 與其第一行的差值。每個元素都是透過從原始 DataFrame 中的對應元素中減去第一行中對應元素的值而得出的。
程式碼解說：
在這段程式碼中，我們使用 iloc 方法選取 DataFrame 的第一行，然後使用減法運算子 (-) 對原始 DataFrame 與第一行進行元素級別的減法運算。結果是一個新的 DataFrame，其中每個元素都是原始 DataFrame 中對應元素與第一行中對應元素的差值。
此外，Pandas 還提供了 subtract 方法來實作元素級別的減法運算。這個方法可以指定軸向（axis），從而允許使用者在列或行方向上進行運算。
# 使用subtract方法進行減法運算
result = df.subtract(df['R'], axis=0)
print(result)
在這個例子中，我們使用 subtract 方法計算原始 DataFrame df 與其 ‘R’ 列之間的差值。結果是一個新的 DataFrame，其中每個元素都是原始 DataFrame 中對應元素與 ‘R’ 列中對應元素的差值。
圖表翻譯：
此圖示為上述程式碼的執行結果，展示了原始 DataFrame df 與其 ‘R’ 列之間的差值。每個元素都是透過從原始 DataFrame 中的對應元素中減去 ‘R’ 列中對應元素的值而得出的。
處理缺失資料
在真實世界中，資料往往不完整或不齊一。許多有趣的資料集都會有一些缺失的資料。為了處理這種情況，Pandas 提供了多種方法來表示和處理缺失資料。
缺失資料的表示
Pandas 使用兩種方法來表示缺失資料：使用 NaN（Not a Number）作為哨兵值，或者使用可空資料型別（nullable data types）。NaN 是 IEEE 浮點數規範的一部分，代表無效或未定義的值。
可空資料型別
Pandas 的可空資料型別允許您建立一個帶有遮罩陣列的 DataFrame，以追蹤缺失的條目。這些缺失的條目被呈現為特殊值 pd.NA。
None 作為哨兵值
對於某些資料型別，Pandas 使用 None 作為哨兵值。None 是一個 Python 物件，這意味著任何包含 None 的陣列必須具有 dtype=object，即它必須是一個 Python 物件序列。
NaN 的使用
NaN 是用於表示浮點數中缺失或無效值的哨兵值。它是 IEEE 浮點數規範的一部分，可以用於表示無法進行算術運算的結果。
選擇哨兵值或遮罩陣列
選擇使用哨兵值或遮罩陣列來表示缺失資料取決於具體的情況。使用哨兵值可以簡化程式碼，但可能會限制有效值的範圍。使用遮罩陣列可以提供更大的靈活性，但可能會增加儲存和計算的開銷。
內容解密：
以下程式碼示範瞭如何使用 Pandas 處理缺失資料：
import pandas as pd
import numpy as np
# 建立一個包含缺失值的 DataFrame
df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, 7, 8]})
# 使用 NaN 作為哨兵值
print(df.isnull())
# 使用可空資料型別
df_nullable = df.astype('Int64')
print(df_nullable.isnull())
圖表翻譯：
在這個圖表中，我們展示瞭如何使用 Pandas 處理缺失資料。原始資料包含缺失值，然後我們使用 NaN 或可空資料型別來處理這些缺失值。最終，我們得到處理後的資料。
處理缺失資料：None 與 NaN
在資料分析中，缺失資料是一個常見的問題。Python 的 NumPy 函式庫提供了兩種方法來表示缺失資料：None 和 NaN。下面，我們將探討這兩種方法的區別和使用方法。
None
None 是 Python 的內建常數，用於表示空或缺失的值。當我們在 NumPy 陣列中使用 None 時，NumPy 會將陣列的資料型別設為 object。這意味著資料將被儲存為 Python 物件，而不是原生資料型別。
import numpy as np
vals1 = np.array([1, None, 2, 3])
print(vals1)
輸出：
array([1, None, 2, 3], dtype=object)
使用 None 的缺點是，它會導致資料操作變慢，因為 NumPy 需要在 Python 層面上進行操作。例如，對於一個包含 1 百萬個整數的陣列，使用 None 的 sum 運算比使用原生整數型別的 sum 運算慢了 30 倍以上。
%timeit np.arange(1E6, dtype=int).sum()
%timeit np.arange(1E6, dtype=object).sum()
輸出：
2.73 ms ± 288 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
92.1 ms ± 3.42 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
此外，因為 Python 不支援對 None 進行算術運算，因此對陣列進行聚合運算（如 sum 或 min）將導致錯誤。
vals1.sum()
輸出：
TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'
NaN
NaN（Not a Number）是一個特殊的浮點數值，用於表示缺失或無效的資料。與 None 不同，NaN 是一個原生浮點數值，可以與其他資料進行快速的算術運算。
vals2 = np.array([1, np.nan, 3, 4])
print(vals2)
輸出：
array([ 1., nan, 3., 4.])
注意到 NumPy 對於這個陣列選擇了一個原生浮點數型別，這意味著可以進行快速的運算。然而，NaN 有一個特殊的性質：它會“感染”任何與它進行算術運算的其他資料。
1 + np.nan
0 * np.nan
輸出：
nan
nan
這意味著對 NaN 進行聚合運算（如 sum 或 min）將得到一個 NaN 結果。
vals2.sum(), vals2.min(), vals2.max()
雖然 NaN 可能不總是是有用的，但它至少不會導致錯誤，並且可以在後續的資料分析中被處理和過濾。因此，在處理缺失資料時，NaN 是一個更好的選擇。
使用NaN和None進行缺失值處理
在進行資料分析時，常會遇到缺失值的問題。NumPy和Pandas都提供了處理缺失值的方法，其中包括使用NaN（Not a Number）和None。
NaN在NumPy中的應用
NaN是一個特殊的浮點數值，表示未定義或無效的數值。在NumPy中，NaN可以用於表示缺失值。例如：
import numpy as np
vals2 = [1, 2, np.nan, 4]
print(np.nansum(vals2), np.nanmin(vals2), np.nanmax(vals2))
輸出：
(8.0, 1.0, 4.0)
如上所示，NumPy提供了NaN-aware版本的聚合函式，例如np.nansum、np.nanmin和np.nanmax，可以忽略NaN值。
NaN和None在Pandas中的應用
Pandas也提供了對NaN和None的支援，可以將兩者之間進行轉換。例如：
import pandas as pd
s = pd.Series([1, np.nan, 2, None])
print(s)
輸出：
0 1.0
1 NaN
2 2.0
3 NaN
dtype: float64
如上所示，Pandas會自動將None轉換為NaN。
資料型別的轉換
當在Pandas中遇到NA值時，會自動進行資料型別的轉換。例如：
x = pd.Series(range(2), dtype=int)
x[0] = None
print(x)
輸出：
0 NaN
1 1.0
dtype: float64
如上所示，Pandas會自動將整數陣列轉換為浮點數陣列，以便容納NA值。
圖表翻譯：
如上所示，NumPy和Pandas都提供了對NaN和None的支援，可以忽略缺失值或自動進行資料型別的轉換。
處理 Pandas 中的空值
Pandas 是一個強大的資料分析函式庫，提供了多種方法來處理空值。空值可以是 None、NaN（Not a Number）或 NA（Not Available），這些值在資料分析中非常重要。
Pandas 中的空值型別
在 Pandas 中，空值可以是以下幾種型別：
- none：Python 中的空值。
- NaN（Not a Number）：用於表示數值運算中無效或未定義的結果。
- NA（Not Available）：用於表示資料缺失或未知。
Pandas 的 Nullable Dtypes
早期版本的 Pandas 中，NaN 和 None 是唯一可用的空值表示方式。然而，這種方法存在一些問題，例如在整數陣列中表示空值的困難。為瞭解決這個問題，Pandas 後來引入了可空的資料型別（nullable dtypes），這些型別與普通的資料型別區別開來（例如，pd.Int32 與 np.int32）。
示例：建立帶有空值的 Series
以下示例展示瞭如何建立一個包含整數和空值的 Series：
import pandas as pd
import numpy as np
# 建立一個包含整數和空值的 Series
series = pd.Series([1, np.nan, 2, None, pd.NA], dtype='Int32')
print(series)
輸出結果：
0 1
1 <NA>
2 2
3 <NA>
4 <NA>
dtype: Int32
處理空值的方法
Pandas 提供了多種方法來處理空值，包括：
- isnull：生成一個布林遮罩，指示哪些值是空的。
- notnull：與
isnull相反，生成一個布林遮罩，指示哪些值不是空的。 - dropna：刪除包含空值的行或列。
以下示例展示瞭如何使用 isnull 和 dropna 方法：
import pandas as pd
import numpy as np
# 建立一個包含整數和空值的 DataFrame
data = {'A': [1, 2, np.nan, 4],
'B': [5, np.nan, 7, 8]}
df = pd.DataFrame(data)
print("原始 DataFrame:")
print(df)
print("\n使用 isnull 方法檢測空值:")
print(df.isnull())
print("\n使用 dropna 方法刪除包含空值的行:")
print(df.dropna())
輸出結果：
原始 DataFrame:
A B
0 1.0 5.0
1 2.0 NaN
2 NaN 7.0
3 4.0 8.0
使用 isnull 方法檢測空值:
A B
0 False False
1 False True
2 True False
3 False False
使用 dropna 方法刪除包含空值的行：
A B
0 1.0 5.0
3 4.0 8.0
處理缺失值的方法
在資料分析中，缺失值是常見的問題。Pandas提供了多種方法來處理缺失值，包括偵測、刪除和填充。
偵測缺失值
Pandas的isnull()和notnull()方法可以用來偵測缺失值。這兩個方法會傳回一個布林遮罩（Boolean mask），指出哪些值是缺失的。
import pandas as pd
import numpy as np
# 建立一個Series，包含缺失值
data = pd.Series([1, np.nan, 'hello', None])
# 偵測缺失值
print(data.isnull())
輸出：
0 False
1 True
2 False
3 True
dtype: bool
刪除缺失值
Pandas的dropna()方法可以用來刪除缺失值。對於Series，結果很直觀：
# 刪除缺失值
print(data.dropna())
輸出：
0 1
2 hello
dtype: object
填充缺失值
Pandas的fillna()方法可以用來填充缺失值。這個方法會傳回一個新的Series或DataFrame，裡面的缺失值已經被填充。
# 填充缺失值
print(data.fillna('未知'))
輸出：
0 1
1 未知
2 hello
3 未知
dtype: object
布林遮罩的使用
布林遮罩可以用來直接索引Series或DataFrame。例如：
# 使用布林遮罩索引Series
print(data[data.notnull()])
輸出：
0 1
2 hello
dtype: object
這些方法可以幫助您處理缺失值，讓您的資料分析更加準確。
處理缺失值的方法
在資料分析中，缺失值是常見的問題。使用 Pandas 這個 Python 函式庫，可以輕易地處理缺失值。對於 Series 物件，dropna() 方法可以直接移除含有缺失值的元素。
import pandas as pd
import numpy as np
# 建立一個 Series 物件
s = pd.Series([1, 2, np.nan, 4])
# 移除含有缺失值的元素
s.dropna()
對於 DataFrame 物件，dropna() 方法也可以用來移除含有缺失值的行或列。預設情況下，dropna() 會移除任何含有缺失值的行。
# 建立一個 DataFrame 物件
df = pd.DataFrame([[1, np.nan, 2],
[2, 3, 5],
[np.nan, 4, 6]])
# 移除含有缺失值的行
df.dropna()
如果你想移除含有缺失值的列，可以使用 axis=‘columns’ 引數。
# 移除含有缺失值的列
df.dropna(axis='columns')
但是，這種方法可能會移除一些有用的資料。為了避免這種情況，可以使用 how 或 thresh 引數來控制移除的條件。例如，你可以設定 how=‘all’ 來只移除所有元素都是缺失值的行或列。
# 只移除所有元素都是缺失值的行
df.dropna(how='all')
或者，你可以設定 thresh 引數來指定至少需要多少個非缺失值才不移除該行或列。
# 至少需要兩個非缺失值才不移除該行
df.dropna(thresh=2)
內容解密：
- dropna() 方法可以用來移除 Pandas Series 或 DataFrame 中的缺失值。
- 對於 Series，dropna() 會直接移除含有缺失值的元素。
- 對於 DataFrame，dropna() 會移除含有缺失值的行或列，視 axis 引數而定。
- how 引數可以用來控制移除的條件，例如 ‘any’ 或 ‘all’。
- thresh 引數可以用來指定至少需要多少個非缺失值才不移除該行或列。
圖表翻譯：
@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle
title Pandas資料對齊與合併運算和缺失值處理
package "Pandas 資料處理" {
package "資料結構" {
component [Series
一維陣列] as series
component [DataFrame
二維表格] as df
component [Index
索引] as index
}
package "資料操作" {
component [選取 Selection] as select
component [篩選 Filtering] as filter
component [分組 GroupBy] as group
component [合併 Merge/Join] as merge
}
package "資料轉換" {
component [重塑 Reshape] as reshape
component [透視表 Pivot] as pivot
component [聚合 Aggregation] as agg
}
}
series --> df : 組成
index --> df : 索引
df --> select : loc/iloc
df --> filter : 布林索引
df --> group : 分組運算
group --> agg : 聚合函數
df --> merge : 合併資料
df --> reshape : melt/stack
reshape --> pivot : 重新組織
note right of df
核心資料結構
類似 Excel 表格
end note
@enduml圖表翻譯：
上述流程圖展示瞭如何使用 dropna() 方法處理 Pandas 中的缺失值。首先，檢查原始資料是否含有缺失值。如果有，則根據 axis、how 和 thresh 引數決定是否移除含有缺失值的行或列。最終，得到處理後的結果。
處理缺失值
在資料分析中，缺失值是常見的問題。Pandas 提供了多種方法來處理缺失值，包括刪除和填充。
刪除缺失值
使用 dropna 方法可以刪除含有缺失值的列或行。例如：
import pandas as pd
import numpy as np
# 建立一個 DataFrame
df = pd.DataFrame({
'A': [1, 2, np.nan],
'B': [np.nan, 3, 4],
'C': [5, 6, np.nan]
})
# 刪除含有缺失值的列
df_drop_col = df.dropna(axis='columns', how='all')
print(df_drop_col)
輸出：
A B C
0 1.0 NaN 5.0
1 2.0 3.0 6.0
2 NaN 4.0 NaN
在這個例子中，dropna 方法刪除了含有所有缺失值的列。
填充缺失值
使用 fillna 方法可以填充缺失值。例如：
# 建立一個 Series
data = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'), dtype='Int32')
# 填充缺失值
data_fill = data.fillna(0)
print(data_fill)
輸出：
a 1
b 0
c 2
d 0
e 3
dtype: Int32
在這個例子中，fillna 方法填充了缺失值為 0。
進階控制
dropna 方法還提供了 thresh 引數，可以指定最少非缺失值的數量。例如：
# 建立一個 DataFrame
df = pd.DataFrame({
'A': [1, 2, np.nan],
'B': [np.nan, 3, 4],
'C': [5, 6, np.nan]
})
# 刪除含有少於 2 個非缺失值的行
df_drop_row = df.dropna(axis='rows', thresh=2)
print(df_drop_row)
輸出：
A B C
1 2.0 3.0 6.0
在這個例子中，dropna 方法刪除了含有少於 2 個非缺失值的行。
處理缺失值的方法
在資料分析中，缺失值是常見的問題。以下介紹幾種處理缺失值的方法。
使用特定值填充
我們可以使用特定的值來填充缺失值，例如使用零填充：
import pandas as pd
import numpy as np
# 建立一個含有缺失值的Series
data = pd.Series([1, np.nan, 2, np.nan, 3], dtype='Int32')
# 使用零填充缺失值
data_filled = data.fillna(0)
print(data_filled)
輸出結果：
0 1
1 0
2 2
3 0
4 3
dtype: Int32
向前填充
另一個方法是使用向前填充（forward fill），即將前一個值填充到缺失值的位置：
# 向前填充缺失值
data_filled_ffill = data.fillna(method='ffill')
print(data_filled_ffill)
輸出結果：
0 1.0
1 1.0
2 2.0
3 2.0
4 3.0
dtype: float64
注意，在這個例子中，由於原始資料型別為Int32，但是在使用fillna方法時，pandas會自動將資料型別轉換為float64，以便容納缺失值。
其他填充方法
除了上述方法外，還有其他填充方法可供選擇，例如：
bfill: 向後填充（back fill）interpolate: 線性插值填充pad: 向前填充（等同於ffill）
每種方法都有其適用場景，根據具體需求選擇合適的填充方法。
從資料處理的效能評估視角來看，Pandas 提供的資料對齊與合併、運算元與方法對應以及缺失值處理等機制，展現了其在資料操作方面的靈活性和效率。藉由索引和欄位對齊，Pandas 簡化了資料運算的複雜度，同時 fill_value 引數的運用有效解決了缺失值填充的痛點。然而，不同資料型別在運算中的自動轉換，例如 None 與 NaN 的互動，可能引入隱性的效能損耗，需要開發者注意。考量 NumPy 與 Pandas 在缺失值處理上的效能差異，針對大型資料集，建議優先使用 NaN-aware 的 NumPy 函式或 Pandas 的 Nullable Dtypes 以提升運算效率。展望未來，隨著資料集規模的不斷增長，Pandas 需持續最佳化其缺失值處理機制，例如更有效率的布林遮罩操作和更精細的資料型別控制，才能更好地滿足高效能資料分析的需求。玄貓認為，深入理解 Pandas 的資料對齊、運算和缺失值處理機制，並結合實際應用場景選擇最佳策略，才能最大程度地發揮 Pandas 的效能優勢。
