0Pricing
R Academy · Aula

Entendendo NA em R

Aprenda o que NA significa, por que se propaga e como difere de NULL.

Entendendo NA em R é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 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.

O que é NA no R?

NA significa Não disponível — representa um valor ausente ou desconhecido. Diferentemente de NULL (ausência de um objeto) ou NaN (não é um número), NA é um marcador para dados que existem, mas são desconhecidos.

# NA represents a missing value
height_cm <- c(175, NA, 162, 188, NA, 170)
cat('Heights:', height_cm, '
')
cat('Length:', length(height_cm), '
')  # NA counts as an element
cat('Sum:', sum(height_cm), '
')        # NA propagates

NA versus NULL

NA é um valor ausente dentro de um vector — a posição existe, mas não tem um valor conhecido. NULL é a ausência completa de um objeto — tem comprimento 0 e não pode ser armazenado dentro de um vector.

# NA: element exists, value unknown
vec_with_na <- c(1, NA, 3)
cat('Vector with NA, length:', length(vec_with_na), '
')  # 3

# NULL: nothing there at all
vec_with_null <- c(1, NULL, 3)
cat('Vector with NULL, length:', length(vec_with_null), '
')  # 2!

# NULL gets dropped; NA is kept
cat('vec_with_na:', vec_with_na, '
')
cat('vec_with_null:', vec_with_null, '
')

NA versus NaN

NaN (Não é um número) resulta de operações matematicamente indefinidas, como 0/0 ou sqrt(-1). É um valor numérico especial, enquanto NA é um marcador geral de valor ausente que pode ser aplicado a qualquer tipo.

# NaN from undefined operations
cat('0/0 =', 0/0, '
')          # NaN
cat('sqrt(-1) =', sqrt(-1), '
') # NaN (with warning)
cat('Inf - Inf =', Inf - Inf, '
') # NaN

# NaN IS also NA (a special case)
cat('is.nan(NaN):', is.nan(NaN), '
')
cat('is.na(NaN): ', is.na(NaN), '
')  # TRUE!
cat('is.nan(NA): ', is.nan(NA), '
')  # FALSE

NA versus infinito

Inf e -Inf representam o infinito positivo e negativo — eles resultam de operações como 1/0. Ao contrário de NA, Inf é um valor numérico conhecido, ainda que extremo, e participa normalmente de comparações.

cat('1/0 =', 1/0, '
')         # Inf
cat('-1/0 =', -1/0, '
')       # -Inf
cat('Inf + 1 =', Inf + 1, '
') # Inf
cat('Inf > 1000:', Inf > 1000, '
')  # TRUE
cat('is.infinite(Inf):', is.infinite(Inf), '
')
cat('is.na(Inf):       ', is.na(Inf), '
')  # FALSE

Propagação de NA na aritmética

NA é contagioso na aritmética: qualquer operação que envolva NA retorna NA. Isso é intencional — se um valor de um cálculo for desconhecido, o resultado também será desconhecido.

x <- NA
cat('NA + 5:  ', x + 5, '
')      # NA
cat('NA * 0:  ', x * 0, '
')      # NA (not 0!)
cat('NA == NA:', x == NA, '
')     # NA (not TRUE!)
cat('NA > 5:  ', x > 5, '
')      # NA
cat('sum(1,NA):', sum(1, NA), '
') # NA

typeof(NA) — NAs tipados

O NA padrão tem tipo logical. R fornece variantes tipadas de NA para cada tipo atômico. Elas são importantes ao trabalhar com vetores tipados, para evitar coerções de tipo não intencionais.

cat('typeof(NA):            ', typeof(NA), '
')           # logical
cat('typeof(NA_integer_):  ', typeof(NA_integer_), '
')   # integer
cat('typeof(NA_real_):     ', typeof(NA_real_), '
')      # double
cat('typeof(NA_complex_):  ', typeof(NA_complex_), '
')   # complex
cat('typeof(NA_character_):', typeof(NA_character_), '
') # character

NA_integer_ na prática

Ao criar um vetor de inteiros com um valor ausente, use NA_integer_ para manter o tipo do vetor consistente. Usar um NA simples causa coerção implícita para double em alguns contextos.

# Using plain NA in an integer vector
v1 <- c(1L, 2L, NA, 4L)
cat('typeof with NA:         ', typeof(v1), '
')  # integer (OK here)

# Explicit typed NA is safer in functions
v2 <- c(1L, 2L, NA_integer_, 4L)
cat('typeof with NA_integer_:', typeof(v2), '
')  # integer

# Check they behave the same
cat('Same?', identical(v1, v2), '
')

NA_real_ e NA_character_

NA_real_ é usado para valores ausentes em vetores double (numéricos), e NA_character_, para strings ausentes. Eles são especialmente importantes ao criar vetores dentro de funções nas quais a consistência de tipos é relevante.

# Character vector with missing
names_vec <- c('Alice', 'Bob', NA_character_, 'Dave')
cat('Names:', names_vec, '
')
cat('typeof:', typeof(names_vec), '
')

# Numeric with missing
readings <- c(22.5, NA_real_, 21.3, NA_real_, 24.1)
cat('Readings:', readings, '
')
cat('Non-NA count:', sum(!is.na(readings)), '
')

NA em operações lógicas

NA em operações lógicas segue a lógica trivalente: TRUE | NA é TRUE (porque TRUE OU qualquer coisa é TRUE), mas FALSE | NA é NA (não podemos determinar o resultado sem conhecer o valor de NA).

cat('TRUE  | NA:', TRUE | NA, '
')   # TRUE
cat('FALSE | NA:', FALSE | NA, '
')  # NA
cat('TRUE  & NA:', TRUE & NA, '
')   # NA
cat('FALSE & NA:', FALSE & NA, '
')  # FALSE

# Never use == to test for NA!
cat('NA == NA:', NA == NA, '
')    # NA (not TRUE!)
cat('is.na(NA):', is.na(NA), '
')  # TRUE (correct way)

NA em vetores e quadros de dados

Valores ausentes aparecem com frequência em dados do mundo real. Entender como NA se comporta ajuda você a interpretar corretamente resumos, identificar problemas de qualidade dos dados e escolher a estratégia adequada para tratá-los.

ages <- c(25, NA, 32, NA, 29, 41, NA, 35)
cat('Ages:', ages, '
')
cat('Length:', length(ages), '
')
cat('Missing count:', sum(is.na(ages)), '
')
cat('Present count:', sum(!is.na(ages)), '
')
cat('Mean (fails):', mean(ages), '
')           # NA
cat('Mean (works):', mean(ages, na.rm = TRUE), '
') # 32.4

Tipos de NA: uma visão completa

Aqui está um resumo dos valores especiais relacionados a NA em R:

  • NA — valor ausente genérico (tipo lógico)
  • NA_integer_, NA_real_, NA_complex_, NA_character_ — NAs tipados
  • NaN — número indefinido (resultado de 0/0, sqrt(-1))
  • Inf, -Inf — valores infinitos (resultado de 1/0)
  • NULL — ausência de um objeto (comprimento 0)
# Test functions for special values
x <- c(1, NA, NaN, Inf, -Inf, 0)
cat('Values:         ', x, '
')
cat('is.na():        ', is.na(x), '
')        # TRUE for NA and NaN
cat('is.nan():       ', is.nan(x), '
')       # TRUE only for NaN
cat('is.infinite():  ', is.infinite(x), '
')  # TRUE for Inf and -Inf
cat('is.finite():    ', is.finite(x), '
')    # TRUE only for normal numbers

Verificação rápida

Para qual valor NA == NA é avaliado em R?

Recapitulação: entendendo NA

Excelente! Principais aprendizados desta lição:

  • NA = valor ausente (sabe-se que existe, mas seu valor é desconhecido)
  • NULL = ausência de um objeto (removido dos vetores)
  • NaN = resultado aritmético indefinido (também é NA)
  • Inf / -Inf = valores infinitos (NÃO são NA)
  • NA é contagioso na aritmética — operações com NA retornam NA
  • Use NAs tipados (NA_integer_, etc.) para escrever código seguro quanto a tipos
  • Sempre teste a presença de NA com is.na(), nunca com == NA
# Key tests side by side
special_vals <- list(NA=NA, NaN=NaN, Inf=Inf, 'NULL-in-vec'=c(1,NULL,3)[2])
for (name in names(special_vals)) {
  v <- special_vals[[name]]
  cat(name, '| is.na:', is.na(v), '| is.nan:', is.nan(v[!is.infinite(v)]), '
')
}

Perguntas Frequentes

A aula “Entendendo NA em R” é grátis?

Sim — o texto completo de “Entendendo NA em R” é 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 “Entendendo NA em R”?

Aprenda o que NA significa, por que se propaga e como difere de NULL. 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 1 de 4.

Quanto tempo leva a aula “Entendendo NA em R”?

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

  1. Entendendo NA em R
  2. Detectando e contando valores ausentes
  3. Removendo e substituindo valores NA
  4. NA em cálculos e agregações
← Voltar para R Academy