Explorar guías rápidas · Python

Tecnología: PythonCategoría: Limpieza de datosNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Inspeccionar los tipos de datos de un DataFrame
  5. 2. Convertir a dtypes nullable de pandas
  6. 3. Convertir una columna explícitamente con astype()
  7. 4. Conservar los identificadores como cadenas
  8. 5. Convertir texto numérico de forma segura
  9. 6. Convertir a enteros nullable
  10. 7. Convertir a flotantes nullable
  11. 8. Convertir a booleanos nullable
  12. 9. Convertir fechas y marcas de tiempo
  13. 10. Analizar explícitamente un formato de fecha y hora conocido
  14. 11. Convertir texto al dtype string de pandas
  15. 12. Convertir texto de baja cardinalidad a categórico
  16. 13. Definir un tipo categórico ordenado
  17. 14. Comprobar qué columnas tienen el dtype genérico object
  18. 15. Detectar tipos de valores de Python mezclados en una columna
  19. 16. Encontrar valores que fallan en la conversión numérica
  20. 17. Eliminar un formato conocido antes de la conversión numérica
  21. 18. Convertir cadenas de porcentaje
  22. 19. Convertir con cuidado flotantes con valor entero
  23. 20. Convertir las claves de ambos lados antes de un merge
  24. 21. Convertir con un mapa de esquema
  25. 22. Validar los dtypes resultantes
  26. 23. Comparar la memoria antes y después de la conversión
  27. 24. Evitar la coerción genérica insegura
  28. 25. Convertir varias columnas de forma coherente
  29. 26. Conservar la precisión decimal cuando importa la aritmética exacta
  30. Qué significa el resultado
  31. Qué revisar
  32. Un identificador se volvió numérico
  33. La conversión numérica crea nuevos nulos
  34. Una columna de enteros se vuelve flotante
  35. La conversión booleana se comporta de forma extraña
  36. Las claves del merge tienen dtypes distintos
  37. El uso de memoria es inesperadamente alto
  38. convert_dtypes() elige un resultado inesperado
  39. Notas de producción
  40. El esquema debe ser explícito en los límites del sistema
  41. Los fallos de conversión son métricas de calidad de datos
  42. Los dtypes nullable son útiles, pero no idénticos a los dtypes de NumPy
  43. astype() puede lanzar errores con valores no válidos
  44. Las categorías necesitan una semántica estable
  45. La conversión de tipos puede cambiar los valores
  46. Las conversiones grandes asignan memoria
  47. Errores comunes
  48. 1. Tratar los identificadores como números
  49. 2. Usar astype(int) con datos nullable
  50. 3. Usar errors="coerce" sin comprobar los fallos
  51. 4. Suponer que object significa cadena
  52. 5. Usar bool() con texto
  53. 6. Convertir importes monetarios a float sin tener en cuenta la precisión
  54. 7. Usar convert_dtypes() como contrato de esquema completo
  55. 8. Convertir las claves del merge por separado sin comprobar su semántica
  56. Siguiente paso
  57. 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", 0 o 1
  • 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

Siguiente paso

Usa el problema de tipos detectado para decidir qué hacer a continuación.

  • Fallos en el análisis numérico → inspecciona los valores sin procesar y define reglas de limpieza.
  • Las fechas siguen siendo cadenas → analízalas con reglas de fecha y hora explícitas.
  • Los identificadores perdieron su formato → vuelve a cargarlos desde el origen con el dtype string si es posible.
  • Los enteros nullable se convirtieron en flotantes → pasa al dtype Int64 de pandas.
  • Los booleanos proceden de códigos o texto → mapea explícitamente los valores de origen permitidos.
  • Las claves del merge no coinciden → normaliza el dtype y el formato en ambos lados.
  • Las columnas object dominan el uso de memoria → evalúa si string o category es adecuado.
  • El esquema es crítico para el negocio → agrega una validación de esquema explícita en la ingesta.
  • Las conversiones son costosas con datos muy grandes → acerca el tipado al origen de datos o a un motor de ejecución distribuido.

← Todas las guías rápidas