0Pricing
R Academy · Lección

Comprender NA en R

Aprenda qué significa NA, por qué se propaga y en qué se diferencia de NULL.

Comprender NA en R es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 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.

¿Qué es NA en R?

NA significa Not Available (no disponible): representa un valor ausente o desconocido. A diferencia de NULL (ausencia de un objeto) o NaN (no es un número), NA es un marcador de posición para datos que existen, pero cuyo valor se desconoce.

# 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 frente a NULL

NA es un valor ausente dentro de un vector: la posición existe, pero no tiene un valor conocido. NULL es la ausencia total de un objeto: tiene longitud 0 y no se puede almacenar dentro de un 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 frente a NaN

NaN (Not a Number, no es un número) es el resultado de operaciones matemáticamente indefinidas, como 0/0 o sqrt(-1). Es un valor numérico especial, mientras que NA es un marcador general de valor ausente que puede aplicarse a cualquier 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 frente a Inf

Inf y -Inf representan el infinito positivo y negativo, respectivamente; son el resultado de operaciones como 1/0. A diferencia de NA, Inf es un valor numérico conocido, aunque extremo, y participa normalmente en las comparaciones.

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

Propagación de NA en operaciones aritméticas

NA es contagioso en las operaciones aritméticas: cualquier operación que incluya NA devuelve NA. Esto es intencionado: si uno de los valores de un cálculo es desconocido, el resultado también lo es.

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): valores NA tipados

El NA predeterminado es de tipo logical. R proporciona variantes tipadas de NA para cada tipo atómico. Estas variantes son importantes al trabajar con vectores tipados, ya que evitan conversiones de tipo no deseadas.

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_ en la práctica

Al crear un vector de enteros con un valor ausente, use NA_integer_ para conservar correctamente el tipo del vector. Usar simplemente NA provoca una conversión implícita a double en algunos 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_ y NA_character_

NA_real_ se usa para valores ausentes en vectores double (numéricos), y NA_character_ para cadenas ausentes. Son especialmente importantes al crear vectores dentro de funciones en las que la coherencia de tipos es importante.

# 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 en operaciones lógicas

NA en las operaciones lógicas sigue la lógica trivalente: TRUE | NA es TRUE (porque TRUE OR cualquier valor es TRUE), pero FALSE | NA es NA (no podemos determinar el resultado sin conocer el 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 en vectores y data frames

Los valores ausentes aparecen con frecuencia en los datos del mundo real. Comprender cómo se comporta NA le ayuda a interpretar correctamente los resúmenes, detectar problemas de calidad de los datos y elegir la estrategia de tratamiento adecuada.

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: panorama completo

A continuación se resumen los valores especiales relacionados con NA en R:

  • NA — valor ausente genérico (tipo logical)
  • NA_integer_, NA_real_, NA_complex_, NA_character_ — valores NA tipados
  • NaN — número indefinido (resultado de 0/0, sqrt(-1))
  • Inf, -Inf — valores infinitos (resultado de 1/0)
  • NULL — ausencia de un objeto (longitud 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

Comprobación rápida

¿A qué valor se evalúa NA == NA en R?

Resumen: comprender NA

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

  • NA = valor ausente (se sabe que existe, pero se desconoce su valor)
  • NULL = ausencia de un objeto (se elimina de los vectores)
  • NaN = resultado aritmético indefinido (también es NA)
  • Inf / -Inf = valores infinitos (NO son NA)
  • NA es contagioso en las operaciones aritméticas: las operaciones con NA devuelven NA
  • Use valores NA tipados (NA_integer_, etc.) para escribir código con tipos seguros
  • Compruebe siempre si hay NA con is.na(), nunca con == 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)]), '
')
}

Preguntas frecuentes

¿La lección «Comprender NA en R» es gratis?

Sí — el texto completo de «Comprender NA en R» 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 «Comprender NA en R»?

Aprenda qué significa NA, por qué se propaga y en qué se diferencia de NULL. 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 1 de 4.

¿Cuánto tiempo toma la lección «Comprender NA en R»?

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