0Pricing
R Academy · Lezione

Conversione tra tipi numerici

Usi in sicurezza as.integer(), as.double() e as.numeric().

Conversione tra tipi numerici è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Integer e double in R

R dispone di due tipi numerici: integer (numeri interi, creati con il suffisso L) e double (virgola mobile, il tipo predefinito per i valori numerici letterali). Nella maggior parte dei casi R utilizza double, ma distinguerli è importante per la sicurezza dei tipi e l'efficienza della memoria.

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() — Conversione a intero

as.integer(x) converte un valore in intero troncando (non arrotondando) la parte decimale. Ciò significa che 3.9 diventa 3, non 4. Il suffisso L è una forma sintattica abbreviata per i valori letterali interi.

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() e as.numeric()

as.double(x) e as.numeric(x) sono equivalenti: entrambi convertono in un valore double (a virgola mobile). Li utilizzi per convertire gli interi in double quando è necessaria una precisione frazionaria.

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

Aritmetica con gli interi

L'aritmetica con gli interi in R produce interi per +, - e *, ma restituisce sempre un double per /. Questo può sorprendere se si prevede che la divisione intera rimanga di tipo intero.

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

Troncamento e arrotondamento

Una distinzione fondamentale: as.integer() tronca (elimina i decimali), mentre round() arrotonda al numero intero più vicino. Specifichi sempre chiaramente quale comportamento intende ottenere.

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

Rischio di overflow degli interi

Gli interi in R sono a 32 bit e possono contenere valori fino a circa ±2,1 miliardi. Il superamento di questo intervallo produce un NA con un avviso. I double possono contenere valori molto più grandi (fino a circa 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

Il suffisso L nei vettori

Può creare vettori di interi utilizzando il suffisso L su ogni elemento oppure passando una sequenza a as.integer(). L'operatore due punti : produce automaticamente interi.

# 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

Memoria e prestazioni

Gli interi utilizzano 4 byte per elemento; i double ne utilizzano 8. Per vettori molto grandi di numeri interi, l'uso degli interi può dimezzare il consumo di memoria. Tuttavia, le operazioni aritmetiche tra tipi diversi promuovono automaticamente il risultato a 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)), '
')

Verifica della memorizzazione come intero con is.integer()

Utilizzi sempre is.integer() (non is.numeric()) quando deve verificare specificamente la memorizzazione come intero. Un numero senza il suffisso L è un double, anche se appare come un numero intero.

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

Esempio di flusso di conversione

Un flusso di lavoro pratico: legga i dati come double (impostazione predefinita), esegua i calcoli, quindi converta esplicitamente i risultati in interi quando sono necessari numeri interi (ad esempio, conteggi, indici e ID).

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

Riepilogo della conversione numerica

Funzioni chiave per la conversione dei tipi numerici:

  • as.integer(x) — tronca a intero (elimina i decimali, verso zero)
  • as.double(x) / as.numeric(x) — converte in double
  • round(x) — arrotonda al valore più vicino (da utilizzare per valori simili a interi)
  • floor(x) / ceiling(x) — arrotonda per difetto / per eccesso
  • Sintassi 5L — valore letterale intero (non è necessaria alcuna conversione)
  • 1:n — produce sempre interi
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

Verifica rapida

Che cosa restituisce as.integer(3.9) in R?

Riepilogo: conversione dei tipi numerici

Ottimo! Concetti chiave di questa lezione:

  • R dispone di due tipi numerici: integer (suffisso L, 4 byte) e double (predefinito, 8 byte)
  • as.integer(x) tronca verso zero: non arrotonda
  • as.double() e as.numeric() sono identici: convertono in double
  • / restituisce sempre un double, anche con operandi integer
  • 1:n crea sequenze di interi; i valori numerici letterali senza L sono double
  • L'overflow degli interi a circa 2,1 miliardi: utilizzi double per numeri interi molto grandi
# 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)

Domande Frequenti

La lezione «Conversione tra tipi numerici» è gratuita?

Sì — il testo completo di «Conversione tra tipi numerici» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Conversione tra tipi numerici»?

Usi in sicurezza as.integer(), as.double() e as.numeric(). Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Conversione tra tipi numerici»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Panoramica del sistema dei tipi di R
  2. Conversione tra tipi numerici
  3. Conversione tra logical e character
  4. Problemi e buone pratiche nella coercizione
← Torna a R Academy