Vecteurs & types de données en R : numeric, character, logical, factor

Créez des vecteurs avec c(), vérifiez et convertissez les types, et gérez les NA — la base sur laquelle tout le reste repose

Les types de données en R — numeric, integer, character, logical et factor — et le vecteur qui les contient. Créez des vecteurs avec c(), comprenez les règles de coercition de R, vérifiez et convertissez les types avec class()/typeof()/is.*/as.*, effectuez des opérations vectorisées, nommez les éléments, construisez des séquences avec seq()/rep(), et gérez les valeurs manquantes (NA).

AstucePoints clés à retenir

• Un vecteur réunit plusieurs valeurs du même type dans un seul objet, construit avec c() (combine).
• Les types atomiques : numeric (doubles), integer, character, logical — plus factor pour les catégories.
• Coercition : mélangez des types dans un même vecteur et R les promeut tous silencieusement vers le type le plus flexible (logical → numeric → character).
• Vérifier & convertir : class()/typeof() pour voir le type, is.numeric()/is.character()/… pour tester, as.numeric()/as.character()/… pour convertir.
• Vectorisé : l’arithmétique et les fonctions s’appliquent à chaque élément d’un coup — pas de boucle nécessaire.
• NA marque une valeur manquante ; testez-la avec is.na(), jamais avec == NA.

Introduction

Tout en R repose sur le vecteur — une séquence de valeurs du même type. Un simple nombre comme 42 est en réalité un vecteur de longueur un ; une colonne de data frame est un vecteur. Comprenez les vecteurs et la poignée de types de données qu’ils contiennent, et le reste de R — indexation, manipulation, modélisation — se met en place naturellement.

Cette leçon est la base : les types atomiques, comment construire des vecteurs avec c(), comment R coerce les types mélangés, comment vérifier et changer un type, les opérations vectorisées, les vecteurs nommés, la construction de séquences, les valeurs manquantes, et les factors pour les catégories. Chaque leçon ultérieure suppose que vous maîtrisez cela.

Les types de données de base

R possède quatre types atomiques que vous utiliserez constamment. Créez une valeur de chacun — numeric pour les nombres, character pour le texte, logical pour vrai/faux :

my_age  <- 28          # numeric
my_name <- "Nicolas"   # character (single or double quotes)
is_data_scientist <- TRUE   # logical: TRUE / FALSE

L’affectation utilise <- (ou =). Pour voir une valeur, tapez son nom. Notez que R est sensible à la casse — my_age et My_Age sont des objets différents.

my_age

[1] 28

Utilisez class() pour demander quel est le type d’une valeur :

class(my_age)

[1] "numeric"

class(my_name)

[1] "character"

class(is_data_scientist)

[1] "logical"

Numeric ou integer

Par défaut, les nombres en R sont des doubles (nombres réels avec décimales) — même un nombre entier comme 28 est un double. Pour forcer un véritable integer, ajoutez L :

x <- 28      # a double, despite looking whole
y <- 28L     # an integer

class(x)

[1] "numeric"

class(y)

[1] "integer"

class() renvoie "numeric" pour les deux, mais typeof() montre le vrai type de stockage — "double" ou "integer" :

typeof(x)

[1] "double"

typeof(y)

[1] "integer"

Au quotidien, la distinction importe rarement — l’arithmétique sur x et y se comporte de la même façon. Elle ressort lorsqu’une fonction exige un integer (certaines indexations et appels de niveau C) ou lorsque vous comparez à un type stocké.

Créer un vecteur avec c()

Un vecteur combine plusieurs valeurs en un seul objet avec c() (pour combine / concatenate). Les valeurs doivent partager un type — vous obtenez un vecteur numeric, character ou logical en conséquence :

ages    <- c(27, 25, 29, 26)                       # numeric vector
friends <- c("Nicolas", "Thierry", "Bernard")      # character vector
married <- c(TRUE, FALSE, TRUE, TRUE)              # logical vector

ages

[1] 27 25 29 26

friends

[1] "Nicolas" "Thierry" "Bernard"

married

[1]  TRUE FALSE  TRUE  TRUE

length() renvoie le nombre d’éléments que contient un vecteur :

length(friends)

[1] 3

Coercition : mélanger des types dans un même vecteur

Un vecteur contient un seul type. Que se passe-t-il donc si vous en mélangez ? R ne renvoie pas d’erreur — il coerce silencieusement chaque élément vers le type commun le plus flexible. La hiérarchie est logical → integer → numeric → character : le texte l’emporte sur tout.

