Tipi di dati in R: numeric, character, logical (typeof e class)

I tipi di dati in R

Ogni valore in R ha uno tra pochi tipi atomici. Quattro di questi fanno quasi tutto il lavoro:

• double: numeri decimali, come 3.14, -2, 1e6. È ciò che R intende con "numeric" ed è il tipo predefinito per qualsiasi numero tu scriva.
• integer: numeri interi memorizzati in modo esatto, scritti con il suffisso L: 42L.
• character: testo tra virgolette, come "hello".
• logical: i due valori di verità TRUE e FALSE (più NA, il valore mancante: vedi i valori mancanti).

Esiste anche complex (2 + 3i) per qualche calcolo occasionale di elaborazione dei segnali; puoi passare anni senza averne bisogno. typeof() ti dice di che tipo è un valore:

cat(typeof(3.14), "\n")
cat(typeof(42L), "\n")
cat(typeof("hello"), "\n")
cat(typeof(TRUE), "\n")
cat(typeof(2 + 3i), "\n")

Nota la prima riga: un numero semplice è un double anche se sembra intero. typeof(42) è "double"; solo 42L è un intero. Nell'analisi quotidiana la differenza conta raramente, perché R converte dall'uno all'altro in silenzio, ma spiega molti output di typeof() che altrimenti confonderebbero.

typeof() contro class(): perché non sono d'accordo

R ha due funzioni che sembrano entrambe rispondere a "che cos'è questo?", e rispondono a domande leggermente diverse.

• typeof() riporta il tipo di memorizzazione: come il valore sta in memoria.
• class() riporta il tipo di comportamento: l'etichetta che il meccanismo di dispatch dei metodi di R usa per decidere, per esempio, quale print o summary eseguire.

Per i valori semplici le risposte differiscono solo nel vocabolario:

x <- 3.14
cat(typeof(x), "\n")
cat(class(x), "\n")

typeof() dice double (la memorizzazione), class() dice numeric (il comportamento). Con le strutture la distanza aumenta:

m <- matrix(1:4, nrow = 2)
cat(typeof(m), "\n")
print(class(m))

La matrice è memorizzata come un semplice vettore di interi, ma si comporta come una matrice: è class() a dire a R di stamparla come una griglia. La stessa divisione compare con i data frame (typeof dice "list", class dice "data.frame") e con le date (typeof dice "double", class dice "Date").

La regola pratica: usa class() quando vuoi sapere cosa è qualcosa nel senso quotidiano, e typeof() quando stai facendo debug di ciò che R fa dietro le quinte.

Controllare i tipi con is.*()

Ogni tipo ha un predicato corrispondente che restituisce TRUE o FALSE, comodo dentro le funzioni che devono validare il proprio input:

x <- 10
cat(is.numeric(x), is.character(x), is.logical(x), "\n")

Una trappola da conoscere: is.numeric() è TRUE sia per i double sia per gli integer (sono entrambi numeri), ma is.integer() controlla la memorizzazione, quindi è FALSE per un semplice 42:

cat(is.numeric(42L), "\n")
cat(is.integer(42), "\n")
cat(is.integer(42L), "\n")

Se ti sei mai stupito che is.integer(7) sia FALSE per un numero che in senso matematico è ovviamente intero, ecco il motivo. 7 è un double; 7L è un intero.

Convertire i tipi con as.*()

La conversione esplicita usa la famiglia as.*, una funzione per ogni tipo di destinazione:

cat(as.numeric("3.5") + 1, "\n")
cat(as.integer(7.9), "\n")
cat(as.character(42), "\n")
cat(as.logical("TRUE"), "\n")

Due comportamenti da ricordare. as.integer() tronca verso lo zero invece di arrotondare: 7.9 diventa 7. E quando una conversione non ha senso, R non genera un errore; restituisce NA e mostra un warning:

result <- as.numeric("abc")
print(result)

Eseguilo e vedrai NA più un warning "NAs introduced by coercion". È davvero utile: converti un'intera colonna di testo disordinato in numeri e le voci non interpretabili diventano NA invece di far crashare lo script. Ma significa anche che un NA silenzioso può infilarsi nei tuoi dati. Quando una conversione è importante, controlla dopo se sono comparsi nuovi NA.

I valori logici si convertono da e verso i numeri come ti aspetteresti: as.numeric(TRUE) è 1, as.logical(0) è FALSE. Ecco perché sum() di un vettore logico conta i TRUE:

passed <- c(TRUE, TRUE, FALSE, TRUE)
cat(sum(passed), "out of", length(passed), "\n")

Coercizione implicita: la regola del tipo unico per i vettori

Un vettore atomico in R può contenere un solo tipo. Combina valori misti con c() e R promuove in silenzio tutto al tipo più flessibile presente, seguendo una scala fissa:

logical → integer → double → character

print(c(TRUE, FALSE, 2L))
print(c(1L, 2L, 3.5))
print(c(1, 2, "three"))

I logici sono diventati 1 e 0, gli interi sono diventati double, e nell'ultima riga tutto è diventato testo: character vince sempre, perché qualsiasi valore si può scrivere come stringa. Puoi confermarlo con typeof():

cat(typeof(c(TRUE, 1L)), "\n")
cat(typeof(c(1L, 2.5)), "\n")
cat(typeof(c(1, "a")), "\n")

La coercizione è la causa numero uno dei bug del tipo "perché la mia colonna è testo?": una sola stringa "N/A" sparsa in una colonna di numeri forza l'intero vettore a character. Quando succede, correggi prima il valore colpevole, poi riconverti con as.numeric().

Cosa ti porti a casa

• Quattro tipi di uso quotidiano: double ("numeric"), integer (42L), character, logical.
• typeof() = come è memorizzato; class() = come si comporta. 3.14 è un double che si comporta come numeric.
• Controlla con is.numeric() e simili; converti con as.numeric() e simili. Le conversioni fallite danno NA con un warning, non un errore.
• I vettori contengono un solo tipo; mescolare forza la coercizione lungo logical → integer → double → character.

Prossimo passo: uno sguardo più da vicino ai tipi numerici, con arrotondamenti, funzioni matematiche e le sorprese della virgola mobile comuni a tutti i linguaggi.