Parcourir les aide-mémoire · Python
Types de données et conversions pandas
Inspectez et convertissez les types de données pandas en toute sécurité, préservez la nullabilité, détectez les conversions en échec et évitez les changements de schéma silencieux dans les pipelines de données de production.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Inspecter les types de données d’un DataFrame
- 2. Convertir vers les dtypes nullables de pandas
- 3. Convertir explicitement une colonne avec astype()
- 4. Conserver les identifiants sous forme de chaînes
- 5. Convertir du texte numérique en toute sécurité
- 6. Convertir en entiers nullables
- 7. Convertir en flottants nullables
- 8. Convertir en booléens nullables
- 9. Convertir des dates et des horodatages
- 10. Analyser explicitement un format de date et heure connu
- 11. Convertir du texte vers le dtype string de pandas
- 12. Convertir du texte à faible cardinalité en catégoriel
- 13. Définir un type catégoriel ordonné
- 14. Vérifier quelles colonnes ont le dtype générique object
- 15. Détecter des types de valeurs Python mélangés dans une colonne
- 16. Trouver les valeurs dont la conversion numérique échoue
- 17. Retirer une mise en forme connue avant la conversion numérique
- 18. Convertir des chaînes de pourcentage
- 19. Convertir avec prudence des flottants à valeur entière
- 20. Convertir les clés des deux côtés avant un merge
- 21. Convertir avec un dictionnaire de schéma
- 22. Valider les dtypes obtenus
- 23. Comparer la mémoire avant et après la conversion
- 24. Éviter la coercition générique risquée
- 25. Convertir plusieurs colonnes de manière cohérente
- 26. Préserver la précision décimale lorsque l’arithmétique exacte compte
- Interpréter le résultat
- Points à vérifier
- Un identifiant est devenu numérique
- La conversion numérique crée de nouvelles valeurs nulles
- Une colonne d’entiers devient flottante
- La conversion booléenne se comporte de façon étrange
- Les clés de merge ont des dtypes différents
- La mémoire est anormalement élevée
- convert_dtypes() produit un résultat inattendu
- Notes de production
- Le schéma doit être explicite aux frontières du système
- Les échecs de conversion sont des métriques de qualité des données
- Les dtypes nullables sont utiles mais ne sont pas identiques aux dtypes NumPy
- astype() peut lever une erreur sur des valeurs invalides
- Les catégories exigent une sémantique stable
- La conversion de type peut modifier les valeurs
- Les conversions volumineuses allouent de la mémoire
- Erreurs fréquentes
- 1. Traiter les identifiants comme des nombres
- 2. Utiliser astype(int) sur des données nullables
- 3. Utiliser errors="coerce" sans vérifier les échecs
- 4. Supposer que object signifie chaîne
- 5. Utiliser bool() sur du texte
- 6. Convertir des montants en float sans tenir compte de la précision
- 7. Utiliser convert_dtypes() comme contrat de schéma complet
- 8. Convertir les clés de merge séparément sans vérifier leur sémantique
- Étape suivante
- Pour aller plus loin
Problème
Un DataFrame pandas peut se charger sans erreur et pourtant avoir un schéma incorrect.
Problèmes de production fréquents :
- identifiants inférés comme des entiers
- colonnes numériques chargées comme des chaînes
- dates laissées sous forme de texte
- booléens encodés en
"Y","N",0ou1 - colonnes d’entiers converties en virgule flottante parce qu’elles contiennent des valeurs manquantes
- colonnes object mixtes qui masquent des données sources incohérentes
- conversions en échec qui deviennent silencieusement des valeurs manquantes
- jointures en échec parce que les colonnes clés utilisent des dtypes incompatibles
L’objectif est de rendre la conversion de type explicite, d’inspecter les échecs et de préserver le sens métier.
Réponse rapide
Commencez par inspecter le schéma actuel :
print(df.dtypes)
df.info()
Utilisez convert_dtypes() lorsque vous voulez les dtypes nullables de pandas :
df = df.convert_dtypes()
Pour les conversions délibérées, privilégiez les fonctions propres à chaque type :
df["customer_id"] = df["customer_id"].astype("string")
df["amount"] = pd.to_numeric(
df["amount"],
errors="coerce",
)
df["event_time"] = pd.to_datetime(
df["event_time"],
errors="coerce",
utc=True,
)
Inspectez toujours les valeurs dont la conversion échoue avant d’écraser des colonnes sources importantes.
Code / commandes
1. Inspecter les types de données d’un DataFrame
print(df.dtypes)
Pour plus de contexte :
df.info()
Faites-le immédiatement après avoir lu un CSV, du JSON, des résultats SQL ou d’autres entrées faiblement typées.
2. Convertir vers les dtypes nullables de pandas
df = df.convert_dtypes()
Cela peut convertir les colonnes compatibles vers des types nullables de pandas tels que :
Int64
Float64
boolean
string
Utilisez-le comme étape de nettoyage lorsque la sémantique nullable est souhaitable.
Ne supposez pas qu’il comprend parfaitement votre schéma métier.
Un identifiant composé uniquement de chiffres peut tout de même nécessiter une conversion explicite en chaîne.
3. Convertir explicitement une colonne avec astype()
df["customer_id"] = (
df["customer_id"]
.astype("string")
)
Utilisez astype() lorsque les valeurs sources sont déjà valides pour le type cible.
Exemple :
df["quantity"] = (
df["quantity"]
.astype("Int64")
)
Si des valeurs invalides peuvent exister, inspectez-les d’abord ou utilisez une fonction d’analyse telle que pd.to_numeric().
4. Conserver les identifiants sous forme de chaînes
Les identifiants doivent généralement rester des chaînes, même lorsqu’ils ne contiennent que des chiffres.
df["account_id"] = (
df["account_id"]
.astype("string")
)
Exemples d’identifiants qui doivent généralement rester textuels :
- identifiants client
- numéros de compte
- codes postaux (ZIP)
- numéros de téléphone
- SKU
- identifiants de référence externes
Les convertir en nombres peut supprimer les zéros initiaux ou suggérer une signification arithmétique qui n’existe pas.
5. Convertir du texte numérique en toute sécurité
parsed_amount = pd.to_numeric(
df["amount"],
errors="coerce",
)
Inspectez les conversions en échec :
failed = df.loc[
df["amount"].notna()
& parsed_amount.isna()
]
print(failed)
N’affectez ensuite qu’après validation :
df["amount"] = parsed_amount
Cela évite de masquer des valeurs sources invalides.
6. Convertir en entiers nullables
Si des valeurs entières manquantes sont valides :
df["quantity"] = (
pd.to_numeric(
df["quantity"],
errors="coerce",
)
.astype("Int64")
)
Utilisez Int64 de pandas, et non int64 de NumPy, lorsque la colonne doit représenter à la fois des entiers et des valeurs manquantes.
7. Convertir en flottants nullables
df["amount"] = (
pd.to_numeric(
df["amount"],
errors="coerce",
)
.astype("Float64")
)
Vous obtenez ainsi la sémantique des flottants nullables de pandas.
Utilisez le float64 standard lorsque le comportement des types d’extension nullables n’est pas nécessaire.
8. Convertir en booléens nullables
Si la source contient déjà des valeurs de type booléen :
df["is_active"] = (
df["is_active"]
.astype("boolean")
)
Si la source utilise des valeurs textuelles, mappez-les explicitement.
boolean_map = {
"Y": True,
"N": False,
}
mapped = df["is_active"].map(boolean_map)
invalid = df.loc[
df["is_active"].notna()
& mapped.isna()
]
print(invalid)
Puis :
df["is_active"] = (
mapped.astype("boolean")
)
N’utilisez pas la valeur de vérité Python (truthiness) pour convertir des chaînes arbitraires.
Par exemple :
bool("False")
vaut True, car la chaîne n’est pas vide.
9. Convertir des dates et des horodatages
parsed_time = pd.to_datetime(
df["event_time"],
errors="coerce",
utc=True,
)
Inspectez les échecs :
failed = df.loc[
df["event_time"].notna()
& parsed_time.isna()
]
print(failed)
Puis affectez :
df["event_time"] = parsed_time
N’utilisez utc=True que lorsque la normalisation en UTC correspond à la sémantique de la source.
10. Analyser explicitement un format de date et heure connu
df["event_date"] = pd.to_datetime(
df["event_date"],
format="%Y-%m-%d",
errors="coerce",
)
Les formats explicites améliorent la clarté et facilitent la détection des changements inattendus dans la source.
11. Convertir du texte vers le dtype string de pandas
df["customer_name"] = (
df["customer_name"]
.astype("string")
)
Pour les colonnes de texte, privilégiez si possible le dtype string de pandas plutôt que le dtype générique object.
Il offre un comportement plus cohérent vis-à-vis des valeurs manquantes.
12. Convertir du texte à faible cardinalité en catégoriel
df["status"] = (
df["status"]
.astype("category")
)
Cela peut réduire la mémoire utilisée par des valeurs catégorielles répétées.
Bons candidats :
- statut
- code pays
- canal
- type de produit
Mauvais candidats :
- identifiants uniques
- texte libre
- références de transaction à forte cardinalité
Mesurez plutôt que de supposer un gain de mémoire.
13. Définir un type catégoriel ordonné
from pandas.api.types import CategoricalDtype
priority_type = CategoricalDtype(
categories=[
"low",
"medium",
"high",
"critical",
],
ordered=True,
)
df["priority"] = (
df["priority"]
.astype(priority_type)
)
Le tri respecte désormais l’ordre métier plutôt que l’ordre alphabétique.
14. Vérifier quelles colonnes ont le dtype générique object
object_cols = (
df.select_dtypes(include="object")
.columns
)
print(object_cols.tolist())
object peut masquer :
- des chaînes
- des objets Python
- des valeurs mixtes
- des types sources incohérents
Inspectez ces colonnes délibérément.
15. Détecter des types de valeurs Python mélangés dans une colonne
type_counts = (
df["value"]
.dropna()
.map(type)
.value_counts()
)
print(type_counts)
C’est utile lorsqu’une colonne object se comporte de manière incohérente.
Le résultat peut par exemple révéler un mélange de :
str
int
float
C’est généralement le signe qu’il faut normaliser les données sources.
16. Trouver les valeurs dont la conversion numérique échoue
parsed = pd.to_numeric(
df["amount"],
errors="coerce",
)
bad_values = df.loc[
df["amount"].notna()
& parsed.isna(),
"amount",
]
print(
bad_values
.value_counts()
.head(20)
)
Utilisez-le pour repérer des motifs tels que :
- symboles monétaires
- virgules
- libellés textuels
- valeurs sentinelles
- saisies mal formées
17. Retirer une mise en forme connue avant la conversion numérique
Exemples de valeurs sources :
"$1,250.50"
"$99.00"
Normalisez explicitement :
clean_amount = (
df["amount"]
.astype("string")
.str.replace("$", "", regex=False)
.str.replace(",", "", regex=False)
)
parsed_amount = pd.to_numeric(
clean_amount,
errors="coerce",
)
Ne supprimez pas des caractères à l’aveugle, sauf s’il s’agit d’une mise en forme documentée.
18. Convertir des chaînes de pourcentage
Exemple :
"15.5%"
"8%"
Analysez :
pct = (
df["discount_pct"]
.astype("string")
.str.rstrip("%")
)
df["discount_rate"] = (
pd.to_numeric(
pct,
errors="coerce",
)
/ 100
)
Résultat :
15.5% -> 0.155
Rendez l’unité explicite dans le nom de la colonne de sortie.
19. Convertir avec prudence des flottants à valeur entière
Supposons que :
1.0
2.0
NaN
doivent représenter des comptages entiers.
Validez d’abord :
values = pd.to_numeric(
df["quantity"],
errors="coerce",
)
non_integer = values.loc[
values.notna()
& (values % 1 != 0)
]
print(non_integer)
S’il n’y en a aucun :
df["quantity"] = (
values.astype("Int64")
)
Ne tronquez pas silencieusement les décimales.
20. Convertir les clés des deux côtés avant un merge
Inspectez d’abord :
print(left["customer_id"].dtype)
print(right["customer_id"].dtype)
Normalisez de manière cohérente :
left["customer_id"] = (
left["customer_id"]
.astype("string")
)
right["customer_id"] = (
right["customer_id"]
.astype("string")
)
Si la mise en forme peut différer :
left["customer_id"] = (
left["customer_id"]
.str.strip()
)
right["customer_id"] = (
right["customer_id"]
.str.strip()
)
Ne normalisez la casse ou la mise en forme que lorsque la sémantique de l’identifiant le permet.
21. Convertir avec un dictionnaire de schéma
Pour les schémas connus :
schema = {
"order_id": "string",
"customer_id": "string",
"quantity": "Int64",
"amount": "Float64",
"is_active": "boolean",
}
df = df.astype(schema)
N’utilisez cette approche que lorsque les valeurs sont déjà compatibles.
Si les données brutes peuvent contenir du texte invalide, analysez d’abord ces colonnes.
22. Valider les dtypes obtenus
expected = {
"order_id": "string",
"customer_id": "string",
"quantity": "Int64",
"amount": "Float64",
}
for column, dtype in expected.items():
actual = str(df[column].dtype)
if actual != dtype:
raise TypeError(
f"{column}: expected {dtype}, got {actual}"
)
La validation de schéma est utile dans les pipelines d’ingestion de production.
Pour des systèmes plus importants, utilisez un framework dédié à la validation de schéma ou de données.
23. Comparer la mémoire avant et après la conversion
before = df.memory_usage(
deep=True
).sum()
Convertissez :
df["status"] = (
df["status"]
.astype("category")
)
Mesurez à nouveau :
after = df.memory_usage(
deep=True
).sum()
print("Before:", before)
print("After:", after)
Appuyez-vous sur des mesures réelles avant d’adopter des changements de dtype uniquement pour des raisons de mémoire.
24. Éviter la coercition générique risquée
Cette écriture est concise :
df["value"] = pd.to_numeric(
df["value"],
errors="coerce",
)
Mais chaque valeur invalide devient manquante.
Mesurez toujours l’impact :
before_nulls = df["value"].isna().sum()
parsed = pd.to_numeric(
df["value"],
errors="coerce",
)
after_nulls = parsed.isna().sum()
print(
"New nulls:",
after_nulls - before_nulls,
)
Des valeurs nulles nouvelles et inattendues sont un signal de qualité des données.
25. Convertir plusieurs colonnes de manière cohérente
numeric_cols = [
"amount",
"tax",
"discount",
]
for col in numeric_cols:
df[col] = pd.to_numeric(
df[col],
errors="coerce",
)
Dans les pipelines de production, enregistrez le nombre d’échecs de conversion par colonne avant l’affectation.
26. Préserver la précision décimale lorsque l’arithmétique exacte compte
La virgule flottante binaire ne convient pas à tous les calculs financiers.
Pour une sémantique décimale exacte :
from decimal import Decimal
df["amount_decimal"] = (
df["amount_text"]
.map(
lambda x: (
Decimal(x)
if pd.notna(x)
else None
)
)
)
Cela produit des objets Python et s’avère plus lent que les dtypes numériques natifs.
Pour les charges analytiques volumineuses, envisagez un moteur de stockage ou d’exécution doté de types décimaux natifs plutôt que de vous appuyer sur des colonnes pandas de Decimal Python stockées comme objets.
Interpréter le résultat
| dtype / fonction | Signification |
|---|---|
object |
Stockage générique d’objets Python ; souvent des chaînes ou des valeurs mixtes. |
string |
Dtype de chaîne nullable de pandas. |
Int64 |
Dtype d’entier 64 bits nullable de pandas. |
Float64 |
Dtype à virgule flottante nullable de pandas. |
boolean |
Dtype booléen nullable de pandas. |
category |
Valeurs catégorielles encodées, utiles pour des données répétées à faible cardinalité. |
datetime64[ns] |
Date et heure pandas/NumPy sans fuseau horaire. |
datetime64[ns, UTC] |
Date et heure avec fuseau horaire, en UTC. |
astype() |
Conversion explicite ; attend généralement des valeurs compatibles. |
convert_dtypes() |
Infère les dtypes nullables de pandas adaptés. |
pd.to_numeric() |
Analyse des valeurs numériques avec une gestion des erreurs configurable. |
pd.to_datetime() |
Analyse des dates et des horodatages. |
La distinction la plus importante est la suivante :
type de stockage != sens métier
Une valeur qui ressemble à un entier peut tout de même être un identifiant.
Une chaîne peut en réalité représenter un horodatage.
Les choix de type doivent suivre le contrat de données.
Points à vérifier
Un identifiant est devenu numérique
Vérifiez si des zéros initiaux ont été perdus.
Si c’est le cas, récupérez si possible les données depuis la source d’origine et lisez-les comme du texte la prochaine fois.
La conversion numérique crée de nouvelles valeurs nulles
L’analyse de ces valeurs a échoué.
Inspectez-les avant de continuer.
Une colonne d’entiers devient flottante
Cela se produit couramment lorsque des données entières NumPy doivent représenter des valeurs manquantes.
Utilisez le dtype nullable Int64 de pandas lorsque la sémantique entière doit être préservée.
La conversion booléenne se comporte de façon étrange
Les valeurs textuelles telles que :
"False"
"0"
"N"
doivent être mappées explicitement.
Ne vous fiez pas à la valeur de vérité Python.
Les clés de merge ont des dtypes différents
Normalisez les deux côtés avant le merge.
Inspectez aussi les différences de mise en forme.
La mémoire est anormalement élevée
Vérifiez :
- les colonnes
object - les chaînes répétées
- les types numériques de précision inutilement élevée
- les colonnes qui pourraient sans risque être catégorielles
Mesurez avant et après les changements.
convert_dtypes() produit un résultat inattendu
Il infère à partir des valeurs observées, et non de votre contrat métier.
Forcez explicitement le type des colonnes importantes.
Notes de production
Le schéma doit être explicite aux frontières du système
Définissez les types attendus lors de la lecture :
- de CSV
- d’API
- d’extractions SQL
- de charges utiles de messages
- de fichiers externes
Ne vous fiez pas uniquement à l’inférence.
Les échecs de conversion sont des métriques de qualité des données
Suivez :
- le nombre d’échecs d’analyse numérique
- le nombre de dates en échec
- les codes booléens invalides
- les valeurs de catégorie inattendues
Ils ne doivent pas disparaître silencieusement.
Les dtypes nullables sont utiles mais ne sont pas identiques aux dtypes NumPy
Exemples :
Int64 != int64
Float64 != float64
boolean != bool
Les dtypes d’extension nullables de pandas gèrent les valeurs manquantes différemment.
Testez la compatibilité en aval lors de l’export ou de l’intégration avec d’autres bibliothèques.
astype() peut lever une erreur sur des valeurs invalides
C’est souvent souhaitable dans des pipelines maîtrisés.
Si des données brutes mal formées sont attendues, analysez d’abord, inspectez les échecs, puis convertissez.
Les catégories exigent une sémantique stable
Un dtype catégoriel est utile pour les données à faible cardinalité, mais les catégories peuvent différer d’un DataFrame à l’autre.
Soyez prudent lorsque vous :
- concaténez des catégoriels
- comparez des catégories ordonnées
- écrivez vers des systèmes externes
La conversion de type peut modifier les valeurs
Exemples :
- la conversion de flottants en entiers peut tronquer ou échouer
- les horodatages peuvent se décaler lors d’une conversion de fuseau horaire
- la conversion de chaînes en nombres peut perdre la mise en forme
- les flottants binaires peuvent introduire des effets de précision
Validez avant et après.
Les conversions volumineuses allouent de la mémoire
Convertir une grande colonne peut créer un nouveau tableau.
Sur les charges de travail limitées en mémoire :
- ne convertissez que les colonnes nécessaires
- évitez les conversions répétées
- libérez les objets intermédiaires inutilisés
- envisagez de traiter en amont, en SQL ou avec Spark, lorsque c’est pertinent
Erreurs fréquentes
1. Traiter les identifiants comme des nombres
Les identifiants sont des libellés, pas des quantités.
Conservez-les sous forme de chaînes, sauf si l’arithmétique a un sens.
2. Utiliser astype(int) sur des données nullables
Cela peut échouer en présence de valeurs manquantes.
Utilisez le dtype nullable Int64 lorsque c’est approprié.
3. Utiliser errors="coerce" sans vérifier les échecs
Cela peut transformer des valeurs sources incorrectes en valeurs manquantes silencieuses.
Suivez les valeurs nulles nouvellement créées.
4. Supposer que object signifie chaîne
Une colonne object peut contenir des types Python mélangés.
Inspectez les valeurs réelles.
5. Utiliser bool() sur du texte
C’est incorrect pour des valeurs telles que :
bool("False") # True
Mappez explicitement les valeurs sources.
6. Convertir des montants en float sans tenir compte de la précision
La virgule flottante binaire peut être inadaptée aux calculs financiers exacts.
Choisissez le modèle numérique en fonction des exigences.
7. Utiliser convert_dtypes() comme contrat de schéma complet
C’est une aide à l’inférence, pas un substitut à un schéma métier explicite.
8. Convertir les clés de merge séparément sans vérifier leur sémantique
Deux colonnes peuvent toutes deux devenir des chaînes et pourtant ne pas correspondre à cause :
- des espaces
- des zéros initiaux
- de la casse
- des règles de mise en forme
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.