Mélangez un nombre avec du texte, et le nombre devient du texte :

mixed <- c(1, 2, "three")
mixed          # all character now — note the quotes

[1] "1"     "2"     "three"

class(mixed)

[1] "character"

Mélangez un logical avec un nombre, et TRUE/FALSE deviennent 1/0 :

nums <- c(TRUE, FALSE, 3, 5)
nums           # logicals promoted to numbers

[1] 1 0 3 5

sum(c(TRUE, TRUE, FALSE, TRUE))   # TRUE counts as 1 — handy for counting

[1] 3

C’est la plus grande surprise du genre « pourquoi mon calcul est-il cassé ? » : une seule valeur texte égarée transforme toute une colonne numérique en character, et l’arithmétique cesse de fonctionner. Vérifiez toujours le type quand les résultats semblent faux.

Vérifier et convertir les types

Deux familles de fonctions vous permettent d’inspecter et de changer les types.

Testez un type avec is.* — chacune renvoie TRUE ou FALSE :

is.numeric(ages)

[1] TRUE

is.character(ages)

[1] FALSE

is.numeric(friends)

[1] FALSE

Convertissez avec as.*. Transformez des nombres en texte, du texte en nombres, et ainsi de suite :

as.character(ages)      # numbers -> "27" "25" ...

[1] "27" "25" "29" "26"

as.numeric(c("10", "20", "30"))   # text -> numbers

[1] 10 20 30

Une conversion qui n’a pas de sens produit NA avec un avertissement — R ne peut pas transformer "hello" en nombre :

as.numeric(c("10", "hello", "30"))

Warning: NAs introduits lors de la conversion automatique

[1] 10 NA 30

Ce NA est votre signal que quelque chose dans les données n’était pas vraiment un nombre.

Opérations vectorisées

R applique l’arithmétique et la plupart des fonctions à chaque élément d’un coup — pas de boucle nécessaire. Multipliez un vecteur par un scalaire et chaque élément est multiplié :

salaries <- c(2000, 1800, 2500, 3000)
salaries * 2

[1] 4000 3600 5000 6000

Opérez sur deux vecteurs de même longueur et R travaille élément par élément — le premier avec le premier, le deuxième avec le deuxième :

coefs <- c(2, 1.5, 1, 3)
salaries * coefs

[1] 4000 2700 2500 9000

Les fonctions de synthèse réduisent un vecteur entier à un seul nombre :

sum(salaries)

[1] 9300

mean(salaries)

[1] 2325

range(salaries)    # min and max

[1] 1800 3000

sqrt(c(4, 16, 9))  # applied to each element

[1] 2 4 3

Ce style vectorisé est la raison pour laquelle le code R est court et rapide — vous décrivez l’opération sur le vecteur entier au lieu d’écrire une boucle.

Vecteurs nommés

Vous pouvez attacher un nom à chaque élément, puis retrouver les valeurs par nom plutôt que par position. Définissez les noms avec names(), ou nommez-les au moment de construire le vecteur :

# Name an existing vector
salaries <- c(2000, 1800, 2500, 3000)
names(salaries) <- c("Nicolas", "Thierry", "Bernard", "Jerome")
salaries

Nicolas Thierry Bernard  Jerome 
   2000    1800    2500    3000 

# Or name them inline
ages <- c(Nicolas = 27, Thierry = 25, Bernard = 29)
ages

Nicolas Thierry Bernard 
     27      25      29 

# Look up by name
salaries["Bernard"]

Bernard 
   2500 

Les vecteurs nommés sont une table de correspondance légère — pratique pour associer des codes à des libellés.

Construire des séquences avec seq() et rep()

Vous tapez rarement de longs vecteurs à la main. Le deux-points : construit une simple suite d’entiers ; seq() donne un contrôle complet sur le pas ; rep() répète des valeurs.

1:5                              # 1, 2, 3, 4, 5

[1] 1 2 3 4 5

seq(0, 1, by = 0.25)             # from, to, step

[1] 0.00 0.25 0.50 0.75 1.00

seq(0, 10, length.out = 5)       # 5 evenly spaced values

[1]  0.0  2.5  5.0  7.5 10.0

rep("A", times = 3)              # repeat 3 times

[1] "A" "A" "A"

rep(c(1, 2), times = 2)          # repeat the whole vector

