0Pricing
Pandas & NumPy Academy · Lección

Conversión de tipos con astype()

Convierta columnas a int, float, string, boolean y datetime mediante astype() y gestione los errores de conversión habituales.

Conversión de tipos con astype() es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

Introducción a astype()

Series.astype(dtype) convierte una columna de su tipo actual al tipo que especifique. Devuelve una nueva Series (o un DataFrame cuando se llama sobre un DataFrame completo) sin modificar el original. Es la herramienta principal de Pandas para corregir problemas de tipos después de cargar datos y permite convertir entre tipos numéricos, a cadenas, a booleanos y al tipo Categorical.

import pandas as pd

df = pd.DataFrame({'age': ['25', '30', '35']})
print('Before:', df['age'].dtype)  # object

df['age'] = df['age'].astype(int)
print('After:', df['age'].dtype)   # int64
print(df['age'] + 1)               # [26, 31, 36] — arithmetic now works

Conversión a tipos numéricos

La conversión más habitual es de object a un tipo numérico. Puede convertir a 'int64', 'int32', 'float64', 'float32', etc. Si algún valor de la columna no se puede convertir, astype() genera un ValueError. Use pd.to_numeric(series, errors='coerce') cuando la columna pueda contener cadenas no numéricas: convierte los valores incorrectos en NaN en lugar de producir un error.

import pandas as pd

df = pd.DataFrame({'price': ['10.5', '20.0', 'N/A', '30.5']})

# astype would crash on 'N/A'
# price_float = df['price'].astype(float)  # ValueError!

# pd.to_numeric with errors='coerce' is safer
df['price_float'] = pd.to_numeric(df['price'], errors='coerce')
print(df)
#   price  price_float
# 0  10.5         10.5
# 1  20.0         20.0
# 2   N/A          NaN
# 3  30.5         30.5

Conversión a cadenas (object)

Convertir una columna a str (o 'object') transforma cada valor en su representación de cadena. Esto resulta útil cuando necesita concatenar una columna numérica con una columna de texto o aplicar métodos de cadenas a datos numéricos, como rellenar con ceros los identificadores. Pandas también dispone del tipo de datos más reciente 'string', que ofrece una mejor gestión de los valores NA en las columnas de texto.

import pandas as pd

df = pd.DataFrame({'id': [1, 2, 3], 'region': ['E', 'W', 'N']})

# Concatenate id and region into a composite key
df['key'] = df['id'].astype(str) + '_' + df['region']
print(df)
#    id region  key
# 0   1      E  1_E
# 1   2      W  2_W
# 2   3      N  3_N

Conversión a booleanos

La conversión a booleanos resulta útil cuando las columnas almacenan True/False como enteros (0/1) o como cadenas ('Yes'/'No'). Convertir enteros 0/1 con astype(bool) funciona directamente: 0 se convierte en False y cualquier valor distinto de cero, en True. Para las columnas de cadenas 'Yes'/'No', aplique primero un diccionario de mapeo y, después, realice la conversión.

import pandas as pd

df = pd.DataFrame({
    'active_int': [1, 0, 1, 0],
    'active_str': ['Yes', 'No', 'Yes', 'No']
})

# Integer to bool
df['active_bool'] = df['active_int'].astype(bool)

# String to bool via mapping
df['active_bool2'] = df['active_str'].map({'Yes': True, 'No': False})

print(df[['active_bool', 'active_bool2']])
#    active_bool  active_bool2
# 0         True          True
# 1        False         False

Reducción del tamaño de los tipos numéricos

De forma predeterminada, Pandas utiliza tipos de 64 bits. Si los valores enteros caben en 32 o incluso 8 bits, puede hacer un downcast a un tipo más pequeño para reducir a la mitad (o a una cuarta parte) el uso de memoria. Use pd.to_numeric(series, downcast='integer') o convierta explícitamente con astype('int32'). Esta es una optimización clave para conjuntos de datos grandes.

import pandas as pd
import numpy as np

df = pd.DataFrame({'count': np.random.randint(0, 200, 1_000_000)})

print('int64 bytes:', df['count'].nbytes)   # 8,000,000

df['count_int16'] = df['count'].astype('int16')  # max 32767, fits 0-200
print('int16 bytes:', df['count_int16'].nbytes)  # 2,000,000

# Or let Pandas choose the smallest type automatically
df['count_auto'] = pd.to_numeric(df['count'], downcast='integer')
print('auto dtype:', df['count_auto'].dtype)

Conversión de DataFrames completos con astype(dict)

Puede convertir varias columnas a la vez pasando un diccionario a df.astype(), donde las claves son los nombres de las columnas y los valores son los tipos de datos de destino. Esto es más claro que encadenar asignaciones de columnas individuales y hace que el paso de conversión de tipos quede documentado por sí mismo como un único bloque de la canalización.

import pandas as pd

df = pd.DataFrame({
    'age': ['25', '30'],
    'salary': ['50000', '70000'],
    'is_manager': ['1', '0']
})

df = df.astype({
    'age': 'int32',
    'salary': 'float64',
    'is_manager': 'bool'
})
print(df.dtypes)
# age           int32
# salary      float64
# is_manager     bool

Gestión de errores en astype()

astype() no dispone de un modo integrado tolerante a errores (a diferencia de pd.to_numeric). Si una conversión falla, genera un ValueError o un OverflowError. El procedimiento seguro es: (1) limpiar primero la columna (eliminar símbolos, rellenar NaN); (2) convertirla después. Como alternativa, use pd.to_numeric(errors='coerce') para valores numéricos o escriba una pequeña función auxiliar que capture los errores de conversión.

