0Pricing
R Academy · Lección

Detección y recuento de valores ausentes

Use is.na(), anyNA() y sum(is.na()) para auditar datos ausentes.

Detección y recuento de valores ausentes es una lección gratuita de R 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 R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

is.na(): la herramienta principal de detección

is.na(x) comprueba cada elemento de x y devuelve un vector lógico de la misma longitud, con TRUE cuando el valor es NA (o NaN). Esta es la herramienta 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), '
')

Contar NA con sum(is.na())

Como TRUE == 1 y FALSE == 0 en las operaciones aritméticas, sum(is.na(x)) cuenta el número total de valores ausentes. mean(is.na(x)) proporciona la proporción 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(): comprobación rápida de presencia

anyNA(x) devuelve un único TRUE si algún elemento es NA; en caso contrario, devuelve FALSE. Es más rápido que any(is.na(x)) porque se detiene al encontrar el primer 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()): encontrar posiciones

which(is.na(x)) devuelve los índices (posiciones) de los valores ausentes de un vector. Es esencial para auditar qué observaciones faltan y realizar una imputación selectiva.

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, '
')

Contar NA en un data frame

En los data frames, is.na(df) devuelve una matriz lógica con las mismas dimensiones. Al combinarla con colSums(), se obtiene el recuento de valores ausentes por columna, una forma rápida de auditar la calidad de los datos.

# 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)), '
')

Patrón colSums(is.na(df))

El patrón colSums(is.na(df)) es la forma más rápida de contar los valores ausentes por columna en un data frame. Devuelve un vector numérico con nombres que muestra cuántos NA hay en cada columna.

# 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)), '
')

Proporción de NA por columna

Dividir por el número de filas proporciona la proporción de valores ausentes por columna. Esto resulta más informativo que los recuentos absolutos cuando las columnas tienen longitudes 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()): recuento de frecuencias

table(is.na(x)) genera una tabla de frecuencias con nombres que muestra cuántos valores FALSE (presentes) y TRUE (ausentes) hay. Es fácil de interpretar de un vistazo.

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)))

Encontrar filas con algún NA

Para encontrar qué filas de un data frame contienen al menos un valor ausente, use apply(is.na(df), 1, any). El resultado es un vector lógico con TRUE para las filas 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), '
')

Auditar un conjunto de datos completo

Un flujo de trabajo práctico para auditar NA consiste en contar, localizar e informar de los valores ausentes para comprender la calidad de los datos antes del análisis. A continuación se muestra una función de auditoría independiente.

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')

Resumen de detección de NA

Referencia rápida de las herramientas para detectar NA:

  • is.na(x) — vector lógico: TRUE donde hay NA
  • anyNA(x) — TRUE/FALSE único: ¿hay algún NA?
  • sum(is.na(x)) — recuento de NA
  • mean(is.na(x)) — proporción de NA
  • which(is.na(x)) — posiciones de los NA
  • colSums(is.na(df)) — recuento de NA por columna
  • table(is.na(x)) — tabla de frecuencias de NA y valores no ausentes
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)), '
')

Comprobación rápida

¿Qué devuelve sum(is.na(c(1, NA, 3, NA, 5)))?

Resumen: detectar y contar NA

¡Buen trabajo! Estas son las ideas clave de esta lección:

  • is.na(x) es la herramienta principal y devuelve un vector lógico
  • sum(is.na(x)) cuenta los valores ausentes; mean(is.na(x)) proporciona la proporción
  • anyNA(x) permite comprobar rápidamente si hay algún NA
  • which(is.na(x)) muestra las posiciones exactas de los NA
  • colSums(is.na(df)) es la forma habitual de auditar un data frame
  • No use nunca x == NA para detectar NA; use siempre 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), '
')

Preguntas frecuentes

¿La lección «Detección y recuento de valores ausentes» es gratis?

Sí — el texto completo de «Detección y recuento de valores ausentes» 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 R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Detección y recuento de valores ausentes»?

Use is.na(), anyNA() y sum(is.na()) para auditar datos ausentes. Practicas R 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 R Academy?

No se requiere experiencia previa. R 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 «Detección y recuento de valores ausentes»?

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

Sí. Cada lección de R 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

  1. Comprender NA en R
  2. Detección y recuento de valores ausentes
  3. Eliminación y sustitución de valores NA
  4. NA en cálculos y agregaciones
← Volver a R Academy