[1] 1 2 1 2

rep(c(1, 2), each = 2)           # repeat each element

[1] 1 1 2 2

Ce sont les briques de base pour l’indexation, la simulation de données et la création de variables de regroupement.

Valeurs manquantes : NA

Les données réelles ont des trous. R marque une valeur manquante avec NA — et elle se propage : toute arithmétique impliquant NA renvoie NA, parce que la réponse est réellement inconnue.

have_child <- c(Nicolas = 2, Thierry = 1, Bernard = NA, Jerome = NA)
have_child

Nicolas Thierry Bernard  Jerome 
      2       1      NA      NA 

mean(have_child)               # NA — one missing value poisons the result

[1] NA

mean(have_child, na.rm = TRUE) # drop NAs first

[1] 1.5

Testez l’absence avec is.na() — jamais x == NA (comparer à une valeur inconnue est lui-même inconnu, donc cela renvoie NA, pas TRUE) :

is.na(have_child)                  # logical vector: which are missing

Nicolas Thierry Bernard  Jerome 
  FALSE   FALSE    TRUE    TRUE 

have_child[!is.na(have_child)]     # keep only the non-missing values

Nicolas Thierry 
      2       1 

NaN (« Not a Number », par ex. 0/0) est une valeur spéciale apparentée ; is.na() vaut TRUE pour les deux, tandis que is.nan() ne signale que NaN.

Factors : les catégories

Un factor stocke des données catégorielles — un ensemble fixe de catégories appelées niveaux (levels). Utilisez factor() pour les variables de regroupement comme le traitement, le sexe ou la note :

groups <- factor(c("low", "high", "low", "high", "medium"))
groups

[1] low    high   low    high   medium
Levels: high low medium

levels(groups)        # the distinct categories

[1] "high"   "low"    "medium"

R ordonne les niveaux par ordre alphabétique par défaut. Quand l’ordre compte (low < medium < high), définissez-le explicitement — cela contrôle la façon dont les groupes se trient dans les tableaux et les graphiques :

groups <- factor(
  groups,
  levels = c("low", "medium", "high")
)
levels(groups)

[1] "low"    "medium" "high"  

table(groups)         # counts per level, in your order

groups
   low medium   high 
     2      1      2 

Le piège du factor-en-nombre : un factor stocke ses niveaux sous forme de codes entiers en interne. Appliquer as.numeric() à un factor renvoie ces codes, pas les libellés — donc un factor de c("10", "20", "30") devient 1, 2, 3. Pour récupérer les nombres, passez d’abord par character :

f <- factor(c("10", "20", "30"))
as.numeric(f)                       # WRONG: 1 2 3 (the level codes)

[1] 1 2 3

as.numeric(as.character(f))         # RIGHT: 10 20 30

[1] 10 20 30

Tout le monde se fait avoir une fois. Si un factor contient réellement des nombres, convertissez toujours via as.character() d’abord.

Essayez en direct

Les blocs ci-dessus ont été exécutés au moment de la construction. Éditez celui-ci et appuyez sur Run pour construire des vecteurs et vérifier leurs types vous-même — il s’exécute dans votre navigateur via webR (aucune installation).

🟢 Avec un agent IA

Collez une colonne en désordre et demandez à Prova « pourquoi cette colonne numérique apparaît-elle comme du character, et comment la corriger ? » — elle repère la valeur non numérique égarée et écrit la conversion as.numeric(), et comme le runtime est juste là, vous l’exécutez pour confirmer que la colonne est réellement numérique sur vos données. Demandez à Prova →

Problèmes courants

Ma colonne numérique est soudain en character / le calcul échoue. Une seule valeur non numérique (un "N/A" égaré, un libellé, un espace) coerce tout le vecteur en character — voir les règles de coercition ci-dessus. Vérifiez avec class(), trouvez le coupable, puis as.numeric() (qui renvoie NA pour tout ce qui n’est pas un nombre, ce qui localise les valeurs fautives).

as.numeric() sur un factor me donne 1, 2, 3 au lieu de mes nombres. Un factor stocke des codes de niveaux entiers, et as.numeric() renvoie ces codes. Convertissez d’abord via character : as.numeric(as.character(f)).

x == NA renvoie NA au lieu de TRUE. Vous ne pouvez pas comparer à une valeur manquante avec == — le résultat est lui-même inconnu. Utilisez is.na(x) pour tester l’absence, et na.rm = TRUE (par ex. mean(x, na.rm = TRUE)) pour ignorer les NA dans les synthèses.