import pandas as pd

# Clean then cast pattern
df = pd.DataFrame({'price': ['$1,200', '$800', '$450']})

# Step 1: remove non-numeric characters
df['price_clean'] = (
    df['price']
    .str.replace('$', '', regex=False)
    .str.replace(',', '', regex=False)
)
# Step 2: safe cast
df['price_num'] = df['price_clean'].astype(float)
print(df)
#      price price_clean  price_num
# 0  $1,200        1200     1200.0
# 1    $800         800      800.0
# 2    $450         450      450.0

Conversión al tipo StringDtype de Pandas

El tipo de datos más reciente 'string' (la variante String con S mayúscula o pd.StringDtype()) se introdujo para ofrecer compatibilidad nativa con cadenas y una gestión adecuada de los valores NA: almacena las cadenas ausentes como pd.NA en lugar de None o np.nan. Permite usar el accesor .str y conserva mejor la semántica de NA que el tipo object, por lo que se recomienda para código nuevo destinado a Pandas 2 o versiones posteriores.

import pandas as pd

df = pd.DataFrame({'name': ['Alice', None, 'Carol']})

# Convert to the modern string dtype
df['name'] = df['name'].astype('string')
print(df['name'].dtype)   # string
print(df['name'].isna())  # proper NA detection
# 0    False
# 1     True
# 2    False

Riesgos de desbordamiento al reducir el tamaño

Al convertir a un tipo entero más pequeño, los valores que superan el rango del tipo sufren un desbordamiento silencioso y vuelven a aparecer dentro del rango. Por ejemplo, convertir 300 a int8 (rango de -128 a 127) produce 44 sin generar ningún error. Compruebe siempre que el rango real de los datos cabe en el tipo de destino antes de reducir su tamaño, para evitar una corrupción sutil de los datos.

import pandas as pd
import numpy as np

df = pd.DataFrame({'value': [100, 200, 300, 127, 128]})

# int8 range: -128 to 127
df['value_i8'] = df['value'].astype('int8')
print(df)
#    value  value_i8
# 0    100       100
# 1    200       -56   <- overflow! 200-256 = -56
# 2    300        44   <- overflow! 300-256 = 44
# 3    127       127
# 4    128      -128   <- overflow!

# Always check range first
print(df['value'].max())  # 300 > 127 — int8 is UNSAFE here

Verificación de conversiones con un mapa de tipos

Después de realizar varias conversiones de tipos, valide el esquema final comparando los tipos reales con un mapa esperado. Este patrón de aserción detecta errores como una columna que no se convirtió (por ejemplo, porque NaN impidió la conversión a entero). Ejecute estas comprobaciones al final de la función de carga de datos como una prueba ligera del esquema.

import pandas as pd

df = pd.DataFrame({
    'user_id': [1, 2, 3],
    'amount': [10.5, 20.0, 30.5],
    'active': [True, False, True]
})

expected = {'user_id': 'int64', 'amount': 'float64', 'active': 'bool'}

for col, dtype in expected.items():
    assert str(df[col].dtype) == dtype, (
        f'{col}: expected {dtype}, got {df[col].dtype}'
    )
print('Schema validation passed')

Ejemplo de una canalización de conversión completa

Para integrar todos los conceptos: a continuación se muestra una canalización realista de conversión posterior a read_csv que limpia el formato, gestiona NaN de forma segura, convierte a tipos óptimos y valida el resultado. Este patrón —limpiar, convertir y validar— debería formar parte habitual de toda función de ingesta de datos.

import pandas as pd

raw = pd.DataFrame({
    'user_id': ['101', '102', '103'],
    'revenue': ['$1,200', '$800', '$2,500'],
    'active': ['Yes', 'No', 'Yes']
})

df = (
    raw
    .assign(
        user_id=raw['user_id'].astype('int32'),
        revenue=pd.to_numeric(
            raw['revenue'].str.replace('[$,]', '', regex=True)
        ),
        active=raw['active'].map({'Yes': True, 'No': False})
    )
)
print(df.dtypes)
# user_id      int32
# revenue    float64
# active        bool

Comprobación rápida

Compruebe cuánto ha entendido sobre la conversión de tipos con astype().

Resumen de la lección

En esta lección ha aprendido que astype(dtype) convierte una columna o un DataFrame completo a un nuevo tipo, que pd.to_numeric(errors='coerce') es más seguro para columnas con cadenas no numéricas y que pasar un diccionario a astype() convierte varias columnas a la vez. Reduzca el tamaño de los tipos con cuidado para evitar desbordamientos y valide siempre el esquema final mediante aserciones. A continuación, exploraremos el tipo de datos Categorical, que permite ahorrar memoria.

Preguntas frecuentes

¿La lección «Conversión de tipos con astype()» es gratis?

Sí — el texto completo de «Conversión de tipos con astype()» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conversión de tipos con astype()»?

Convierta columnas a int, float, string, boolean y datetime mediante astype() y gestione los errores de conversión habituales. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Pandas & NumPy Academy?

No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Conversión de tipos con astype()»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?

Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Inspeccionar los tipos de datos de las columnas
  2. Conversión de tipos con astype()
  3. Tipo de datos categórico
  4. Analizar fechas correctamente
← Volver a Pandas & NumPy Academy