0Pricing
R Academy · Leçon

Convertir entre les types numériques

Utilisez as.integer(), as.double() et as.numeric() en toute sécurité.

Convertir entre les types numériques 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.

Integer et double dans R

R possède deux types numériques : integer (nombres entiers, créés avec le suffixe L) et double (nombres à virgule flottante, type par défaut des littéraux numériques). La plupart du temps, R utilise double, mais les distinguer est important pour garantir la sûreté des types et optimiser la mémoire.

x_dbl <- 5        # double by default
x_int <- 5L       # integer (L suffix)

cat('typeof(5):  ', typeof(x_dbl), '
')  # double
cat('typeof(5L): ', typeof(x_int), '
')  # integer
cat('5 == 5L:    ', x_dbl == x_int, '
') # TRUE (values equal)
cat('identical:  ', identical(x_dbl, x_int), '
')  # FALSE (types differ)

as.integer() — Convertir en integer

as.integer(x) convertit une valeur en integer en tronquant (et non en arrondissant) sa partie décimale. Ainsi, 3.9 devient 3 et non 4. Le suffixe L est une notation abrégée pour les littéraux integer.

cat('as.integer(3.7):  ', as.integer(3.7), '
')   # 3 (truncated, not 4)
cat('as.integer(3.2):  ', as.integer(3.2), '
')   # 3
cat('as.integer(-2.9): ', as.integer(-2.9), '
')  # -2 (toward zero)
cat('as.integer(10.9): ', as.integer(10.9), '
')  # 10

# Compare with round
cat('round(3.7):        ', round(3.7), '
')       # 4

as.double() et as.numeric()

as.double(x) et as.numeric(x) sont équivalentes : toutes deux convertissent la valeur en double (à virgule flottante). Utilisez-les pour convertir des integer en double lorsque vous avez besoin de conserver une précision fractionnaire.

count <- 7L  # integer
cat('typeof(count):         ', typeof(count), '
')

dbl_count <- as.double(count)
cat('typeof(as.double(7L)): ', typeof(dbl_count), '
')  # double
cat('Value:                 ', dbl_count, '
')           # 7

# Division automatically promotes to double
cat('7L / 2L:              ', 7L / 2L, '
')            # 3.5 (double)
cat('typeof(7L / 2L):      ', typeof(7L / 2L), '
')    # double

Arithmétique avec integer

Dans R, l’arithmétique avec des integer produit des integer pour +, - et *, mais renvoie toujours un double pour /. Cela peut être surprenant si vous vous attendez à ce qu’une division entière reste entière.

a <- 6L
b <- 3L

cat('6L + 3L =', a + b, '| typeof:', typeof(a + b), '
')  # 9 integer
cat('6L - 3L =', a - b, '| typeof:', typeof(a - b), '
')  # 3 integer
cat('6L * 3L =', a * b, '| typeof:', typeof(a * b), '
')  # 18 integer
cat('6L / 3L =', a / b, '| typeof:', typeof(a / b), '
')  # 2 DOUBLE!
cat('6L %/% 3L =', a %/% b, '| typeof:', typeof(a %/% b), '
') # 2 integer

Troncature et arrondi

Une distinction essentielle : as.integer() tronque (supprime les décimales), tandis que round() arrondit au nombre entier le plus proche. Précisez toujours le comportement souhaité.

values <- c(2.1, 2.5, 2.9, -2.1, -2.5, -2.9)

cat('Original:     ', values, '
')
cat('as.integer():  ', as.integer(values), '
')  # truncate toward 0
cat('round():       ', round(values), '
')       # banker rounding
cat('floor():       ', floor(values), '
')       # round down
cat('ceiling():     ', ceiling(values), '
')     # round up

Risque de dépassement pour les integer

Dans R, les integer sont codés sur 32 bits et peuvent contenir des valeurs allant jusqu’à environ ±2,1 milliards. Dépasser cette plage produit un NA accompagné d’un avertissement. Les double peuvent contenir des valeurs bien plus grandes (jusqu’à environ 1,8 × 10^308).

max_int <- .Machine$integer.max
cat('Max integer:', max_int, '
')  # 2147483647

# Overflow produces NA
cat('max_int + 1L:', max_int + 1L, '
')  # NA with warning

# Double handles it fine
cat('as.double(max_int) + 1:', as.double(max_int) + 1, '
')  # 2147483648

Le suffixe L dans les vecteurs

Vous pouvez créer des vecteurs integer en utilisant le suffixe L pour chaque élément, ou en transmettant une séquence à as.integer(). L’opérateur deux-points : produit automatiquement des integer.

# Colon produces integers
seq_int <- 1:5
cat('1:5 typeof:', typeof(seq_int), '
')  # integer

# Explicit integer vector
vec_int <- c(10L, 20L, 30L, 40L)
cat('c(10L,...) typeof:', typeof(vec_int), '
')  # integer

# as.integer on a vector
vec_dbl <- c(1.1, 2.9, 3.5, 4.7)
cat('as.integer(c(1.1,...)):', as.integer(vec_dbl), '
')  # 1 2 3 4

Mémoire et performances

Les integer utilisent 4 octets par élément, contre 8 octets pour les double. Pour de très grands vecteurs de nombres entiers, l’utilisation d’integer peut diviser par deux la mémoire nécessaire. Cependant, les opérations arithmétiques entre types mixtes sont automatiquement converties en double.

n <- 1000000L

vec_int <- 1:n          # integer: 4 bytes each
vec_dbl <- as.double(1:n)  # double: 8 bytes each

cat('Integer vector size:', object.size(vec_int), 'bytes
')
cat('Double vector size: ', object.size(vec_dbl), 'bytes
')
cat('Ratio:', as.numeric(object.size(vec_dbl)) / as.numeric(object.size(vec_int)), '
')

Vérifier le stockage integer avec is.integer()

Utilisez toujours is.integer() (et non is.numeric()) lorsque vous devez précisément vérifier un stockage integer. Un nombre sans le suffixe L est de type double, même s’il ressemble à un nombre entier.

a <- 5    # looks like integer, but it is double
b <- 5L   # true integer

cat('is.integer(5):  ', is.integer(a), '
')   # FALSE!
cat('is.integer(5L): ', is.integer(b), '
')   # TRUE
cat('is.numeric(5):  ', is.numeric(a), '
')   # TRUE
cat('is.numeric(5L): ', is.numeric(b), '
')   # TRUE
cat('class(5):       ', class(a), '
')        # numeric
cat('class(5L):      ', class(b), '
')        # integer

Exemple de processus de conversion

Processus pratique : lire les données sous forme de double (valeur par défaut), effectuer les calculs, puis convertir explicitement les résultats en integer lorsque des nombres entiers sont requis (par exemple pour des comptes, des indices ou des identifiants).

# Simulated: reading counts as doubles (common from CSV)
counts_raw <- c(12.0, 8.0, 15.0, 3.0, 22.0)
cat('typeof raw:', typeof(counts_raw), '
')  # double

# Convert to integer for proper storage
counts_int <- as.integer(counts_raw)
cat('typeof converted:', typeof(counts_int), '
')  # integer
cat('Counts:', counts_int, '
')
cat('Total:', sum(counts_int), '
')

Résumé des conversions numériques

Principales fonctions de conversion des types numériques :

  • as.integer(x) — tronquer en integer (supprime les décimales, en allant vers zéro)
  • as.double(x) / as.numeric(x) — convertir en double
  • round(x) — arrondir à la valeur la plus proche (à utiliser pour les valeurs assimilables à des integer)
  • floor(x) / ceiling(x) — arrondir vers le bas / vers le haut
  • syntaxe 5L — littéral integer (aucune conversion nécessaire)
  • 1:n — produit toujours des integer
x <- 7.8
cat('as.integer(7.8):', as.integer(x), '
')  # 7 (truncate)
cat('round(7.8):     ', round(x), '
')       # 8
cat('floor(7.8):     ', floor(x), '
')       # 7
cat('ceiling(7.8):   ', ceiling(x), '
')     # 8

Vérification rapide

Que renvoie as.integer(3.9) dans R ?

Récapitulatif : conversion des types numériques

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

  • R possède deux types numériques : integer (suffixe L, 4 octets) et double (par défaut, 8 octets)
  • as.integer(x) tronque vers zéro : il n’effectue pas d’arrondi
  • as.double() et as.numeric() sont identiques : elles convertissent en double
  • / renvoie toujours un double, même lorsque ses opérandes sont des integer
  • 1:n crée des séquences d’integer ; les littéraux numériques sans L sont des double
  • Un dépassement d’integer survient vers 2,1 milliards : utilisez double pour les très grands nombres entiers
# Demonstrate truncation vs rounding
test_vals <- c(0.1, 0.5, 0.9, 1.5, 2.5, 3.7)
cat('Values:      ', test_vals, '
')
cat('as.integer(): ', as.integer(test_vals), '
')  # truncation
cat('round():      ', round(test_vals), '
')       # nearest (banker)

Questions Fréquemment Posées

La leçon « Convertir entre les types numériques » est-elle gratuite ?

Oui — le texte complet de « Convertir entre les types numériques » 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 « Convertir entre les types numériques » ?

Utilisez as.integer(), as.double() et as.numeric() en toute sécurité. 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 « Convertir entre les types numériques » ?

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