0Pricing
Pandas & NumPy Academy · Aula

Conversão de tipos com astype()

Converta colunas para int, float, string, boolean e datetime usando astype() e trate erros comuns de conversão.

Conversão de tipos com astype() é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

Introdução a astype()

Series.astype(dtype) converte uma coluna do tipo atual para o tipo especificado. Ele retorna uma nova Series (ou um DataFrame quando chamado em um DataFrame completo) sem modificar o original. Esta é a principal ferramenta do Pandas para corrigir problemas de tipos de dados após o carregamento dos dados, e ela pode converter entre tipos numéricos, para textos, para valores booleanos e para o 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

Convertendo para tipos numéricos

A conversão mais comum é de object para um tipo numérico. Você pode converter para 'int64', 'int32', 'float64', 'float32' etc. Se algum valor da coluna não puder ser convertido, astype() gera um ValueError. Use pd.to_numeric(series, errors='coerce') quando a coluna puder conter textos não numéricos — essa função converte valores inválidos em NaN em vez de interromper a execução.

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

Convertendo para texto (object)

Converter uma coluna para str (ou 'object') transforma cada valor em sua representação textual. Isso é útil quando você precisa concatenar uma coluna numérica com uma coluna de texto ou quando deseja aplicar métodos de texto a dados numéricos, como preencher IDs com zeros à esquerda. O Pandas também oferece o tipo de dados mais recente 'string', que proporciona um tratamento melhor de NA em colunas 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

Convertendo para booleano

A conversão para booleano é útil quando as colunas armazenam Verdadeiro/Falso como inteiros (0/1) ou como textos ('Yes'/'No'). Converter inteiros 0/1 com astype(bool) funciona diretamente: 0 se torna False e qualquer valor diferente de zero se torna True. Para colunas de texto 'Yes'/'No', aplique primeiro map com um dicionário e depois faça a conversão.

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

Reduzindo o tamanho dos tipos numéricos

Por padrão, o Pandas usa tipos de 64 bits. Se seus valores inteiros couberem em 32 ou até 8 bits, você poderá fazer um downcast para um tipo menor e reduzir o uso de memória pela metade (ou para um quarto). Use pd.to_numeric(series, downcast='integer') ou faça a conversão explicitamente com astype('int32'). Essa é uma otimização essencial para conjuntos de dados 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)

Convertendo DataFrames completos com astype(dict)

Você pode converter várias colunas de uma só vez passando um dicionário para df.astype(), em que as chaves são os nomes das colunas e os valores são os tipos de dados desejados. Isso é mais organizado do que encadear atribuições de colunas individuais e torna a etapa de conversão de tipos autoexplicativa como um único bloco no fluxo de processamento.

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

Tratando erros em astype()

astype() não tem um modo integrado tolerante a erros (ao contrário de pd.to_numeric). Se uma conversão falhar, ele gera um ValueError ou OverflowError. O fluxo de trabalho seguro é: (1) limpar primeiro a coluna (remover símbolos, preencher NaN) e (2) depois fazer a conversão. Como alternativa, use pd.to_numeric(errors='coerce') para dados numéricos ou escreva uma pequena função auxiliar que capture os erros de conversão.

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

Convertendo para o StringDtype do Pandas

O tipo de dados mais recente 'string' (a variante com S maiúsculo ou pd.StringDtype()) foi introduzido para oferecer suporte completo a textos, com tratamento adequado de NA — ele armazena textos ausentes como pd.NA, em vez de None ou np.nan. Ele habilita o acessador .str e preserva melhor a semântica de NA do que o tipo de dados object, sendo recomendado para códigos novos destinados ao Pandas 2 ou superior.

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

Riscos de estouro ao reduzir o tamanho dos tipos

Ao reduzir o tamanho para um tipo inteiro menor, valores que excedem o intervalo do tipo sofrem estouro silenciosamente e dão a volta no intervalo. Por exemplo, converter 300 para int8 (intervalo de -128 a 127) produz 44 sem gerar um erro. Sempre verifique se o intervalo real dos seus dados cabe no tipo de destino antes de reduzir seu tamanho, para evitar corrupção sutil dos dados.

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

Verificando conversões com um mapa de tipos de dados

Depois de realizar várias conversões de tipos, valide o esquema final comparando os tipos de dados reais com um mapa esperado. Esse padrão de asserção detecta erros como uma coluna que não foi convertida (por exemplo, porque NaN impediu a conversão para inteiro). Execute essas verificações no final da função de carregamento de dados como um teste leve do 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')

Exemplo completo de fluxo de conversão

Reunindo tudo: aqui está um fluxo de conversão realista após read_csv que limpa a formatação, trata NaN com segurança, converte para tipos ideais e valida o resultado. Esse padrão — limpar, converter e validar — deve fazer parte de toda função de ingestão de dados.

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

Verificação rápida

Teste sua compreensão sobre conversões com astype().

Recapitulação da lição

Nesta lição, você aprendeu que astype(dtype) converte uma coluna ou um DataFrame inteiro para um novo tipo, que pd.to_numeric(errors='coerce') é mais seguro para colunas com textos não numéricos e que passar um dicionário para astype() converte várias colunas de uma só vez. Faça a redução de tamanho com cuidado para evitar estouros e sempre valide o esquema final com asserções. A seguir, exploraremos o tipo de dados Categorical, eficiente em termos de memória.

Perguntas Frequentes

A aula “Conversão de tipos com astype()” é grátis?

Sim — o texto completo de “Conversão de tipos com astype()” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “Conversão de tipos com astype()”?

Converta colunas para int, float, string, boolean e datetime usando astype() e trate erros comuns de conversão. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Conversão de tipos com astype()”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Inspecionando os tipos de dados das colunas
  2. Conversão de tipos com astype()
  3. Tipo de dados categórico
  4. Analisando datas corretamente
← Voltar para Pandas & NumPy Academy