Python Pandas get_dummies方法用法及代碼示例

Pandas get_dummies(~) 方法對分類變量執行 one-hot 編碼或虛擬編碼。

參數

1.data | array-like 或 DataFrame

其分類變量將被 one-hot 編碼的源數據。

2. prefix | string 或 list<string> 或 dict | optional

附加到 dummy-encoded 列標簽的前綴。默認情況下，prefix=None 。

3. prefix_sep | string | optional

在前綴和列名之間使用的分隔符。必須指定 prefix 才能生效。默認情況下，prefix_sep="_" 。

4. dummy_na | boolean | optional

是否附加指示缺失值的新列。默認情況下，dummy_na=False 。

5. columns | array-like | optional

將進行 one-hot 編碼的列的標簽。默認情況下，columns=None 。

6. sparse | boolean | optional

是否使用SparseArray 來表示dummy-encoded 列。默認情況下，sparse=False 。

7. drop_first | boolean | optional

是否刪除一列dummy-encoded。默認情況下，drop_first=False 。

8. dtype | dtype | optional

新虛擬列的數據類型。默認情況下，dtype=np.uint8 。

返回值

其分類變量已被 one-hot 編碼的 DateFrame。

例子

基本用法

考慮以下 DataFrame ：

df = pd.DataFrame({"name":["alex","bob","cathy"], "group":["A","B","A"]})
df



   name  group
0  alex   A
1  bob    B
2  cathy  A

這裏，group 列保存分類變量。但是，默認情況下，所有字符串都將被解釋為分類變量 - 在這種情況下這是不可取的，因為我們知道 name 不是分類變量：

pd.get_dummies(df)



   name_alex  name_bob  name_cathy  group_A  group_B
0     1          0          0          1       0
1     0          1          0          0       1
2     0          0          1          1       0

為了指定group列是one-hot編碼的分類變量，我們隻需要設置columns參數，如下所示：

pd.get_dummies(df, columns=["group"])



   name  group_A  group_B
0  alex     1        0
1  bob      0        1
2  cathy    1        0

在這裏，請注意 name 列如何不是 one-hot 編碼的。

One-hot 使用列表進行編碼

要從列表構建 one-hot 編碼的 DataFrame：

pd.get_dummies(["A","B","C","B"])



   A  B  C
0  1  0  0
1  0  1  0
2  0  0  1
3  0  1  0

我們在這裏再次展示df供您參考：

df



   name  group
0  alex   A
1  bob    B
2  cathy  A

指定前綴

默認情況下，分類變量的列標簽成為新列標簽的前綴：

pd.get_dummies(df, columns=["group"])



   name  group_A  group_B
0  alex    1        0
1  bob     0        1
2  cathy   1        0

我們可以通過設置prefix參數來指定自定義前綴：

pd.get_dummies(df, columns=["group"], prefix="Group")



   name   Group_A  Group_B
0  alex     1        0
1  bob      0        1
2  cathy    1        0

指定prefix_sep

默認情況下，分類變量的前綴和值之間的分隔符是 "_" 。我們可以將其更改為我們想要的任何內容：

pd.get_dummies(df, columns=["group"], prefix_sep="@")



   name  group@A  group@B
0  alex    1       0
1  bob     0       1
2  cathy   1       0

指定dummy_na

考慮以下 DataFrame ：

df = pd.DataFrame({"name":["alex","bob","cathy"], "group":["A","B",np.NaN]})
df



   name  group
0  alex   A
1  bob    B
2  cathy  NaN

在這裏，我們為 Cathy 的組提供了一個缺失值 (NaN)。

默認情況下， dummy_na=False ，這意味著缺失值將導致該行的所有 0 ：

pd.get_dummies(df, columns=["group"])



   name  group_A  group_B
0  alex     1        0
1  bob      0        1
2  cathy    0        0

如果我們像這樣設置dummy_na=True，則缺失值可以被視為一個單獨的類別：

pd.get_dummies(df, columns=["group"], dummy_na=True)



   name  group_A  group_B   group_nan
0  alex     1        0         0
1  bob      0        1         0
2  cathy    0        0         1

請注意我們如何創建一個名為 group_nan 的新列。

指定稀疏

One-hot 編碼本質上會產生一組稀疏的列(即許多 0 )。為了節省內存使用，我們可以選擇使用SparseArray來存儲one-hot編碼列，而不是傳統的Numpy數組。

需要注意的是，SparseArray 沒有 Numpy 數組那麽多的函數，因此隻有在處理導致內存問題的大型 DataFrame 時才設置 sparse=True。

考慮與上麵相同的df：

df



   name  group
0  alex   A
1  bob    B
2  cathy  A

這是 dummy-encoded 列的默認 dtype ：

pd.get_dummies(df, columns=["group"]).dtypes



name       object
group_A     uint8
group_B     uint8
dtype: object

這是我們設置 sparse=True 時的 dtype ：

pd.get_dummies(df, columns=["group"], sparse=True).dtypes



name                 object
group_A    Sparse[uint8, 0]
group_B    Sparse[uint8, 0]
dtype: object

我們看到 dummy-encoded 列的內部表示已更改。

指定drop_first

考慮以下 DataFrame ：

df = pd.DataFrame({"name":["alex","bob","cathy"], "group":["A","B","A"]})
df



   name   group
0  alex     A
1  bob      B
2  cathy    A

默認情況下， drop_first=False ，這意味著每個分類變量都有自己的一列：

pd.get_dummies(df, columns=["group"])   # drop_first=False



   name  group_A  group_B
0  alex     1        0
1  bob      0        1
2  cathy    1        0

通過設置 drop_first=True ，我們刪除一個 dummy-encoded 列：

pd.get_dummies(df, columns=["group"], drop_first=True)



   name  group_B
0  alex     0
1  bob      1
2  cathy    0

這裏的關鍵是，即使我們刪除單個dummy-encoded列，我們仍然可以弄清楚一個人屬於哪個組。