0Pricing
R Academy · Leçon

Détecter et compter les valeurs manquantes

Utilisez is.na(), anyNA() et sum(is.na()) pour contrôler les données manquantes.

Détecter et compter les valeurs manquantes est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

is.na() — l’outil essentiel de détection

is.na(x) teste chaque élément de x et renvoie un vecteur logique de même longueur, contenant TRUE lorsque la valeur est NA (ou NaN). C’est l’outil fondamental pour détecter les valeurs manquantes.

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

Compter les NA avec sum(is.na())

Comme TRUE == 1 et FALSE == 0 dans les opérations arithmétiques, sum(is.na(x)) compte le nombre total de valeurs manquantes. mean(is.na(x)) donne la proportion de valeurs manquantes.

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() — vérification rapide de présence

anyNA(x) renvoie un seul TRUE si un élément quelconque vaut NA, et FALSE dans le cas contraire. Cette fonction est plus rapide que any(is.na(x)), car elle s’arrête dès qu’elle trouve le premier 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()) — trouver les positions

which(is.na(x)) renvoie les indices (positions) des valeurs manquantes dans un vecteur. C’est essentiel pour vérifier quelles observations sont manquantes et effectuer une imputation ciblée.

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

Compter les NA dans un data frame

Pour les data frames, is.na(df) renvoie une matrice logique de mêmes dimensions. La combinaison avec colSums() donne le nombre de valeurs manquantes par colonne — un moyen rapide de vérifier la qualité des données.

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

Motif colSums(is.na(df))

Le motif colSums(is.na(df)) est le moyen le plus rapide de compter les valeurs manquantes par colonne dans un data frame. Il renvoie un vecteur numérique nommé indiquant le nombre de NA présents dans chaque colonne.

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

Proportion de NA par colonne

En divisant par le nombre de lignes, vous obtenez la proportion de valeurs manquantes par colonne. Cette mesure est plus informative que les décomptes bruts lorsque les colonnes ont des longueurs différentes.

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()) — décompte des fréquences

table(is.na(x)) produit un tableau de fréquences nommé indiquant le nombre de valeurs FALSE (présentes) et TRUE (manquantes). Il se lit facilement en un coup d’œil.

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

Trouver les lignes contenant au moins un NA

Pour trouver les lignes d’un data frame qui contiennent au moins une valeur manquante, utilisez apply(is.na(df), 1, any). Le résultat est un vecteur logique contenant TRUE pour les lignes incomplètes.

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

Vérifier un jeu de données complet

Voici une méthode pratique pour vérifier les NA : compter, localiser et signaler les valeurs manquantes afin de comprendre la qualité des données avant l’analyse. Voici une fonction de vérification autonome.

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

Résumé de la détection des NA

Référence rapide des outils de détection des NA :

  • is.na(x) — vecteur logique : TRUE lorsque la valeur est NA
  • anyNA(x) — TRUE/FALSE unique : un NA est-il présent ?
  • sum(is.na(x)) — nombre de NA
  • mean(is.na(x)) — proportion de NA
  • which(is.na(x)) — positions des NA
  • colSums(is.na(df)) — nombre de NA par colonne
  • table(is.na(x)) — tableau de fréquences des valeurs NA et non-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)), '
')

Vérification rapide

Que renvoie sum(is.na(c(1, NA, 3, NA, 5))) ?

Récapitulatif : détecter et compter les NA

Très bien ! Voici les points essentiels de cette leçon :

  • is.na(x) est l’outil principal : il renvoie un vecteur logique
  • sum(is.na(x)) compte les valeurs manquantes ; mean(is.na(x)) en donne la proportion
  • anyNA(x) permet de vérifier rapidement la présence d’un NA
  • which(is.na(x)) révèle les positions exactes des NA
  • colSums(is.na(df)) est la méthode standard pour vérifier un data frame
  • N’utilisez jamais x == NA pour détecter NA : utilisez toujours 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), '
')

Questions Fréquemment Posées

La leçon « Détecter et compter les valeurs manquantes » est-elle gratuite ?

Oui — le texte complet de « Détecter et compter les valeurs manquantes » 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 « Détecter et compter les valeurs manquantes » ?

Utilisez is.na(), anyNA() et sum(is.na()) pour contrôler les données manquantes. 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 2 sur 4.

Combien de temps prend la leçon « Détecter et compter les valeurs manquantes » ?

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