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 worksConversió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.5Conversió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_NConversió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 FalseReducció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 boolGestió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.0Conversió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 FalseRiesgos 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 hereVerificació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 boolComprobació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
- Inspeccionar los tipos de datos de las columnas
- Conversión de tipos con astype()
- Tipo de datos categórico
- Analizar fechas correctamente