PricingLoginStart free
R Academy · Lezione

Panoramica del sistema dei tipi di R

Comprenda i tipi double, integer, character, logical e complex.

Lezione 1 di 413 passaggi

Panoramica del sistema dei tipi di R è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Il sistema dei tipi di R

R dispone di un sistema dei tipi articolato. Ogni oggetto ha una classe (categoria di alto livello) e un tipo (modalità di memorizzazione di basso livello). Comprendere entrambi La aiuta a scrivere codice corretto ed efficiente e a eseguire il debug degli errori relativi ai tipi.

# Check class and type of various objects
cat('class(42L)    :', class(42L), '
')
cat('typeof(42L)   :', typeof(42L), '
')
cat('class(3.14)   :', class(3.14), '
')
cat('typeof(3.14)  :', typeof(3.14), '
')
cat('class(TRUE)   :', class(TRUE), '
')
cat('class("hello"):', class('hello'), '
')

class() rispetto a typeof()

class(x) restituisce la categoria di alto livello utilizzata dal sistema orientato agli oggetti di R (ad esempio, 'integer', 'numeric', 'matrix'). typeof(x) restituisce il tipo di memorizzazione C di basso livello (ad esempio, 'integer', 'double', 'closure').

m <- matrix(1:4, nrow = 2)
cat('class(matrix)  :', class(m), '
')   # matrix array
cat('typeof(matrix) :', typeof(m), '
')  # integer

f <- factor(c('a', 'b', 'a'))
cat('class(factor)  :', class(f), '
')   # factor
cat('typeof(factor) :', typeof(f), '
')  # integer (stored as int!)

cat('class(list)    :', class(list()), '
')  # list
cat('typeof(list)   :', typeof(list()), '
') # list

is.numeric() — Verifica numerica

is.numeric(x) restituisce TRUE sia per i valori integer sia per quelli double (e per le matrici numeriche). Verifica il supertipo numerico, non la modalità di memorizzazione specifica.

cat('is.numeric(3.14):', is.numeric(3.14), '
')    # TRUE (double)
cat('is.numeric(3L):  ', is.numeric(3L), '
')      # TRUE (integer)
cat('is.numeric(TRUE):', is.numeric(TRUE), '
')    # FALSE
cat('is.numeric("3"): ', is.numeric('3'), '
')     # FALSE
cat('is.numeric(NA):  ', is.numeric(NA), '
')      # FALSE (NA is logical)

is.integer() rispetto a is.double()

is.integer() verifica specificamente la memorizzazione come intero (creata con il suffisso L o con as.integer()). is.double() verifica la memorizzazione in virgola mobile (double). Entrambi sono sottotipi di numeric.

x_int <- 5L
x_dbl <- 5.0

cat('--- x_int = 5L ---
')
cat('is.integer:', is.integer(x_int), '
')  # TRUE
cat('is.double: ', is.double(x_int), '
')   # FALSE
cat('is.numeric:', is.numeric(x_int), '
')  # TRUE

cat('--- x_dbl = 5.0 ---
')
cat('is.integer:', is.integer(x_dbl), '
')  # FALSE
cat('is.double: ', is.double(x_dbl), '
')   # TRUE
cat('is.numeric:', is.numeric(x_dbl), '
')  # TRUE

is.character() — Verifica delle stringhe

is.character(x) restituisce TRUE se x è un vettore di caratteri (stringhe). Lo utilizzi per convalidare input che dovrebbero essere testo o per distinguere i tipi di NA numerici da quelli di carattere.

greetings <- c('hello', 'world', 'R')
numbers <- c(1, 2, 3)
numeric_string <- '42'

cat('is.character(greetings):      ', is.character(greetings), '
')
cat('is.character(numbers):        ', is.character(numbers), '
')
cat('is.character(numeric_string): ', is.character(numeric_string), '
')
cat('is.character(NA_character_):  ', is.character(NA_character_), '
')

is.logical() — Verifica booleana

is.logical(x) restituisce TRUE se x contiene valori logici (booleani). Tenga presente che, per impostazione predefinita, il valore NA senza tipo è un valore logico.

flags <- c(TRUE, FALSE, TRUE, NA)
cat('is.logical(flags): ', is.logical(flags), '
')   # TRUE
cat('is.logical(NA):    ', is.logical(NA), '
')      # TRUE (default NA is logical)
cat('is.logical(1):     ', is.logical(1), '
')       # FALSE
cat('is.logical("TRUE"):', is.logical('TRUE'), '
')  # FALSE
cat('typeof(NA):        ', typeof(NA), '
')          # logical

Gerarchia dei tipi di R

I tipi atomici di R formano una gerarchia dal più semplice al più complesso: logical < integer < double < complex < character. Quando si combinano tipi in un vettore, R converte tutti gli elementi nel tipo più complesso presente.

# Type hierarchy in action
cat('c(TRUE, 1L) type:     ', typeof(c(TRUE, 1L)), '
')   # integer
cat('c(1L, 1.5) type:      ', typeof(c(1L, 1.5)), '
')   # double
cat('c(1.5, 1+0i) type:    ', typeof(c(1.5, 1+0i)), '
') # complex
cat('c(1+0i, "a") type:   ', typeof(c(1+0i, 'a')), '
')  # character
cat('c(TRUE, "x") type:    ', typeof(c(TRUE, 'x')), '
') # character

Ispezione programmatica dei tipi

Può scrivere funzioni di ispezione dei tipi per verificare una lista di oggetti. La combinazione di class(), typeof() e length() fornisce un riepilogo completo della struttura di qualsiasi oggetto.

describe_type <- function(x, label) {
  cat(label, ': class =', class(x), ', typeof =', typeof(x),
      ', length =', length(x), '
')
}

describe_type(42L,         'integer literal')
describe_type(3.14,        'double literal')
describe_type(TRUE,        'logical')
describe_type('hello',     'character')
describe_type(c(1,2,3),    'numeric vector')
describe_type(list(1,'a'), 'list')

storage.mode() e mode()

storage.mode(x) è simile a typeof(x), ma utilizza la convenzione di denominazione S3 (ad esempio, restituisce 'double' invece di 'double'). mode(x) restituisce un raggruppamento leggermente più generico, che riunisce integer e double sotto 'numeric'.

x_int <- 5L
x_dbl <- 5.0

cat('mode(5L):         ', mode(x_int), '
')          # numeric
cat('mode(5.0):        ', mode(x_dbl), '
')          # numeric
cat('storage.mode(5L): ', storage.mode(x_int), '
')  # integer
cat('storage.mode(5.0):', storage.mode(x_dbl), '
')  # double
# mode() lumps int+dbl; storage.mode() / typeof() distinguish them

Ispezione dei tipi per liste e data frame

Per oggetti più complessi, come liste e data frame, sapply(df, class) applica class() a ogni colonna, restituendo un vettore denominato dei tipi di colonna: un modo rapido per verificare lo schema di un data frame.

df <- data.frame(
  id      = 1:3,
  name    = c('Alice', 'Bob', 'Carol'),
  score   = c(88.5, 79.0, 92.3),
  passed  = c(TRUE, TRUE, TRUE)
)
cat('Column types:
')
print(sapply(df, class))
cat('Column typeof:
')
print(sapply(df, typeof))

Riepilogo del sistema dei tipi

Ecco un rapido riferimento agli strumenti di ispezione dei tipi di R:

  • class(x) — nome della classe S3 di alto livello
  • typeof(x) — tipo di memorizzazione C di basso livello
  • is.numeric(x) — TRUE per integer o double
  • is.integer(x) — TRUE solo per la memorizzazione integer
  • is.double(x) — TRUE solo per double (virgola mobile)
  • is.character(x) — TRUE per le stringhe
  • is.logical(x) — TRUE per TRUE/FALSE/NA
x <- 42L
cat('class(42L):       ', class(x), '
')
cat('typeof(42L):      ', typeof(x), '
')
cat('is.numeric(42L):  ', is.numeric(x), '
')
cat('is.integer(42L):  ', is.integer(x), '
')
cat('is.double(42L):   ', is.double(x), '
')
cat('is.character(42L):', is.character(x), '
')

Verifica rapida

Che cosa restituisce is.numeric(5L) in R?

Rispondi nella lezione interattiva

Riepilogo: il sistema dei tipi di R

Ottimo lavoro! Concetti chiave di questa lezione:

  • class(x) restituisce il tipo di alto livello; typeof(x) restituisce il tipo di memorizzazione di basso livello
  • is.numeric() è TRUE sia per gli interi sia per i double
  • is.integer() e is.double() distinguono i due sottotipi numerici
  • Gerarchia dei tipi di R (dal basso all'alto): logical → integer → double → complex → character
  • La combinazione di tipi in un vettore attiva la conversione automatica al tipo più alto
  • sapply(df, class) verifica tutti i tipi di colonna in un data frame
# Type audit function
audit_types <- function(x, name = 'x') {
  cat(name, ': class=', class(x), ', typeof=', typeof(x),
      ', is.numeric=', is.numeric(x), '
')
}
audit_types(1L,      'integer')
audit_types(1.0,     'double')
audit_types(TRUE,    'logical')
audit_types('hello', 'character')
audit_types(1+2i,    'complex')
Gratis per iniziare

Impara R con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
43
Lezioni
159
Inizia a imparare gratisVisualizza il corso completo

Domande Frequenti

La lezione «Panoramica del sistema dei tipi di R» è gratuita?

Sì — il testo completo di «Panoramica del sistema dei tipi di R» è 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 «Panoramica del sistema dei tipi di R»?

Comprenda i tipi double, integer, character, logical e complex. 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 1 di 4.

Quanto tempo richiede la lezione «Panoramica del sistema dei tipi di R»?

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