0Pricing
R Academy · Leçon

Comprendre NA dans R

Découvrez ce que signifie NA, pourquoi il se propage et en quoi il diffère de NULL.

Comprendre NA dans R est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Qu’est-ce que NA dans R ?

NA signifie Not Available (« non disponible ») et représente une valeur manquante ou inconnue. Contrairement à NULL (absence d’objet) ou à NaN (pas un nombre), NA sert d’espace réservé pour des données qui existent, mais dont la valeur est inconnue.

# 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 ou NULL

NA est une valeur manquante à l’intérieur d’un vector : l’emplacement existe, mais sa valeur n’est pas connue. NULL correspond à l’absence totale d’un objet : sa longueur est nulle et il ne peut pas être stocké dans 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 ou NaN

NaN (Not a Number, « pas un nombre ») résulte d’opérations mathématiquement indéfinies comme 0/0 ou sqrt(-1). Il s’agit d’une valeur numérique spéciale, tandis que NA est un marqueur général de valeur manquante qui peut s’appliquer à n’importe quel type.

# 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 ou Inf

Inf et -Inf représentent l’infini positif et négatif — ils résultent d’opérations telles que 1/0. Contrairement à NA, Inf est une valeur numérique connue (même si elle est extrême) et participe normalement aux comparaisons.

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

Propagation de NA dans les opérations arithmétiques

NA est contagieux dans les opérations arithmétiques : toute opération impliquant NA renvoie NA. C’est intentionnel : si une valeur d’un calcul est inconnue, le résultat l’est également.

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) — NA typés

Par défaut, NA est de type logical. R fournit des variantes de NA typées pour chaque type atomique. Elles sont importantes lorsque vous travaillez avec des vecteurs typés, afin d’éviter une coercition de type involontaire.

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 pratique

Lorsque vous créez un vecteur d’entiers contenant une valeur manquante, utilisez NA_integer_ pour conserver proprement le type du vecteur. L’utilisation de NA seul provoque une coercition implicite vers le type double dans certains contextes.

# 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_ et NA_character_

NA_real_ s’utilise pour les valeurs manquantes dans les vecteurs de type double (numériques), et NA_character_ pour les chaînes manquantes. Ils sont particulièrement importants lors de la construction de vecteurs dans des fonctions où la cohérence des types est essentielle.

# 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 dans les opérations logiques

Dans les opérations logiques, NA suit une logique à trois valeurs : TRUE | NA vaut TRUE (car TRUE OU n’importe quoi vaut TRUE), tandis que FALSE | NA vaut NA (nous ne pouvons pas déterminer le résultat sans connaître la valeur 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 dans les vecteurs et les data frames

Les valeurs manquantes apparaissent fréquemment dans les données réelles. Comprendre le comportement de NA vous aide à interpréter correctement les synthèses, à repérer les problèmes de qualité des données et à choisir la stratégie de traitement appropriée.

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

Types de NA : vue d’ensemble

Voici un résumé des valeurs spéciales liées à NA dans R :

  • NA — valeur manquante générique (type logical)
  • NA_integer_, NA_real_, NA_complex_, NA_character_ — NA typés
  • NaN — nombre indéfini (résultat de 0/0, sqrt(-1))
  • Inf, -Inf — valeurs infinies (résultat de 1/0)
  • NULL — absence d’un objet (longueur 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

Vérification rapide

À quelle valeur NA == NA s’évalue-t-il dans R ?

Récapitulatif : comprendre NA

Excellent ! Voici les points essentiels de cette leçon :

  • NA = valeur manquante (on sait qu’elle existe, mais sa valeur est inconnue)
  • NULL = absence d’un objet (retiré des vecteurs)
  • NaN = résultat arithmétique indéfini (est également NA)
  • Inf / -Inf = valeurs infinies (ne sont PAS NA)
  • NA est contagieux dans les opérations arithmétiques : les opérations sur NA renvoient NA
  • Utilisez des NA typés (NA_integer_, etc.) pour garantir la sûreté des types dans votre code
  • Testez toujours la présence de NA avec is.na(), jamais avec == 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)]), '
')
}

Questions Fréquemment Posées

La leçon « Comprendre NA dans R » est-elle gratuite ?

Oui — le texte complet de « Comprendre NA dans R » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comprendre NA dans R » ?

Découvrez ce que signifie NA, pourquoi il se propage et en quoi il diffère de NULL. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Comprendre NA dans R » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Comprendre NA dans R
  2. Détecter et compter les valeurs manquantes
  3. Supprimer et remplacer les valeurs NA
  4. NA dans les calculs et les agrégations
← Retour à R Academy