0Pricing
R Academy · Aula

Detectando e contando valores ausentes

Use is.na(), anyNA() e sum(is.na()) para auditar dados ausentes.

Detectando e contando valores ausentes é uma aula grátis de R 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 R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

is.na() — a ferramenta principal de detecção

is.na(x) testa cada elemento de x e retorna um vetor lógico com o mesmo comprimento, contendo TRUE onde o valor é NA (ou NaN). Esta é a ferramenta fundamental para detectar valores ausentes.

heights <- c(175, NA, 162, 188, NA, 170, NA, 165)
cat('Heights:', heights, '
')
cat('is.na() :', is.na(heights), '
')
cat('!is.na():', !is.na(heights), '
')

Contando NAs com sum(is.na())

Como TRUE == 1 e FALSE == 0 na aritmética, sum(is.na(x)) conta o número total de valores ausentes. mean(is.na(x)) fornece a proporção de valores ausentes.

survey <- c(8, NA, 6, NA, 9, 7, NA, 5, NA, 8)
cat('Survey responses:', survey, '
')
cat('Total NAs:    ', sum(is.na(survey)), '
')
cat('Total present:', sum(!is.na(survey)), '
')
cat('NA proportion:', mean(is.na(survey)), '
')
cat('NA percentage:', mean(is.na(survey)) * 100, '%
')

anyNA() — verificação rápida de presença

anyNA(x) retorna um único TRUE se algum elemento for NA; caso contrário, retorna FALSE. Ele é mais rápido que any(is.na(x)) porque para ao encontrar o primeiro NA.

complete_data <- c(1, 2, 3, 4, 5)
incomplete_data <- c(1, 2, NA, 4, 5)

cat('anyNA(complete)  :', anyNA(complete_data), '
')    # FALSE
cat('anyNA(incomplete):', anyNA(incomplete_data), '
')  # TRUE

# Use in validation
if (anyNA(incomplete_data)) {
  cat('Warning: data contains missing values!
')
}

which(is.na()) — encontrando posições

which(is.na(x)) retorna os índices (posições) dos valores ausentes em um vetor. Isso é essencial para auditar quais observações estão ausentes e para realizar imputações direcionadas.

temperatures <- c(22.1, NA, 19.8, NA, 25.1, NA, 17.3, 20.0)
cat('Temperatures:', temperatures, '
')

missing_pos <- which(is.na(temperatures))
cat('Missing at positions:', missing_pos, '
')
cat('Number missing:', length(missing_pos), '
')

# What values are NOT missing?
present_pos <- which(!is.na(temperatures))
cat('Present at positions:', present_pos, '
')

Contando NAs em um quadro de dados

Para quadros de dados, is.na(df) retorna uma matriz lógica com as mesmas dimensões. Combiná-la com colSums() fornece a contagem de valores ausentes por coluna — uma maneira rápida de auditar a qualidade dos dados.

# Simulate a small data frame
name_col <- c('Alice', 'Bob', 'Carol', 'Dave', 'Eve')
age_col  <- c(28, NA, 32, NA, 29)
sal_col  <- c(55000, 72000, NA, 90000, 61000)
scr_col  <- c(88, NA, 75, NA, NA)

cat('Age NAs:   ', sum(is.na(age_col)), '
')
cat('Salary NAs:', sum(is.na(sal_col)), '
')
cat('Score NAs: ', sum(is.na(scr_col)), '
')

Padrão colSums(is.na(df))

O padrão colSums(is.na(df)) é a maneira mais rápida de contar valores ausentes por coluna em um quadro de dados. Ele retorna um vetor numérico nomeado mostrando quantos NAs existem em cada coluna.

# Build a data frame manually
df <- data.frame(
  name   = c('Alice', 'Bob', 'Carol', 'Dave', 'Eve'),
  age    = c(28, NA, 32, NA, 29),
  salary = c(55000, 72000, NA, 90000, 61000),
  score  = c(88, NA, 75, NA, NA)
)
cat('Missing values per column:
')
print(colSums(is.na(df)))
cat('Total missing:', sum(is.na(df)), '
')

Proporção de NAs por coluna

Dividir pelo número de linhas fornece a proporção de valores ausentes por coluna. Isso é mais informativo do que as contagens brutas quando as colunas têm comprimentos diferentes.

df <- data.frame(
  x1 = c(1, NA, 3, NA, 5),
  x2 = c(NA, 2, NA, 4, NA),
  x3 = c(1, 2, 3, NA, 5)
)
n_rows <- nrow(df)
na_counts <- colSums(is.na(df))
na_pct <- round(na_counts / n_rows * 100, 1)

cat('NA counts:     '); print(na_counts)
cat('NA percentage: '); print(na_pct)

table(is.na()) — contagem de frequências

table(is.na(x)) produz uma tabela de frequências nomeada, mostrando quantos valores FALSE (presentes) e TRUE (ausentes) existem. É fácil interpretá-la rapidamente.

responses <- c(5, NA, 8, 6, NA, 9, 7, NA, NA, 8)

cat('NA frequency table:
')
print(table(is.na(responses)))

# For multiple columns:
cat('Age table:
')
ages <- c(28, NA, 32, NA, 29)
print(table(is.na(ages)))

Encontrando linhas com qualquer NA

Para descobrir quais linhas de um quadro de dados contêm pelo menos um valor ausente, use apply(is.na(df), 1, any). O resultado é um vetor lógico com TRUE para as linhas incompletas.

df <- data.frame(
  id     = 1:5,
  age    = c(28, NA, 32, NA, 29),
  salary = c(55000, 72000, NA, 90000, 61000)
)

# Which rows have at least one NA?
has_na <- apply(is.na(df), 1, any)
cat('Rows with any NA:', which(has_na), '
')
cat('Complete rows:   ', which(!has_na), '
')
cat('Complete row count:', sum(!has_na), '/', nrow(df), '
')

Auditando um conjunto de dados completo

Um fluxo de trabalho prático para auditar NAs: contar, localizar e relatar valores ausentes para entender a qualidade dos dados antes da análise. A seguir, há uma função de auditoria autocontida.

audit_na <- function(v, label) {
  n_total   <- length(v)
  n_missing <- sum(is.na(v))
  pct       <- round(n_missing / n_total * 100, 1)
  positions <- which(is.na(v))
  cat(label, ':', n_missing, '/', n_total,
      '(', pct, '%) NA at positions', positions, '
')
}

heights <- c(175, NA, 162, 188, NA, 170)
weights <- c(70, 85, NA, 92, 68, NA)
audit_na(heights, 'Height')
audit_na(weights, 'Weight')

Resumo da detecção de NA

Referência rápida das ferramentas de detecção de NA:

  • is.na(x) — vetor lógico: TRUE onde há NA
  • anyNA(x) — TRUE/FALSE único: há algum NA?
  • sum(is.na(x)) — contagem de NAs
  • mean(is.na(x)) — proporção de NAs
  • which(is.na(x)) — posições dos NAs
  • colSums(is.na(df)) — contagem de NAs por coluna
  • table(is.na(x)) — tabela de frequências de NA e não NA
x <- c(10, NA, 30, NA, 50, NA, 70)
cat('is.na:       ', is.na(x), '
')
cat('anyNA:       ', anyNA(x), '
')
cat('sum(is.na):  ', sum(is.na(x)), '
')
cat('mean(is.na): ', mean(is.na(x)), '
')
cat('which(is.na):', which(is.na(x)), '
')

Verificação rápida

O que sum(is.na(c(1, NA, 3, NA, 5))) retorna?

Recapitulação: detectando e contando NAs

Muito bem! Principais aprendizados desta lição:

  • is.na(x) é a ferramenta principal — retorna um vetor lógico
  • sum(is.na(x)) conta os valores ausentes; mean(is.na(x)) fornece a proporção
  • anyNA(x) é uma verificação rápida da presença de qualquer NA
  • which(is.na(x)) revela as posições exatas dos NAs
  • colSums(is.na(df)) é a maneira padrão de auditar um quadro de dados
  • Nunca use x == NA para detectar NA — use sempre is.na(x)
# Full audit of a data frame in 3 lines
df <- data.frame(a=c(1,NA,3), b=c(NA,2,NA), c=c(1,2,3))
cat('Per column:', colSums(is.na(df)), '
')
cat('Total:     ', sum(is.na(df)), '/', nrow(df)*ncol(df), '
')
cat('Complete rows:', sum(complete.cases(df)), '/', nrow(df), '
')

Perguntas Frequentes

A aula “Detectando e contando valores ausentes” é grátis?

Sim — o texto completo de “Detectando e contando valores ausentes” é 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 “Detectando e contando valores ausentes”?

Use is.na(), anyNA() e sum(is.na()) para auditar dados ausentes. 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 2 de 4.

Quanto tempo leva a aula “Detectando e contando valores ausentes”?

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