Fonction Pandas pd.get_dummies()

Pandas 通用函数Fonctions courantes de Pandas

pd.get_dummies()Il s'agit d'une fonction de la bibliothèque Pandas utilisée pourl'encodage one-hot des variables catégorielles. Elle convertit les variables catégorielles en colonnes binaires (0/1), chaque catégorie correspondant à une colonne.

L'encodage one-hot est une technique courante dans le prétraitement en apprentissage automatique, car la plupart des algorithmes ne peuvent pas traiter directement les données catégorielles et doivent les convertir sous forme numérique.

Explication du terme： get_dummiesIci, « dummy » signifie « variable muette », désignant des variables binaires utilisées en statistique et en économétrie pour représenter des variables catégorielles.

Syntaxe de base et paramètres

pd.get_dummies()C'est une fonction de haut niveau de la bibliothèque Pandas, utilisée pour convertir des variables catégorielles au format d'encodage one-hot.

Format de syntaxe

pd.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False, columns=None, drop_first=False, dtype=None)

Description du paramètre

  • Paramètre： data
    • Type : Series, DataFrame ou objet de type tableau.
    • Description : les données à encoder en one-hot. Généralement une Series ou un DataFrame contenant des variables catégorielles.
  • Paramètre： prefix
    • Type : String, liste de chaînes de caractères ou dictionnaire.
    • Description : le préfixe des nouveaux noms de colonnes générés. S'il n'est pas spécifié, les noms de colonnes d'origine sont utilisés comme préfixe.
  • Paramètre： prefix_sep
    • Type : String.
    • Description : Le séparateur entre le préfixe et le nom de la catégorie. Par défaut : trait de soulignement'_'。
  • Paramètre： dummy_na
    • Type : booléen.
    • Description : SiTrue, il crée également une colonne séparée pour les valeurs manquantes (NaN). Par défaut :False。
  • Paramètre： columns
    • Type : List ou None.
    • Description : Les noms de colonnes à encoder. Si non spécifiés, toutes les colonnes de type object, category ou boolean sont encodées.
  • Paramètre： drop_first
    • Type : booléen.
    • Description : SiTrue, il supprimera la première colonne de chaque variable catégorielle pour éviter la multicolinéarité. Dans des modèles tels que la régression logistique, cela peut éviter le piège des variables muettes. Par défaut :False。

Description de la fonction

  • Valeur de retour: Renvoie un DataFrame où chaque colonne correspond à une catégorie et les valeurs sont 0 ou 1.
  • Effet: Convertit les variables catégorielles en colonnes binaires numériques, ce qui facilite le traitement par les algorithmes d'apprentissage automatique.

Exemples

À travers une série d'exemples du simple au complexe, apprenons à maîtriser parfaitementpd.get_dummies()l'utilisation de pd.get_dummies().

Exemple 1 : Utilisation de base - Encodage one-hot d'une Series

Exemple

import pandas as pd

# 1. Créer une Series contenant des variables catégorielles
colors = pd.Series(['red', 'blue', 'green', 'red', 'green', 'blue'])

print("=== Série originale ===")
print(colors)

# 2. Utiliser pd.get_dummies() pour l'encodage one-hot
result = pd.get_dummies(colors)
print("\n"=== Résultat de l'encodage one-hot avec pd.get_dummies() ===")
print(result)

Sortie attendue :

=== 原始 Series ===
0      red
1     blue
2     green
3      red
4     green
5     blue
dtype: object

=== pd.get_dummies() 独热编码结果 ===
    blue  green  red
0  False   False  True
1   True   False  False
2  False    True  False
3  False   False  True
4  False    True  False
5   True   False  False

Explication du code :

  1. La Series originale contient trois couleurs : rouge, bleu, vert.
  2. Après l'encodage one-hot, chaque couleur devient une colonne, en utilisantTrue/Falsepour indiquer si la ligne appartient à cette catégorie.
  3. Chaque ligne a exactement unTrue, correspondant à la valeur de couleur d'origine.

Exemple 2 : Encodage de colonnes spécifiques d'un DataFrame

Dans l'analyse de données, il est souvent nécessaire d'encoder uniquement des colonnes catégorielles spécifiques tout en laissant les colonnes numériques inchangées.

Exemple

import pandas as pd

# 1. Créer un DataFrame contenant des variables numériques et catégorielles
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana'],
    'age': [25, 30, 35, 28],
    'city': ['Beijing', 'Shanghai', 'Beijing', 'Guangzhou'],
    'department': ['Ventes', 'Ingénierie', 'Ventes', 'HR']
})

print("=== DataFrame d'origine ===")
print(df)

