0Pricing
R Academy · Leçon

Conversions logique et caractère

Convertissez des valeurs entre les types logical, character et numeric avec as.logical() et as.character().

Conversions logique et caractère est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Convertir entre les types

R fournit des fonctions as.*() pour convertir tous les types de base les uns vers les autres. Cette leçon présente les conversions entre les types logical, character et numeric, c’est-à-dire les conversions aller-retour les plus courantes lors du nettoyage des données.

# Quick overview of as.*() functions
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.numeric(TRUE): ', as.numeric(TRUE), '
')  # 1
cat('as.character(3.14):', as.character(3.14), '
') # "3.14"
cat('as.logical("TRUE"):', as.logical('TRUE'), '
') # TRUE

De numeric à logical

Lorsqu’un nombre est converti en logical, 0 devient FALSE et tout nombre non nul devient TRUE. Cette règle s’applique aux integer comme aux double.

cat('as.logical(0):    ', as.logical(0), '
')     # FALSE
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.logical(-5):   ', as.logical(-5), '
')    # TRUE (non-zero)
cat('as.logical(0.001):', as.logical(0.001), '
') # TRUE (non-zero)
cat('as.logical(0L):   ', as.logical(0L), '
')    # FALSE
cat('as.logical(3L):   ', as.logical(3L), '
')    # TRUE

De logical à numeric

TRUE est converti en 1 et FALSE en 0. Cette conversion est au cœur de nombreuses pratiques idiomatiques de R, comme l’utilisation de sum() pour compter les valeurs TRUE ou de mean() pour calculer des proportions.

cat('as.numeric(TRUE):  ', as.numeric(TRUE), '
')   # 1
cat('as.numeric(FALSE): ', as.numeric(FALSE), '
')  # 0
cat('as.integer(TRUE):  ', as.integer(TRUE), '
')   # 1L

# Practical use: count TRUEs by summing
passed <- c(TRUE, FALSE, TRUE, TRUE, FALSE, TRUE)
cat('Passed count:', sum(as.numeric(passed)), '
')  # 4
cat('Pass rate:   ', mean(passed) * 100, '%
')      # 66.67%

as.logical() à partir de chaînes

as.logical('TRUE') et as.logical('FALSE') convertissent les représentations sous forme de chaînes. R accepte également 'T' et 'F' comme abréviations. Toute autre valeur (y compris 'true' en minuscules) renvoie NA.

cat('as.logical("TRUE"):  ', as.logical('TRUE'), '
')   # TRUE
cat('as.logical("FALSE"): ', as.logical('FALSE'), '
')  # FALSE
cat('as.logical("T"):     ', as.logical('T'), '
')      # TRUE
cat('as.logical("F"):     ', as.logical('F'), '
')      # FALSE
cat('as.logical("yes"):   ', as.logical('yes'), '
')    # NA (not recognised)
cat('as.logical("true"):  ', as.logical('true'), '
')   # NA (case-sensitive!)

De numeric à character

as.character(x) convertit un nombre en sa représentation sous forme de chaîne. Cette fonction est utile pour créer des libellés ou des identifiants, ou lorsque vous devez insérer des nombres dans des chaînes.

num_val <- 3.14159
char_val <- as.character(num_val)
cat('as.character(3.14159):', char_val, '
')  # '3.14159'
cat('class:', class(char_val), '
')           # character

# Building labels
ids <- 1:5
labels <- paste0('Item_', as.character(ids))
cat('Labels:', labels, '
')

De character à numeric

as.numeric('3.14') analyse une chaîne et la convertit en double. Si la chaîne ne peut pas être interprétée comme un nombre, R renvoie NA avec un avertissement. Validez toujours les entrées avant la conversion dans du code destiné à la production.

cat('as.numeric("3.14"):  ', as.numeric('3.14'), '
')   # 3.14
cat('as.numeric("100"):   ', as.numeric('100'), '
')    # 100
cat('as.numeric("-5.5"):  ', as.numeric('-5.5'), '
')   # -5.5
cat('as.numeric("abc"):   ', as.numeric('abc'), '
')    # NA with warning
cat('as.numeric("1e3"):   ', as.numeric('1e3'), '
')    # 1000 (sci notation OK)

De logical à character

as.character(TRUE) produit la chaîne 'TRUE'. Cette fonction est utile lorsque vous devez inclure des valeurs logical dans une sortie textuelle, des exportations de fichiers ou des concaténations de chaînes.

flag_t <- TRUE
flag_f <- FALSE

cat('as.character(TRUE): ', as.character(flag_t), '
')  # 'TRUE'
cat('as.character(FALSE):', as.character(flag_f), '
')  # 'FALSE'
cat('class:', class(as.character(flag_t)), '
')         # character

# In paste()
message <- paste('System status:', as.character(flag_t))
cat(message, '
')

Conversion aller-retour

La plupart des conversions sont réversibles (aller-retour), mais peuvent entraîner une certaine perte : numeric -> character -> numeric peut perdre en précision selon la manière dont le nombre est formaté sous forme de chaîne.

original <- 3.141592653589793
char_version <- as.character(original)
back_to_num <- as.numeric(char_version)

cat('Original:  ', original, '
')
cat('As string: ', char_version, '
')
cat('Back:      ', back_to_num, '
')
cat('Identical?:', identical(original, back_to_num), '
')
cat('Equal?:    ', original == back_to_num, '
')

Convertir des vecteurs d’origines mixtes

Lorsque vous appliquez as.numeric() à un vecteur character, chaque élément est converti indépendamment. Les éléments qui ne peuvent pas être analysés deviennent NA. Il s’agit de la méthode standard pour nettoyer des données d’apparence numérique lues depuis des fichiers CSV.

# Simulated data from CSV (all read as character)
raw_data <- c('42', '37.5', 'N/A', '55', '', '28.0')
cat('Raw character data:', raw_data, '
')

numeric_data <- suppressWarnings(as.numeric(raw_data))
cat('Converted:         ', numeric_data, '
')  # 42 37.5 NA 55 NA 28
cat('NA count:          ', sum(is.na(numeric_data)), '
')

Conversion logique dans ifelse()

Combiner as.numeric() avec ifelse(), ou multiplier directement par un vecteur logical, est une pratique idiomatique courante pour attribuer des scores conditionnels ou créer des variables dérivées dans l’analyse des données.

# Score: 1 for correct, 0 for incorrect
quiz_answers <- c('A', 'C', 'B', 'D', 'B')
correct      <- c('A', 'B', 'B', 'D', 'C')

is_correct <- quiz_answers == correct
cat('Correct:  ', is_correct, '
')
cat('As 0/1:   ', as.numeric(is_correct), '
')
cat('Score:    ', sum(is_correct), '/', length(is_correct), '
')

Résumé des conversions

Voici un résumé des principales conversions entre logical et character :

  • as.logical(0) → FALSE ; toute valeur non nulle → TRUE
  • as.logical('TRUE'/'T') → TRUE ; sensible à la casse ; les autres valeurs → NA
  • as.numeric(TRUE) → 1 ; as.numeric(FALSE) → 0
  • as.character(x) → représentation de x sous forme de chaîne
  • as.numeric('3.14') → 3.14 ; les chaînes non numériques → NA avec un avertissement
# All conversions in one snippet
cat('logical->num:  ', as.numeric(c(TRUE, FALSE)), '
')
cat('num->logical:  ', as.logical(c(0, 1, -1, 0.5)), '
')
cat('char->num:     ', suppressWarnings(as.numeric(c('5', 'abc', '3.1'))), '
')
cat('char->logical: ', as.logical(c('TRUE', 'FALSE', 'yes')), '
')
cat('logical->char: ', as.character(c(TRUE, FALSE)), '
')

Vérification rapide

À quelle valeur s’évalue as.numeric(TRUE) + as.numeric(FALSE) dans R ?

Récapitulatif : conversion des types logical et character

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

  • as.logical(0) → FALSE ; une valeur non nulle → TRUE ; 'TRUE'/'T' → TRUE
  • as.numeric(TRUE) → 1 ; as.numeric(FALSE) → 0
  • as.character(x) convertit toute valeur en sa forme textuelle
  • as.numeric('3.14') analyse une chaîne numérique ; les chaînes non valides → NA
  • as.logical('true') vaut NA : la correspondance est sensible à la casse ('TRUE' fonctionne)
  • Les conversions sont généralement réversibles ; utilisez suppressWarnings() lors de la conversion de colonnes contenant des entrées qui doivent produire des NA
# Practical: parse a messy survey score column
raw_scores <- c('8', '7', 'N/A', '9', 'skip', '6')
numeric_scores <- suppressWarnings(as.numeric(raw_scores))
cat('Parsed:', numeric_scores, '
')
cat('Valid responses:', sum(!is.na(numeric_scores)), '
')
cat('Average score:  ', round(mean(numeric_scores, na.rm = TRUE), 2), '
')

Questions Fréquemment Posées

La leçon « Conversions logique et caractère » est-elle gratuite ?

Oui — le texte complet de « Conversions logique et caractère » 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 « Conversions logique et caractère » ?

Convertissez des valeurs entre les types logical, character et numeric avec as.logical() et as.character(). 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 3 sur 4.

Combien de temps prend la leçon « Conversions logique et caractère » ?

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. Vue d’ensemble du système de types de R
  2. Convertir entre les types numériques
  3. Conversions logique et caractère
  4. Pièges de la coercition et bonnes pratiques
← Retour à R Academy