Questions fréquentes

NoteComment créer un vecteur en R ?

Utilisez c() pour combiner des valeurs : c(1, 2, 3) pour des nombres, c("a", "b") pour du texte, c(TRUE, FALSE) pour des logicals. Tous les éléments doivent partager un type. Pour des suites de valeurs, utilisez 1:5 ou seq(), et rep() pour répéter.

NoteQuels sont les types de données en R ?

Les types atomiques sont numeric (doubles), integer (écrivez 5L), character (texte) et logical (TRUE/FALSE). Au-dessus de ceux-ci, factor stocke des catégories et NA marque une valeur manquante. Vérifiez un type avec class() ou typeof().

NotePourquoi mon vecteur numérique s’est-il transformé en character ?

Un vecteur contient un seul type, donc mélanger une seule valeur texte avec des nombres coerce tout en character (l’ordre est logical → numeric → character). Un seul non-nombre égaré transforme tout le vecteur en texte. Trouvez-le, puis reconvertissez avec as.numeric().

NoteQuelle est la différence entre numeric et integer en R ?

Un numeric est un double — un nombre réel qui peut avoir des décimales, et la valeur par défaut pour tout nombre que vous tapez. Un integer est un nombre entier que vous créez avec le suffixe L (28L). class() renvoie les deux comme numeric, mais typeof() montre "double" ou "integer". Pour la plupart des travaux, la différence n’a pas d’importance.

NoteComment vérifier les valeurs manquantes (NA) en R ?

Utilisez is.na(x), qui renvoie un vecteur logical marquant chaque NA. N’écrivez jamais x == NA — comparer à une valeur inconnue renvoie NA, pas TRUE. Pour ignorer les valeurs manquantes dans une synthèse, ajoutez na.rm = TRUE, par ex. mean(x, na.rm = TRUE).

Testez vos connaissances

ImportantExercice : construire, coercer et nettoyer un vecteur

Créez un vecteur numérique scores valant c(80, 92, NA, 75, 88). Calculez sa moyenne en ignorant la valeur manquante, puis montrez quels éléments sont manquants, puis construisez une version nommée où les noms sont c("a","b","c","d","e").

# Drop NAs in a summary with na.rm = TRUE.
# Test for missingness with is.na().
# Assign a character vector of names into names(scores).

scores <- c(80, 92, NA, 75, 88) # 1. Mean, ignoring NA mean(scores, na.rm = TRUE) # 2. Which elements are missing? is.na(scores) # 3. Add names names(scores) <- c("a", "b", "c", "d", "e") scores

scores <- c(80, 92, NA, 75, 88)

# 1. Mean, ignoring NA
mean(scores, na.rm = TRUE)

# 2. Which elements are missing?
is.na(scores)

# 3. Add names
names(scores) <- c("a", "b", "c", "d", "e")
scores

NoteVérification rapide : quel est le type de ce vecteur ?

Que renvoie class(c(1, 2, "3")) ?

A. "numeric" B. "character" C. "list"

Afficher la réponse

B. Le vecteur mélange des nombres avec une valeur texte "3", donc R coerce tout vers le type le plus flexible — character. Les nombres deviennent "1" et "2". C’est pourquoi une seule valeur texte égarée peut casser l’arithmétique sur une colonne.

Conclusion

Les vecteurs sont l’unité de base de R, et ils contiennent un seul type à la fois : numeric, integer, character ou logical, plus les factors pour les catégories. Construisez-les avec c(), méfiez-vous de la coercition silencieuse quand les types se mélangent, vérifiez avec class()/typeof() et convertissez avec as.*, appuyez-vous sur les opérations vectorisées plutôt que sur les boucles, et testez les valeurs manquantes avec is.na() — jamais == NA. Ces règles sous-tendent chaque jeu de données que vous toucherez en R.

Leçons connexes

• Indexation & sélection — extrayez des éléments des vecteurs que vous venez de construire. · Structures de contrôle : if, for, while — créez des branches et bouclez sur les vecteurs. · Jeux de données intégrés à R — des données d’entraînement dont les colonnes sont précisément ces types. · Renommer des colonnes en R — travaillez avec des data frames, qui sont des vecteurs côte à côte.
• Aller plus loin : R Foundations — la série complète. · Science computationnelle & IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Les bases de R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.