# 2. Effectuer un encodage one-hot sur les colonnes catégorielles spécifiées
result = pd.get_dummies(df, columns=['city', 'department'])
print("\n"=== Encodage one-hot pour les colonnes city et department ===")
print(result)

Sortie attendue :

=== 原始 DataFrame ===
      name  age       city  department
0    Alice   25    Beijing       Sales
1      Bob   30  Shanghai  Engineering
2  Charlie   35    Beijing       Sales
3   Diana   28  Guangzhou         HR

=== 对 city 和 department 列进行独热编码 ===
      name  age  city_Beijing  city_Guangzhou  city_Shanghai  department_Engineering  department_HR  department_Sales
0    Alice   25           True            False           False                False            True
1      Bob   30          False           False            True                True           False
2  Charlie   35           True           False           False                False            True
3   Diana   28          False            True           False                False           False

Explication du code :

  • Utilisez lacolumnsparamètre pour spécifier que seules lescityetdepartmentcolonnes sont encodées.
  • Colonnes numériquesageet les colonnes textuellesnamerestent inchangées.
  • Les noms de colonnes nouvellement générés utilisent le séparateur par défaut underscore, commecity_Beijing。

Exemple 3 : Préfixe et séparateur personnalisés

Vous pouvez utiliser laprefixetprefix_sepparamètre pour personnaliser les noms des nouvelles colonnes.

<h2 class="example">Exemple
import pandas as pd

# 1. Créer un DataFrame
df = pd.DataFrame({
    'color': ['red', 'blue', 'green', 'red'],
    'size': ['S', 'M', 'L', 'XL']
})

print("=== DataFrame d'origine ===")
print(df)

# 2. Utiliser le paramètre prefix pour personnaliser le préfixe
result_prefix = pd.get_dummies(df, prefix=['color', 'size'])
print("\n"=== Utilisation du préfixe personnalisé ===")
print(result_prefix)

# 3. Utiliser prefix_sep pour personnaliser le séparateur
result_sep = pd.get_dummies(df, prefix=['color', 'size'], prefix_sep='-')
print("\n"=== Utilisation d'un séparateur personnalisé '-' ===")
print(result_sep)

Sortie attendue :

=== 原始 DataFrame ===
   color  size
0    red     S
1   blue     M
2  green     L
3    red    XL

=== 使用自定义前缀 ===
   color_blue  color_green  color_red  size_L  size_M  size_S  size_XL
0       False        False       True   False   False    True   False
1        True       False      False   False    True   False   False
2       False        True      False    True   False   False   False
3       False        False       True   False   False   False    True

=== 使用自定义分隔符 '-' ===
   color-blue  color-green  color-red  size-L  ...

Explication du code :

  • prefix=['color', 'size']Spécifiez différents préfixes pour différentes colonnes.
  • prefix_sep='-'Remplacez le trait de soulignement par défaut par un tiret, et les nouveaux noms de colonnes deviennentcolor-redcette forme.

Exemple 4 : Gestion des valeurs manquantes et du paramètre drop_first

Exemple

import pandas as pd
import numpy as np

# 1. Données contenant des valeurs manquantes
df = pd.DataFrame({
    'color': ['red', 'blue', np.nan, 'red', 'green'],
    'size': ['S', 'M', 'L', np.nan, 'XL']
})

print("=== DataFrame contenant des valeurs manquantes ===")
print(df)

# 2. Par défaut, les valeurs manquantes ne sont pas gérées
result_default = pd.get_dummies(df, columns=['color'])
print("\n"=== Par défaut : les valeurs manquantes ne sont pas traitées ===")
print(result_default)

# 3. dummy_na=True crée une colonne distincte pour les valeurs manquantes
result_na = pd.get_dummies(df, columns=['color'], dummy_na=True)
print("\n"=== dummy_na=True crée une colonne pour les valeurs manquantes ===")
print(result_na)

# 4. drop_first=True supprime la première colonne pour éviter la multicolinéarité
result_drop = pd.get_dummies(df, columns=['size'], drop_first=True)
print("\n"=== drop_first=True supprime la première colonne ===")
print(result_drop)

Sortie attendue :

=== 包含缺失值的 DataFrame ===
   color  size
0    red     S
1   blue     M
2    NaN     L
3    red   NaN
4  green   XL

=== 默认不处理缺失值 ===
   size  color_blue  color_green  color_red
0     S       False        False       True
1     M        True       False      False
2     L       False        False      False
3     S       False        False       True
4    XL       False        True      False

=== dummy_na=True 为缺失值创建列 ===
   size  color_True  color_blue  color_green  color_red
0     S       False        False        False       True
1     M       False         True        False      False
2     L        True        False        False       False
3     S       False        False        False       True
4    XL       False        False         True       False

=== drop_first=True 删除第一列 ===
   color_blue  color_green  color_red
0       False        False       True
1        True       False      False
2       False        False      False
3       False        False       True
4       False        True       False

Explication du code :

  • dummy_na=TrueCréez une colonne supplémentaire pour les valeurs manquantes (indiquée comme la colonne color_True dans cet exemple).
  • drop_first=TrueLa suppression de la première colonne de chaque groupe (par exemple, size_M est supprimée) peut éviter les problèmes de multicolinéarité dans les modèles linéaires.

Astuce :L'encodage one-hot augmente la dimensionnalité des données (une colonne par catégorie). Si le nombre de catégories est très élevé, cela peut conduire à la malédiction de la dimensionnalité. Dans de tels cas, vous pouvez envisager d'utiliser l'encodage par étiquettes (pd.factorize()) ou d'autres méthodes d'encodage.

Pandas 常用函数Fonctions courantes de Pandas