R Academy · Aula

Conversão lógica e de caracteres

Converta entre valores lógicos, de caracteres e numéricos com as.logical() e as.character().

Conversão lógica e de caracteres é uma aula grátis de R Academy no CoddyKit. Esta é a aula 3 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 R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Conversão entre Tipos

O R fornece funções as.*() para converter entre todos os tipos básicos. Esta lição aborda conversões entre os tipos logical, character e numeric — as conversões de ida e volta mais comuns que você encontrará na limpeza de dados.

# Quick overview of as.*() functions
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.numeric(TRUE): ', as.numeric(TRUE), '
')  # 1
cat('as.character(3.14):', as.character(3.14), '
') # "3.14"
cat('as.logical("TRUE"):', as.logical('TRUE'), '
') # TRUE

De Numérico para Lógico

Ao converter um número para lógico: 0 se torna FALSE e qualquer número diferente de zero se torna TRUE. Essa regra se aplica tanto a integers quanto a doubles.

cat('as.logical(0):    ', as.logical(0), '
')     # FALSE
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.logical(-5):   ', as.logical(-5), '
')    # TRUE (non-zero)
cat('as.logical(0.001):', as.logical(0.001), '
') # TRUE (non-zero)
cat('as.logical(0L):   ', as.logical(0L), '
')    # FALSE
cat('as.logical(3L):   ', as.logical(3L), '
')    # TRUE

De Lógico para Numérico

TRUE é convertido em 1 e FALSE em 0. Essa conversão está na base de muitos padrões idiomáticos do R, como usar sum() para contar valores TRUE ou mean() para calcular proporções.

cat('as.numeric(TRUE):  ', as.numeric(TRUE), '
')   # 1
cat('as.numeric(FALSE): ', as.numeric(FALSE), '
')  # 0
cat('as.integer(TRUE):  ', as.integer(TRUE), '
')   # 1L

# Practical use: count TRUEs by summing
passed <- c(TRUE, FALSE, TRUE, TRUE, FALSE, TRUE)
cat('Passed count:', sum(as.numeric(passed)), '
')  # 4
cat('Pass rate:   ', mean(passed) * 100, '%
')      # 66.67%

as.logical() a partir de Textos

as.logical('TRUE') e as.logical('FALSE') convertem representações em texto. O R também aceita 'T' e 'F' como abreviações. Qualquer outra coisa (incluindo 'true' em minúsculas) retorna NA.

cat('as.logical("TRUE"):  ', as.logical('TRUE'), '
')   # TRUE
cat('as.logical("FALSE"): ', as.logical('FALSE'), '
')  # FALSE
cat('as.logical("T"):     ', as.logical('T'), '
')      # TRUE
cat('as.logical("F"):     ', as.logical('F'), '
')      # FALSE
cat('as.logical("yes"):   ', as.logical('yes'), '
')    # NA (not recognised)
cat('as.logical("true"):  ', as.logical('true'), '
')   # NA (case-sensitive!)

De Numérico para Texto

as.character(x) converte um número para sua representação em texto. Isso é útil para criar rótulos e IDs ou quando você precisa inserir números em textos.

num_val <- 3.14159
char_val <- as.character(num_val)
cat('as.character(3.14159):', char_val, '
')  # '3.14159'
cat('class:', class(char_val), '
')           # character

# Building labels
ids <- 1:5
labels <- paste0('Item_', as.character(ids))
cat('Labels:', labels, '
')

De Texto para Numérico

as.numeric('3.14') interpreta um texto e o transforma em um valor double. Se o texto não puder ser interpretado como um número, o R retornará NA com um aviso. Sempre valide a entrada antes da conversão em código de produção.

cat('as.numeric("3.14"):  ', as.numeric('3.14'), '
')   # 3.14
cat('as.numeric("100"):   ', as.numeric('100'), '
')    # 100
cat('as.numeric("-5.5"):  ', as.numeric('-5.5'), '
')   # -5.5
cat('as.numeric("abc"):   ', as.numeric('abc'), '
')    # NA with warning
cat('as.numeric("1e3"):   ', as.numeric('1e3'), '
')    # 1000 (sci notation OK)

De Lógico para Texto

as.character(TRUE) produz o texto 'TRUE'. Isso é útil quando você precisa incluir valores lógicos em uma saída de texto, em exportações de arquivos ou em concatenações de textos.

flag_t <- TRUE
flag_f <- FALSE

cat('as.character(TRUE): ', as.character(flag_t), '
')  # 'TRUE'
cat('as.character(FALSE):', as.character(flag_f), '
')  # 'FALSE'
cat('class:', class(as.character(flag_t)), '
')         # character

# In paste()
message <- paste('System status:', as.character(flag_t))
cat(message, '
')

Conversão de Ida e Volta

A maioria das conversões é reversível (de ida e volta), mas pode haver alguma perda: numeric -> character -> numeric pode perder precisão dependendo de como o número é formatado como texto.

original <- 3.141592653589793
char_version <- as.character(original)
back_to_num <- as.numeric(char_version)

cat('Original:  ', original, '
')
cat('As string: ', char_version, '
')
cat('Back:      ', back_to_num, '
')
cat('Identical?:', identical(original, back_to_num), '
')
cat('Equal?:    ', original == back_to_num, '
')

Convertendo Vetores de Origem Mista

Ao aplicar as.numeric() a um vetor de caracteres, cada elemento é convertido de forma independente. Os elementos que não puderem ser interpretados se tornam NA. Essa é a maneira padrão de limpar dados com aparência numérica lidos de arquivos CSV.

# Simulated data from CSV (all read as character)
raw_data <- c('42', '37.5', 'N/A', '55', '', '28.0')
cat('Raw character data:', raw_data, '
')

numeric_data <- suppressWarnings(as.numeric(raw_data))
cat('Converted:         ', numeric_data, '
')  # 42 37.5 NA 55 NA 28
cat('NA count:          ', sum(is.na(numeric_data)), '
')

Conversão Lógica em ifelse()

Combinar as.numeric() com ifelse() ou multiplicar diretamente por um vetor lógico é um padrão idiomático comum para pontuação condicional ou engenharia de atributos na análise de dados.

# Score: 1 for correct, 0 for incorrect
quiz_answers <- c('A', 'C', 'B', 'D', 'B')
correct      <- c('A', 'B', 'B', 'D', 'C')

is_correct <- quiz_answers == correct
cat('Correct:  ', is_correct, '
')
cat('As 0/1:   ', as.numeric(is_correct), '
')
cat('Score:    ', sum(is_correct), '/', length(is_correct), '
')

Resumo das Conversões

Aqui está um resumo das principais conversões lógicas e de caracteres:

as.logical(0) → FALSE; qualquer valor diferente de zero → TRUE
as.logical('TRUE'/'T') → TRUE; diferencia maiúsculas de minúsculas; outros valores → NA
as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
as.character(x) → representação em texto de x
as.numeric('3.14') → 3.14; textos não numéricos → NA com aviso

# All conversions in one snippet
cat('logical->num:  ', as.numeric(c(TRUE, FALSE)), '
')
cat('num->logical:  ', as.logical(c(0, 1, -1, 0.5)), '
')
cat('char->num:     ', suppressWarnings(as.numeric(c('5', 'abc', '3.1'))), '
')
cat('char->logical: ', as.logical(c('TRUE', 'FALSE', 'yes')), '
')
cat('logical->char: ', as.character(c(TRUE, FALSE)), '
')

Verificação Rápida

Qual é o resultado de as.numeric(TRUE) + as.numeric(FALSE) no R?

Recapitulação: Conversão Lógica e de Caracteres

Excelente! Principais aprendizados desta lição:

as.logical(0) → FALSE; diferente de zero → TRUE; 'TRUE'/'T' → TRUE
as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
as.character(x) converte qualquer valor para sua forma textual
as.numeric('3.14') interpreta um texto numérico; textos inválidos → NA
as.logical('true') é NA — a correspondência diferencia maiúsculas de minúsculas ('TRUE' funciona)
As conversões são, em sua maioria, reversíveis; use suppressWarnings() ao converter colunas com entradas que devem produzir NA

# Practical: parse a messy survey score column
raw_scores <- c('8', '7', 'N/A', '9', 'skip', '6')
numeric_scores <- suppressWarnings(as.numeric(raw_scores))
cat('Parsed:', numeric_scores, '
')
cat('Valid responses:', sum(!is.na(numeric_scores)), '
')
cat('Average score:  ', round(mean(numeric_scores, na.rm = TRUE), 2), '
')

Perguntas Frequentes

A aula “Conversão lógica e de caracteres” é grátis?

Sim — o texto completo de “Conversão lógica e de caracteres” é 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 R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Conversão lógica e de caracteres”?

Converta entre valores lógicos, de caracteres e numéricos com as.logical() e as.character(). Você pratica R 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 R Academy?

Nenhuma experiência prévia é necessária. R 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 3 de 4.

Quanto tempo leva a aula “Conversão lógica e de caracteres”?

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 R Academy?

Sim. Cada aula de R 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

← Voltar para R Academy