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列，我们仍然可以弄清楚一个人属于哪个组。