Types de données en R : numeric, character, logical (typeof et class)

Les types de données en R

Chaque valeur en R appartient à un petit ensemble de types atomiques. Quatre d'entre eux font presque tout le travail :

• double - nombres décimaux : 3.14, -2, 1e6. C'est ce que R entend par « numeric », et c'est le type par défaut de tout nombre que tu tapes.
• integer - entiers stockés exactement, écrits avec un suffixe L : 42L.
• character - du texte entre guillemets : "hello".
• logical - les deux valeurs de vérité TRUE et FALSE (plus NA, la valeur manquante - voir les valeurs manquantes).

Il y a aussi complex (2 + 3i) pour les rares calculs de traitement du signal ; tu peux passer des années sans en avoir besoin. typeof() te dit quel type a une valeur :

cat(typeof(3.14), "\n")
cat(typeof(42L), "\n")
cat(typeof("hello"), "\n")
cat(typeof(TRUE), "\n")
cat(typeof(2 + 3i), "\n")

Note la première ligne : un nombre simple est un double même s'il a l'air entier. typeof(42) vaut "double" ; seul 42L est un integer. Dans l'analyse quotidienne la différence importe rarement - R convertit silencieusement entre les deux - mais elle explique beaucoup de sorties de typeof() autrement déroutantes.

typeof() et class() : pourquoi ils divergent

R a deux fonctions qui semblent toutes deux répondre à « qu'est-ce que c'est ? », et elles répondent à des questions subtilement différentes.

• typeof() indique le type de stockage : comment la valeur est posée en mémoire.
• class() indique le type comportemental : l'étiquette utilisée par le mécanisme de dispatch de R pour décider, par exemple, quel print ou quel summary exécuter.

Pour des valeurs simples, les réponses ne diffèrent que par le vocabulaire :

x <- 3.14
cat(typeof(x), "\n")
cat(class(x), "\n")

typeof() dit double (le stockage), class() dit numeric (le comportement). Pour les structures, l'écart se creuse :

m <- matrix(1:4, nrow = 2)
cat(typeof(m), "\n")
print(class(m))

La matrice est stockée comme un simple vecteur d'entiers, mais elle se comporte comme une matrice - c'est class() qui dit à R de l'afficher sous forme de grille. La même séparation apparaît avec les data frames (typeof dit "list", class dit "data.frame") et les dates (typeof dit "double", class dit "Date").

La règle pratique : utilise class() quand tu veux savoir ce qu'est quelque chose au sens courant, et typeof() quand tu débogues ce que R fait sous le capot.

Vérifier les types avec is.*()

Chaque type a un prédicat associé qui renvoie TRUE ou FALSE - pratique dans les fonctions qui doivent valider leur entrée :

x <- 10
cat(is.numeric(x), is.character(x), is.logical(x), "\n")

Un piège à connaître : is.numeric() vaut TRUE pour les doubles comme pour les entiers (ce sont tous deux des nombres), mais is.integer() vérifie le stockage, donc il vaut FALSE pour un simple 42 :

cat(is.numeric(42L), "\n")
cat(is.integer(42), "\n")
cat(is.integer(42L), "\n")

Si tu as déjà été surpris que is.integer(7) soit FALSE pour un nombre qui est manifestement un entier au sens mathématique - voilà pourquoi. 7 est un double ; 7L est un integer.

Convertir les types avec as.*()

La conversion explicite passe par la famille as.*, une fonction par type cible :

cat(as.numeric("3.5") + 1, "\n")
cat(as.integer(7.9), "\n")
cat(as.character(42), "\n")
cat(as.logical("TRUE"), "\n")

Deux comportements à retenir. as.integer() tronque vers zéro au lieu d'arrondir - 7.9 devient 7. Et quand une conversion n'a aucun sens, R ne lève pas d'erreur ; il renvoie NA et émet un avertissement :

result <- as.numeric("abc")
print(result)

Lance ça et tu verras NA accompagné d'un avertissement « NAs introduced by coercion ». C'est réellement utile - convertis toute une colonne de texte brouillon en nombres et les entrées illisibles deviennent NA au lieu de faire planter ton script - mais ça veut aussi dire qu'un NA silencieux peut se glisser dans tes données. Quand une conversion compte, vérifie ensuite l'apparition de nouveaux NA.

Les logiques se convertissent depuis et vers les nombres comme tu l'espères : as.numeric(TRUE) vaut 1, as.logical(0) vaut FALSE. C'est pourquoi sum() d'un vecteur logique compte les TRUE :

passed <- c(TRUE, TRUE, FALSE, TRUE)
cat(sum(passed), "out of", length(passed), "\n")

Coercition implicite : la règle du type unique pour les vecteurs

Un vecteur atomique en R ne peut contenir qu'un seul type. Combine des valeurs de types différents avec c() et R promeut silencieusement le tout vers le type le plus souple présent, en suivant une échelle fixe :

logical → integer → double → character

print(c(TRUE, FALSE, 2L))
print(c(1L, 2L, 3.5))
print(c(1, 2, "three"))

Les logiques sont devenues 1 et 0, les entiers sont devenus des doubles, et à la dernière ligne tout est devenu du texte - character gagne toujours, parce que n'importe quelle valeur peut s'écrire sous forme de chaîne. Tu peux le confirmer avec typeof() :

cat(typeof(c(TRUE, 1L)), "\n")
cat(typeof(c(1L, 2.5)), "\n")
cat(typeof(c(1, "a")), "\n")

La coercition est la source numéro un des bugs « pourquoi ma colonne est-elle du texte ? » : une seule chaîne "N/A" égarée dans une colonne de nombres transforme tout le vecteur en character. Quand ça arrive, corrige d'abord la valeur fautive, puis reconvertis avec as.numeric().

Ce que tu retiens

• Quatre types de tous les jours : double (« numeric »), integer (42L), character, logical.
• typeof() = comment c'est stocké ; class() = comment ça se comporte. 3.14 est un double qui se comporte comme un numeric.
• Vérifie avec is.numeric() et ses semblables ; convertis avec as.numeric() et ses semblables - les conversions échouées donnent NA avec un avertissement, pas une erreur.
• Les vecteurs ne contiennent qu'un seul type ; le mélange force la coercition selon logical → integer → double → character.

Prochaine étape : un regard plus fin sur les types numériques - arrondis, fonctions mathématiques, et les surprises de la virgule flottante que tous les langages partagent.