Explorar guías rápidas · Python
Tipos de datos y conversiones en pandas
Inspecciona y convierte tipos de datos de pandas de forma segura, conserva la nulabilidad, detecta conversiones fallidas y evita cambios silenciosos de esquema en pipelines de datos de producción.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Inspeccionar los tipos de datos de un DataFrame
- 2. Convertir a dtypes nullable de pandas
- 3. Convertir una columna explícitamente con astype()
- 4. Conservar los identificadores como cadenas
- 5. Convertir texto numérico de forma segura
- 6. Convertir a enteros nullable
- 7. Convertir a flotantes nullable
- 8. Convertir a booleanos nullable
- 9. Convertir fechas y marcas de tiempo
- 10. Analizar explícitamente un formato de fecha y hora conocido
- 11. Convertir texto al dtype string de pandas
- 12. Convertir texto de baja cardinalidad a categórico
- 13. Definir un tipo categórico ordenado
- 14. Comprobar qué columnas tienen el dtype genérico object
- 15. Detectar tipos de valores de Python mezclados en una columna
- 16. Encontrar valores que fallan en la conversión numérica
- 17. Eliminar un formato conocido antes de la conversión numérica
- 18. Convertir cadenas de porcentaje
- 19. Convertir con cuidado flotantes con valor entero
- 20. Convertir las claves de ambos lados antes de un merge
- 21. Convertir con un mapa de esquema
- 22. Validar los dtypes resultantes
- 23. Comparar la memoria antes y después de la conversión
- 24. Evitar la coerción genérica insegura
- 25. Convertir varias columnas de forma coherente
- 26. Conservar la precisión decimal cuando importa la aritmética exacta
- Qué significa el resultado
- Qué revisar
- Un identificador se volvió numérico
- La conversión numérica crea nuevos nulos
- Una columna de enteros se vuelve flotante
- La conversión booleana se comporta de forma extraña
- Las claves del merge tienen dtypes distintos
- El uso de memoria es inesperadamente alto
- convert_dtypes() elige un resultado inesperado
- Notas de producción
- El esquema debe ser explícito en los límites del sistema
- Los fallos de conversión son métricas de calidad de datos
- Los dtypes nullable son útiles, pero no idénticos a los dtypes de NumPy
- astype() puede lanzar errores con valores no válidos
- Las categorías necesitan una semántica estable
- La conversión de tipos puede cambiar los valores
- Las conversiones grandes asignan memoria
- Errores comunes
- 1. Tratar los identificadores como números
- 2. Usar astype(int) con datos nullable
- 3. Usar errors="coerce" sin comprobar los fallos
- 4. Suponer que object significa cadena
- 5. Usar bool() con texto
- 6. Convertir importes monetarios a float sin tener en cuenta la precisión
- 7. Usar convert_dtypes() como contrato de esquema completo
- 8. Convertir las claves del merge por separado sin comprobar su semántica
- Siguiente paso
- Para profundizar
Problema
Un DataFrame de pandas puede cargarse correctamente y aun así tener un esquema incorrecto.
Problemas habituales en producción:
- identificadores inferidos como enteros
- columnas numéricas cargadas como cadenas
- fechas que quedan como texto
- booleanos codificados como
"Y","N",0o1 - columnas de enteros convertidas a punto flotante porque contienen valores faltantes
- columnas object mixtas que ocultan datos de origen incoherentes
- conversiones fallidas que se convierten silenciosamente en valores faltantes
- joins que fallan porque las columnas clave usan dtypes incompatibles
El objetivo es hacer explícita la conversión de tipos, inspeccionar los fallos y conservar el significado de negocio.
Respuesta rápida
Empieza inspeccionando el esquema actual:
print(df.dtypes)
df.info()
Usa convert_dtypes() cuando quieras los dtypes nullable de pandas:
df = df.convert_dtypes()
Para conversiones deliberadas, prefiere funciones específicas de cada tipo:
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,
)
Inspecciona siempre los valores cuya conversión falla antes de sobrescribir columnas de origen importantes.
Código / comandos
1. Inspeccionar los tipos de datos de un DataFrame
print(df.dtypes)
Para obtener más contexto:
df.info()
Hazlo justo después de leer CSV, JSON, resultados de SQL u otras entradas con tipado poco estricto.
2. Convertir a dtypes nullable de pandas
df = df.convert_dtypes()
Esto puede convertir las columnas compatibles a tipos nullable de pandas como:
Int64
Float64
boolean
string
Úsalo como paso de limpieza cuando la semántica nullable sea deseable.
No supongas que entiende perfectamente tu esquema de negocio.
Un identificador que solo contiene dígitos puede requerir igualmente una conversión explícita a cadena.
3. Convertir una columna explícitamente con astype()
df["customer_id"] = (
df["customer_id"]
.astype("string")
)
Usa astype() cuando los valores de origen ya sean válidos para el tipo de destino.
Ejemplo:
df["quantity"] = (
df["quantity"]
.astype("Int64")
)
Si pueden existir valores no válidos, inspecciónalos primero o usa una función de análisis como pd.to_numeric().
4. Conservar los identificadores como cadenas
Por lo general, los identificadores deben seguir siendo cadenas aunque solo contengan dígitos.
df["account_id"] = (
df["account_id"]
.astype("string")
)
Ejemplos de identificadores que normalmente deben seguir siendo texto:
- identificadores de cliente
- números de cuenta
- códigos postales (ZIP)
- números de teléfono
- SKU
- identificadores de referencia externos
Convertirlos en números puede eliminar los ceros a la izquierda o sugerir un significado aritmético que no existe.
5. Convertir texto numérico de forma segura
parsed_amount = pd.to_numeric(
df["amount"],
errors="coerce",
)
Inspecciona las conversiones fallidas:
failed = df.loc[
df["amount"].notna()
& parsed_amount.isna()
]
print(failed)
Luego asigna solo después de validar:
df["amount"] = parsed_amount
Así evitas ocultar valores de origen no válidos.
6. Convertir a enteros nullable
Si los valores enteros faltantes son válidos:
df["quantity"] = (
pd.to_numeric(
df["quantity"],
errors="coerce",
)
.astype("Int64")
)
Usa Int64 de pandas, no int64 de NumPy, cuando la columna deba representar tanto enteros como valores faltantes.
7. Convertir a flotantes nullable
df["amount"] = (
pd.to_numeric(
df["amount"],
errors="coerce",
)
.astype("Float64")
)
Esto ofrece la semántica de punto flotante nullable de pandas.
Usa el float64 estándar cuando no necesites el comportamiento de los tipos de extensión nullable.
8. Convertir a booleanos nullable
Si el origen ya contiene valores de tipo booleano:
df["is_active"] = (
df["is_active"]
.astype("boolean")
)
Si el origen usa valores de texto, mapéalos explícitamente.
boolean_map = {
"Y": True,
"N": False,
}
mapped = df["is_active"].map(boolean_map)
invalid = df.loc[
df["is_active"].notna()
& mapped.isna()
]
print(invalid)
Después:
df["is_active"] = (
mapped.astype("boolean")
)
No uses la veracidad de Python (truthiness) para convertir cadenas arbitrarias.
Por ejemplo:
bool("False")
es True porque la cadena no está vacía.
9. Convertir fechas y marcas de tiempo
parsed_time = pd.to_datetime(
df["event_time"],
errors="coerce",
utc=True,
)
Inspecciona los fallos:
failed = df.loc[
df["event_time"].notna()
& parsed_time.isna()
]
print(failed)
Después asigna:
df["event_time"] = parsed_time
Usa utc=True solo cuando la normalización a UTC coincida con la semántica del origen.
10. Analizar explícitamente un formato de fecha y hora conocido
df["event_date"] = pd.to_datetime(
df["event_date"],
format="%Y-%m-%d",
errors="coerce",
)
Los formatos explícitos mejoran la claridad y facilitan detectar cambios inesperados en el origen.
11. Convertir texto al dtype string de pandas
df["customer_name"] = (
df["customer_name"]
.astype("string")
)
Para columnas de texto, prefiere el dtype string de pandas frente al object genérico cuando sea práctico.
Ofrece un comportamiento más coherente ante valores faltantes.
12. Convertir texto de baja cardinalidad a categórico
df["status"] = (
df["status"]
.astype("category")
)
Esto puede reducir la memoria usada por valores categóricos repetidos.
Buenos candidatos:
- estado
- código de país
- canal
- tipo de producto
Malos candidatos:
- identificadores únicos
- texto libre
- referencias de transacción de alta cardinalidad
Mide en lugar de suponer un beneficio de memoria.
13. Definir un tipo categórico ordenado
from pandas.api.types import CategoricalDtype
priority_type = CategoricalDtype(
categories=[
"low",
"medium",
"high",
"critical",
],
ordered=True,
)
df["priority"] = (
df["priority"]
.astype(priority_type)
)
Ahora la ordenación respeta el orden de negocio en lugar del orden alfabético.
14. Comprobar qué columnas tienen el dtype genérico object
object_cols = (
df.select_dtypes(include="object")
.columns
)
print(object_cols.tolist())
object puede ocultar:
- cadenas
- objetos de Python
- valores mixtos
- tipos de origen incoherentes
Inspecciona estas columnas de forma deliberada.
15. Detectar tipos de valores de Python mezclados en una columna
type_counts = (
df["value"]
.dropna()
.map(type)
.value_counts()
)
print(type_counts)
Es útil cuando una columna object se comporta de forma incoherente.
La salida podría revelar, por ejemplo, una mezcla de:
str
int
float
Normalmente es una señal de que hay que normalizar los datos de origen.
16. Encontrar valores que fallan en la conversión numérica
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)
)
Úsalo para identificar patrones como:
- símbolos de moneda
- comas
- etiquetas de texto
- valores centinela
- entradas mal formadas
17. Eliminar un formato conocido antes de la conversión numérica
Ejemplos de valores de origen:
"$1,250.50"
"$99.00"
Normaliza explícitamente:
clean_amount = (
df["amount"]
.astype("string")
.str.replace("$", "", regex=False)
.str.replace(",", "", regex=False)
)
parsed_amount = pd.to_numeric(
clean_amount,
errors="coerce",
)
No elimines caracteres a ciegas a menos que se trate de un formato documentado.
18. Convertir cadenas de porcentaje
Ejemplo:
"15.5%"
"8%"
Analiza:
pct = (
df["discount_pct"]
.astype("string")
.str.rstrip("%")
)
df["discount_rate"] = (
pd.to_numeric(
pct,
errors="coerce",
)
/ 100
)
Resultado:
15.5% -> 0.155
Haz explícita la unidad en el nombre de la columna de salida.
19. Convertir con cuidado flotantes con valor entero
Supongamos que:
1.0
2.0
NaN
deben representar recuentos enteros.
Valida primero:
values = pd.to_numeric(
df["quantity"],
errors="coerce",
)
non_integer = values.loc[
values.notna()
& (values % 1 != 0)
]
print(non_integer)
Si no hay ninguno:
df["quantity"] = (
values.astype("Int64")
)
No trunques los decimales de forma silenciosa.
20. Convertir las claves de ambos lados antes de un merge
Inspecciona primero:
print(left["customer_id"].dtype)
print(right["customer_id"].dtype)
Normaliza de forma coherente:
left["customer_id"] = (
left["customer_id"]
.astype("string")
)
right["customer_id"] = (
right["customer_id"]
.astype("string")
)
Si el formato puede diferir:
left["customer_id"] = (
left["customer_id"]
.str.strip()
)
right["customer_id"] = (
right["customer_id"]
.str.strip()
)
Normaliza las mayúsculas y minúsculas o el formato solo cuando la semántica del identificador lo permita.
21. Convertir con un mapa de esquema
Para esquemas conocidos:
schema = {
"order_id": "string",
"customer_id": "string",
"quantity": "Int64",
"amount": "Float64",
"is_active": "boolean",
}
df = df.astype(schema)
Úsalo solo cuando los valores ya sean compatibles.
Si los datos sin procesar pueden contener texto no válido, analiza primero esas columnas.
22. Validar los dtypes resultantes
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 validación de esquemas es útil en pipelines de ingesta de producción.
Para sistemas más grandes, usa un framework dedicado de validación de esquemas o de datos.
23. Comparar la memoria antes y después de la conversión
before = df.memory_usage(
deep=True
).sum()
Convierte:
df["status"] = (
df["status"]
.astype("category")
)
Vuelve a medir:
after = df.memory_usage(
deep=True
).sum()
print("Before:", before)
print("After:", after)
Usa mediciones reales antes de adoptar cambios de dtype solo por motivos de memoria.
24. Evitar la coerción genérica insegura
Esto es conciso:
df["value"] = pd.to_numeric(
df["value"],
errors="coerce",
)
Pero todo valor no válido se convierte en faltante.
Mide siempre el impacto:
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,
)
Los nuevos nulos inesperados son una señal de calidad de datos.
25. Convertir varias columnas de forma coherente
numeric_cols = [
"amount",
"tax",
"discount",
]
for col in numeric_cols:
df[col] = pd.to_numeric(
df[col],
errors="coerce",
)
En pipelines de producción, registra el número de fallos de conversión por columna antes de la asignación.
26. Conservar la precisión decimal cuando importa la aritmética exacta
El punto flotante binario no es adecuado para todos los cálculos financieros.
Para una semántica decimal exacta:
from decimal import Decimal
df["amount_decimal"] = (
df["amount_text"]
.map(
lambda x: (
Decimal(x)
if pd.notna(x)
else None
)
)
)
Esto produce objetos de Python y es más lento que los dtypes numéricos nativos.
Para cargas analíticas grandes, considera usar un motor de almacenamiento o ejecución con tipos decimales nativos en lugar de depender de columnas de pandas con objetos Decimal de Python.
Qué significa el resultado
| dtype / función | Significado |
|---|---|
object |
Almacenamiento genérico de objetos de Python; a menudo cadenas o valores mixtos. |
string |
Dtype de cadena nullable de pandas. |
Int64 |
Dtype de entero de 64 bits nullable de pandas. |
Float64 |
Dtype de punto flotante nullable de pandas. |
boolean |
Dtype booleano nullable de pandas. |
category |
Valores categóricos codificados, útiles para datos repetidos de baja cardinalidad. |
datetime64[ns] |
Fecha y hora de pandas/NumPy sin zona horaria. |
datetime64[ns, UTC] |
Fecha y hora con zona horaria, en UTC. |
astype() |
Conversión explícita; por lo general espera valores compatibles. |
convert_dtypes() |
Infiere los dtypes nullable de pandas adecuados. |
pd.to_numeric() |
Analiza valores numéricos con un manejo de errores configurable. |
pd.to_datetime() |
Analiza fechas y marcas de tiempo. |
La distinción más importante es:
tipo de almacenamiento != significado de negocio
Un valor con aspecto de entero puede seguir siendo un identificador.
Una cadena puede representar en realidad una marca de tiempo.
Las decisiones de tipos deben seguir el contrato de datos.
Qué revisar
Un identificador se volvió numérico
Comprueba si se perdieron ceros a la izquierda.
Si es así, recupera los datos del origen original si es posible y léelos como texto la próxima vez.
La conversión numérica crea nuevos nulos
Esos valores no se pudieron analizar.
Inspecciónalos antes de continuar.
Una columna de enteros se vuelve flotante
Suele ocurrir cuando datos enteros de NumPy deben representar valores faltantes.
Usa el dtype nullable Int64 de pandas cuando deba conservarse la semántica de entero.
La conversión booleana se comporta de forma extraña
Los valores de texto como:
"False"
"0"
"N"
deben mapearse explícitamente.
No dependas de la veracidad de Python.
Las claves del merge tienen dtypes distintos
Normaliza ambos lados antes de hacer merge.
Inspecciona también las diferencias de formato.
El uso de memoria es inesperadamente alto
Revisa:
- las columnas
object - las cadenas repetidas
- los tipos numéricos de precisión innecesariamente alta
- las columnas que podrían ser categóricas sin riesgo
Mide antes y después de los cambios.
convert_dtypes() elige un resultado inesperado
Infiere a partir de los valores observados, no de tu contrato de negocio.
Sobrescribe explícitamente el tipo de las columnas importantes.
Notas de producción
El esquema debe ser explícito en los límites del sistema
Define los tipos esperados al leer:
- CSV
- API
- extracciones de SQL
- cargas útiles de mensajes
- archivos externos
No dependas solo de la inferencia.
Los fallos de conversión son métricas de calidad de datos
Haz seguimiento de:
- el número de análisis numéricos fallidos
- el número de fechas fallidas
- los códigos booleanos no válidos
- los valores de categoría inesperados
No deben desaparecer de forma silenciosa.
Los dtypes nullable son útiles, pero no idénticos a los dtypes de NumPy
Ejemplos:
Int64 != int64
Float64 != float64
boolean != bool
Los dtypes de extensión nullable de pandas gestionan los valores faltantes de otra manera.
Prueba la compatibilidad posterior al exportar o al integrarte con otras bibliotecas.
astype() puede lanzar errores con valores no válidos
A menudo es lo deseable en pipelines controlados.
Si se esperan datos sin procesar mal formados, analiza primero, inspecciona los fallos y después convierte.
Las categorías necesitan una semántica estable
Un dtype categórico es útil para datos de baja cardinalidad, pero las categorías pueden diferir entre DataFrames.
Ten cuidado al:
- concatenar categóricos
- comparar categorías ordenadas
- escribir en sistemas externos
La conversión de tipos puede cambiar los valores
Ejemplos:
- de flotantes a enteros puede truncar o fallar
- las marcas de tiempo pueden desplazarse durante la conversión de zona horaria
- de cadenas a números puede perder el formato
- los flotantes binarios pueden introducir efectos de precisión
Valida antes y después.
Las conversiones grandes asignan memoria
Convertir una columna grande puede crear un nuevo array.
En cargas de trabajo con memoria limitada:
- convierte solo las columnas necesarias
- evita conversiones repetidas
- libera los objetos intermedios que no uses
- considera procesar antes, en SQL o Spark, cuando sea apropiado
Errores comunes
1. Tratar los identificadores como números
Los identificadores son etiquetas, no cantidades.
Mantenlos como cadenas a menos que la aritmética tenga sentido.
2. Usar astype(int) con datos nullable
Puede fallar cuando existen valores faltantes.
Usa el dtype nullable Int64 cuando corresponda.
3. Usar errors="coerce" sin comprobar los fallos
Puede convertir valores de origen erróneos en valores faltantes silenciosos.
Haz seguimiento de los nulos recién creados.
4. Suponer que object significa cadena
Una columna object puede contener tipos de Python mezclados.
Inspecciona los valores reales.
5. Usar bool() con texto
Es incorrecto para valores como:
bool("False") # True
Mapea explícitamente los valores de origen.
6. Convertir importes monetarios a float sin tener en cuenta la precisión
El punto flotante binario puede no ser adecuado para cálculos financieros exactos.
Elige el modelo numérico según los requisitos.
7. Usar convert_dtypes() como contrato de esquema completo
Es una ayuda para la inferencia, no un sustituto de un esquema de negocio explícito.
8. Convertir las claves del merge por separado sin comprobar su semántica
Dos columnas pueden convertirse ambas en cadenas y aun así no coincidir debido a:
- espacios en blanco
- ceros a la izquierda
- mayúsculas y minúsculas
- reglas de formato
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.