)}"
Fonctions courantes de Pandaspd.factorize()Est une fonction de la bibliothèque Pandas utilisée pourencoder des variables catégoriellesLa fonction convertit les données catégorielles en codes entiers et renvoie une liste de valeurs uniques.
C'est une technique courante dans le prétraitement en apprentissage automatique, convertissant des catégories textuelles en valeurs numériques, ce qui facilite le traitement par les algorithmes. Comparé à l'encodage one-hot (pd.get_dummies()), l'encodage par factorisation n'augmente pas la dimension des données.
Définition du mot： factorizeSignifie « factorisation », ici il s'agit de convertir des variables catégorielles en facteurs numériques (codes entiers).
Syntaxe de base et paramètres
pd.factorize()C'est une fonction de premier niveau de la bibliothèque Pandas, utilisée pour encoder des variables catégorielles sous forme d'entiers.
Format de syntaxe
pd.factorize(values, sort=False, na_sentinel=-1, size_hint=None)
Description du paramètre
- Paramètre：
values- Type : objet de type tableau, tel que Series, list, array, etc.
- Description : les données catégorielles à encoder.
- Paramètre：
sort- Type : valeur booléenne.
True, trie les valeurs uniques avant l'encodage. La valeur par défaut estFalse(encoder dans l'ordre d'apparition).
na_sentinel
- Type: Integer.
Integer used to mark missing values. Default is-1. If set toNone, missing values will be kept as NaN.
Description de la fonction
- Valeur de retour: Renvoie un tuple (codes, uniques), où codes est le tableau d'entiers encodés, et uniques est le tableau des valeurs uniques.
- Effet: Associe les variables catégorielles à une séquence d'entiers commençant à 0, chaque valeur unique correspondant à un entier.
Exemples
Maîtrisons à fond à travers une série d'exemples, du simple au complexepd.factorize()son utilisation.
Exemple 1 : Utilisation de base - Encodage de variables catégorielles
Exemple
import pandas as pd
import numpy as np
# 1. Créer des données catégorielles
colors = pd.Series(['red', 'blue', 'green', 'red', 'blue', 'yellow'])
print("=== Données catégorielles originales ===")
print(colors)
# 2. Utiliser pd.factorize() pour l'encodage
codes, uniques = pd.factorize(colors)
print("\n=== résultat d'encodage pd.factorize() ===")
print(fEncodage : {codes}) # Entier encodé
print(fValeurs uniques : {uniques}) # uniqueValueList
print(f"Type : {type(codes)}")
import numpy as np
# 1. Créer des données catégorielles
colors = pd.Series(['red', 'blue', 'green', 'red', 'blue', 'yellow'])
print("=== Données catégorielles originales ===")
print(colors)
# 2. Utiliser pd.factorize() pour l'encodage
codes, uniques = pd.factorize(colors)
print("\n=== résultat d'encodage pd.factorize() ===")
print(fEncodage : {codes}) # Entier encodé
print(fValeurs uniques : {uniques}) # uniqueValueList
print(f"Type : {type(codes)}")
Sortie attendue :
=== 原始分类数据 === 0 red 1 blue 2 green 3 red 4 blue 5 yellow 原始数据中 'red' 出现 2 次，'blue' 出现 2 次，'green' 和 'yellow' 各出现 1 次。 按出现顺序分配编码： - 'red' -> 0 - 'blue' -> 1 - 'green' -> 2 - 'yellow' -> 3 === 编码: [0 1 2 0 1 3] === 唯一值数组: ['red' 'blue' 'green' 'yellow']
Explication du code :
- Les codes renvoyés forment un tableau d'entiers, où chaque valeur d'origine est remplacée par le code entier correspondant.
- Le tableau uniques stocke toutes les valeurs uniques, disposées dans l'ordre d'encodage correspondant.
- Par défaut, les codes sont attribués dans l'ordre d'apparition (la première valeur qui apparaît est encodée par 0).
Exemple 2 : paramètre sort - Trier les valeurs uniques avant l'encodage
Utilisationsort=Truevous pouvez trier les valeurs uniques avant l'encodage, ce qui rend les résultats plus prévisibles.
Exemple
import pandas as pd
import numpy as np
# Créer des données catégorielles
colors = pd.Series(['red', 'blue', 'green', 'red', 'blue', 'yellow'])
print(=== Données brutes ===)
print(colors)
# 1. Aucun tri (par défaut) - encoder dans l'ordre d'apparition
codes_unsorted, uniques_unsorted = pd.factorize(colors, sort=False)
print("\n=== sort=False (par défaut) ===")
print(f"Codes: {codes_unsorted}")
print(fValeurs uniques: {uniques_unsorted})
# 2. Encoder après tri - par ordre alphabétique
codes_sorted, uniques_sorted = pd.factorize(colors, sort=True)
print("\n=== sort=True (par ordre alphabétique) ===)
print(fCodes: {codes_sorted})
print(f"Valeurs uniques: {uniques_sorted}")
# 3. Trier les valeurs numériques
numbers = pd.Series([5, 2, 8, 5, 3, 2, 9])
codes_num, uniques_num = pd.factorize(numbers, sort=True)
print("\n=== Encodage du tri numérique ===)
print(f"Codes : {codes_num}")
print(fValeurs uniques : {uniques_num})
import numpy as np
# Créer des données catégorielles
colors = pd.Series(['red', 'blue', 'green', 'red', 'blue', 'yellow'])
print(=== Données brutes ===)
print(colors)
# 1. Aucun tri (par défaut) - encoder dans l'ordre d'apparition
codes_unsorted, uniques_unsorted = pd.factorize(colors, sort=False)
print("\n=== sort=False (par défaut) ===")
print(f"Codes: {codes_unsorted}")
print(fValeurs uniques: {uniques_unsorted})
# 2. Encoder après tri - par ordre alphabétique
codes_sorted, uniques_sorted = pd.factorize(colors, sort=True)
print("\n=== sort=True (par ordre alphabétique) ===)
print(fCodes: {codes_sorted})
print(f"Valeurs uniques: {uniques_sorted}")
# 3. Trier les valeurs numériques
numbers = pd.Series([5, 2, 8, 5, 3, 2, 9])
codes_num, uniques_num = pd.factorize(numbers, sort=True)
print("\n=== Encodage du tri numérique ===)
print(f"Codes : {codes_num}")
print(fValeurs uniques : {uniques_num})
Sortie attendue :
=== 原始数据 === 0 red 1 blue 2 green 3 red 4 blue 5 yellow === sort=False (默认) === 编码: [0 1 2 0 1 3] 唯一值: ['red' 'blue' 'green' 'yellow'] === sort=True (按字母顺序) === 编码: [2 0 1 2 0 3] 唯一值: ['blue' 'green', 'red', 'yellow'] 按字母顺序排列：blue, green, red, yellow - blue -> 0 - green -> 1 - red -> 2 - yellow -> 3 === 数值排序编码 === 编码: [2 0 3 2 1 0 4] 唯一值: [2, 3, 5, 8, 9] 按数值排序：2, 3, 5, 8, 9 - 2 -> 0 - 3 -> 1 - 5 -> 2 - 8 -> 3 - 9 -> 4
Explication du code :
sort=TrueAprès avoir trié les valeurs uniques puis encodé, l’ordre de codage est déterministe et prévisible.- Cela est utile lorsque des résultats reproductibles sont requis.
Exemple 3 : Gestion des valeurs manquantes
na_sentinelLe paramètre est utilisé pour contrôler la gestion des valeurs manquantes.
Exemple
import pandas as pd
import numpy as np
Données contenant des valeurs manquantes
data = pd.Series(['a', 'b', np.nan, 'a', None, 'c', 'b'])
print("=== Données avec valeurs manquantes ===")
print(data)
# 2. Comportement par défaut (valeur manquante → -1)
codes_default, uniques_default = pd.factorize(data)
print("\n=== Gestion par défaut (valeurs manquantes = -1) ===)
print(fEncodage : {codes_default})
print(f"Valeurs uniques : {uniques_default}")
# 3. Encodage personnalisé des valeurs manquantes (simulation de na_sentinel=-999)
codes_custom = np.where(codes_default == -1, -999, codes_default)
print("\n=== Encodage personnalisé des valeurs manquantes (-999) ===)
print(fCodes : {codes_custom})
# 4. Conserver NaN (simuler na_sentinel=None)
codes_nan = codes_default.astype('float')
codes_nan[codes_nan == -1] = np.nan
print("\n=== Conserver NaN ===)
print(f"Codes : {codes_nan}")
print(f"Type d'encodage : {type(codes_nan)
import numpy as np
Données contenant des valeurs manquantes
data = pd.Series(['a', 'b', np.nan, 'a', None, 'c', 'b'])
print("=== Données avec valeurs manquantes ===")
print(data)
# 2. Comportement par défaut (valeur manquante → -1)
codes_default, uniques_default = pd.factorize(data)
print("\n=== Gestion par défaut (valeurs manquantes = -1) ===)
print(fEncodage : {codes_default})
print(f"Valeurs uniques : {uniques_default}")
# 3. Encodage personnalisé des valeurs manquantes (simulation de na_sentinel=-999)
codes_custom = np.where(codes_default == -1, -999, codes_default)
print("\n=== Encodage personnalisé des valeurs manquantes (-999) ===)
print(fCodes : {codes_custom})
# 4. Conserver NaN (simuler na_sentinel=None)
codes_nan = codes_default.astype('float')
codes_nan[codes_nan == -1] = np.nan
print("\n=== Conserver NaN ===)
print(f"Codes : {codes_nan}")
print(f"Type d'encodage : {type(codes_nan)
Sortie attendue :
=== 包含缺失值的数据 === 0 a 1 b 2 NaN 3 a 4 None 5 c 6 b dtype: object === 默认处理（缺失值 = -1）=== 编码: [ 0 1 -1 0 -1 2 1] 唯一值: Index(['a', 'b', 'c'], dtype='object') === 自定义缺失值编码（-999）=== 编码: [ 0 1 -999 0 -999 2 1] === 保持 NaN === 编码: [ 0. 1. nan 0. nan 2. 1.] 编码类型: <class 'numpy.float64'>
Exemple 4 : Application en apprentissage automatique
L'encodage par factorisation est très pratique dans le prétraitement d'apprentissage automatique, en particulier pour les variables catégorielles à cardinalité élevée.
Exemple
import pandas as pd
Créer un DataFrame contenant des variables catégorielles
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank'],
'city': ['Beijing', 'Shanghai', 'Beijing', 'Guangzhou', 'Shanghai', 'Beijing'],
'department': ['Ventes', 'Ingénierie', 'Ventes', 'RH', 'Ingénierie', 'Ventes']
})
print("=== DataFrame d'origine ===")
print(df)
# 2. Factoriser les colonnes catégorielles
# Créer un dictionnaire de correspondance
city_codes, city_uniques = pd.factorize(df['city'])
dept_codes, dept_uniques = pd.factorize(df['department'])
print("\n=== Résultat de l'encodage par factorisation ===)
print(f"codes de ville : {city_codes.tolist()}")
print(f"valeurs uniques de ville : {city_uniques}")
print(f"code du département : {dept_codes.tolist()}")
print(f"valeurs uniques du département : {dept_uniques}")
# 3. Créer le DataFrame encodé
df_encoded = df.copy()
df_encoded['city_encoded'] = city_codes
df_encoded['dept_encoded'] = dept_codes
print("\n=== DataFrame encodé ===)
print(df_encoded)
# 4. Utiliser un dictionnaire de correspondance pour encoder de nouvelles données
print("\n=== Dictionnaire de mappage ===)
city_mapping = dict(zip(city_uniques, range(len(city_uniques))))
print(fmappage des villes : {city_mapping})
# Encoder de nouvelles données
new_cities = pd.Series(['Beijing', 'Shanghai', 'Shenzhen'])
new_codes = new_cities.map(city_mapping)
print(f"\nEncodage des nouvelles données : {new_codes.tolist()}")
Créer un DataFrame contenant des variables catégorielles
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank'],
'city': ['Beijing', 'Shanghai', 'Beijing', 'Guangzhou', 'Shanghai', 'Beijing'],
'department': ['Ventes', 'Ingénierie', 'Ventes', 'RH', 'Ingénierie', 'Ventes']
})
print("=== DataFrame d'origine ===")
print(df)
# 2. Factoriser les colonnes catégorielles
# Créer un dictionnaire de correspondance
city_codes, city_uniques = pd.factorize(df['city'])
dept_codes, dept_uniques = pd.factorize(df['department'])
print("\n=== Résultat de l'encodage par factorisation ===)
print(f"codes de ville : {city_codes.tolist()}")
print(f"valeurs uniques de ville : {city_uniques}")
print(f"code du département : {dept_codes.tolist()}")
print(f"valeurs uniques du département : {dept_uniques}")
# 3. Créer le DataFrame encodé
df_encoded = df.copy()
df_encoded['city_encoded'] = city_codes
df_encoded['dept_encoded'] = dept_codes
print("\n=== DataFrame encodé ===)
print(df_encoded)
# 4. Utiliser un dictionnaire de correspondance pour encoder de nouvelles données
print("\n=== Dictionnaire de mappage ===)
city_mapping = dict(zip(city_uniques, range(len(city_uniques))))
print(fmappage des villes : {city_mapping})
# Encoder de nouvelles données
new_cities = pd.Series(['Beijing', 'Shanghai', 'Shenzhen'])
new_codes = new_cities.map(city_mapping)
print(f"\nEncodage des nouvelles données : {new_codes.tolist()}")
Sortie attendue :
=== 原始 DataFrame ===
name city department
0 Alice Beijing Sales
1 Bob Shanghai Engineering
2 Charlie Beijing Sales
3 Diana Guangzhou HR
4 eve Shanghai Engineering
5 Frank Beijing Sales
=== 因子化编码结果 ===
city 编码: [0 1 0 2 1 0]
city 唯一值: ['Beijing' 'Shanghai' 'Guangzhou']
department 编码: [0 1 0 2 1 0]
department 唯一值: ['Sales' 'Engineering' 'HR']
=== 编码后的 DataFrame ===
name city department city_encoded dept_encoded
0 Alice Beijing Sales 0 0
1 Bob Shanghai Engineering 1 1
2 Charlie Beijing Sales 0 0
3 Diana Guangzhou HR 2 2
4 Eve Shanghai Engineering 1 1
5 Frank Beijing Sales 0 0
=== 映射字典 ===
city 映射: {'Beijing': 0, 'Shanghai': 1, 'Guangzhou': 2}
Explication du code :
pd.factorize()Renvoie un tuple qui peut être directement dépaqueté pour obtenir les codes et les valeurs uniques.- Après avoir créé un dictionnaire de mappage, le même encodage peut être appliqué aux nouvelles données, ce qui facilite l'inférence des modèles d'apprentissage automatique.
- L'encodage par factorisation n'augmente pas la dimension des données, ce qui le rend adapté au traitement des variables catégorielles à cardinalité élevée.
Autres extensionsAstuce :
pd.factorize()Adapté au traitement des variables catégorielles ordonnées ou non ordonnées. Si un encodage one-hot est nécessaire (pour des algorithmes tels que la régression logistique), veuillez utiliserpd.get_dummies()fonction.