Operatori in R
Gli operatori in R sono simboli speciali che eseguono operazioni su uno o piu’ valori (operandi). R offre un ricco insieme di operatori che spaziano dall’aritmetica di base alle operazioni logiche avanzate, fino al moderno operatore pipe. In questa guida esploreremo tutte le categorie di operatori disponibili.
Operatori Aritmetici
Gli operatori aritmetici vengono utilizzati per eseguire calcoli matematici. R supporta tutte le operazioni aritmetiche fondamentali e alcune operazioni specifiche molto utili.
a <- 17
b <- 5
# Addizione
cat("a + b =", a + b, "\n") # 22
# Sottrazione
cat("a - b =", a - b, "\n") # 12
# Moltiplicazione
cat("a * b =", a * b, "\n") # 85
# Divisione
cat("a / b =", a / b, "\n") # 3.4
# Esponente (potenza)
cat("a ^ b =", a ^ b, "\n") # 1419857
# Modulo (resto della divisione)
cat("a %% b =", a %% b, "\n") # 2
# Divisione intera
cat("a %/% b =", a %/% b, "\n") # 3
Gli operatori %% (modulo) e %/% (divisione intera) sono particolarmente utili. Il modulo restituisce il resto della divisione, mentre la divisione intera restituisce il quoziente senza la parte decimale.
# Applicazione pratica: verificare se un numero e' pari o dispari
numero <- 42
if (numero %% 2 == 0) {
cat(numero, "e' pari\n")
} else {
cat(numero, "e' dispari\n")
}
# 42 e' pari
# Operazioni su vettori (elemento per elemento)
v1 <- c(10, 20, 30)
v2 <- c(3, 4, 5)
print(v1 + v2) # [1] 13 24 35
print(v1 * v2) # [1] 30 80 150
print(v1 %% v2) # [1] 1 0 0
print(v1 %/% v2) # [1] 3 5 6
Operatori di Confronto
Gli operatori di confronto (o relazionali) restituiscono un valore logico TRUE o FALSE in base alla relazione tra i due operandi.
x <- 10
y <- 20
# Uguale a
cat("x == y:", x == y, "\n") # FALSE
# Diverso da
cat("x != y:", x != y, "\n") # TRUE
# Minore di
cat("x < y:", x < y, "\n") # TRUE
# Maggiore di
cat("x > y:", x > y, "\n") # FALSE
# Minore o uguale a
cat("x <= y:", x <= y, "\n") # TRUE
# Maggiore o uguale a
cat("x >= y:", x >= y, "\n") # FALSE
Gli operatori di confronto funzionano anche su vettori, restituendo un vettore di valori logici:
voti <- c(28, 18, 30, 25, 15, 22)
# Confronto elemento per elemento
sufficienti <- voti >= 18
print(sufficienti) # [1] TRUE TRUE TRUE TRUE FALSE TRUE
# Filtrare i valori con il confronto
voti_validi <- voti[voti >= 18]
print(voti_validi) # [1] 28 18 30 25 22
# Contare quanti sono sufficienti
cat("Voti sufficienti:", sum(voti >= 18), "\n") # 5
# Confronto tra stringhe (ordine lessicografico)
cat("'abc' < 'abd':", "abc" < "abd", "\n") # TRUE
cat("'a' == 'A':", "a" == "A", "\n") # FALSE
Operatori Logici
Gli operatori logici consentono di combinare espressioni booleane. R offre due versioni: operatori vettorizzati e operatori a corto circuito.
Operatori Vettorizzati (&, |, !)
Questi operatori lavorano elemento per elemento su vettori interi:
a <- c(TRUE, TRUE, FALSE, FALSE)
b <- c(TRUE, FALSE, TRUE, FALSE)
# AND logico (elemento per elemento)
cat("a & b:", a & b, "\n") # TRUE FALSE FALSE FALSE
# OR logico (elemento per elemento)
cat("a | b:", a | b, "\n") # TRUE TRUE TRUE FALSE
# NOT logico
cat("!a:", !a, "\n") # FALSE FALSE TRUE TRUE
Operatori a Corto Circuito (&&, ||)
Questi operatori valutano solo il primo elemento e si fermano appena il risultato e’ determinato. Sono ideali nelle espressioni condizionali if.
x <- 5
# && valuta solo cio' che serve
if (x > 0 && x < 10) {
cat("x e' tra 0 e 10\n")
}
# x e' tra 0 e 10
# || si ferma se la prima condizione e' TRUE
if (x < 0 || x > 3) {
cat("x e' fuori dall'intervallo [0, 3]\n")
}
# x e' fuori dall'intervallo [0, 3]
# Differenza pratica tra & e &&
v <- c(TRUE, FALSE, TRUE)
w <- c(FALSE, TRUE, TRUE)
# & lavora su tutto il vettore
print(v & w) # [1] FALSE FALSE TRUE
# && considera solo il primo elemento
print(v && w) # [1] FALSE
Utilizzo Pratico con i Dati
eta <- c(25, 16, 30, 14, 45, 17)
reddito <- c(30000, 0, 50000, 0, 60000, 5000)
# Maggiorenni con reddito superiore a 20000
filtro <- (eta >= 18) & (reddito > 20000)
print(filtro) # [1] TRUE FALSE TRUE FALSE TRUE FALSE
# Indici che soddisfano la condizione
which(filtro) # [1] 1 3 5
Operatori di Assegnazione
R offre diversi operatori per assegnare valori alle variabili:
# Freccia sinistra (consigliato)
x <- 10
# Uguale
y = 20
# Freccia destra
30 -> z
# Assegnazione globale (da dentro una funzione)
# x <<- 10
# 10 ->> x
cat("x:", x, "\n") # 10
cat("y:", y, "\n") # 20
cat("z:", z, "\n") # 30
La differenza tra <- e = si manifesta nelle chiamate a funzione:
# Con =, il valore viene assegnato al parametro della funzione
media1 <- mean(x = c(1, 2, 3))
# x non esiste come variabile nell'ambiente
# Con <-, il valore viene assegnato sia al parametro che all'ambiente
media2 <- mean(x <- c(4, 5, 6))
print(x) # [1] 4 5 6 (x esiste ora nell'ambiente)
Operatore Pipe
L’operatore pipe consente di concatenare operazioni in modo leggibile, passando il risultato di un’espressione come primo argomento della funzione successiva. R offre due versioni del pipe.
Pipe Nativo |> (R 4.1+)
Il pipe nativo |> e’ stato introdotto in R 4.1 ed e’ integrato nel linguaggio senza necessita’ di pacchetti aggiuntivi.
# Senza pipe (funzioni annidate, difficile da leggere)
risultato <- round(mean(c(1.5, 2.3, 3.7, 4.1, 5.9)), 1)
print(risultato) # [1] 3.5
# Con il pipe nativo |> (leggibile da sinistra a destra)
risultato <- c(1.5, 2.3, 3.7, 4.1, 5.9) |>
mean() |>
round(1)
print(risultato) # [1] 3.5
# Esempio con manipolazione di stringhe
" ciao mondo " |>
trimws() |>
toupper() |>
nchar() |>
print() # [1] 10
Pipe di magrittr %>%
Il pipe %>% del pacchetto magrittr (incluso in tidyverse) e’ stato il primo operatore pipe disponibile in R ed offre alcune funzionalita’ aggiuntive.
# Richiede il pacchetto magrittr o dplyr
# library(magrittr)
# oppure
# library(dplyr)
# Utilizzo base (identico a |>)
# c(1, 2, 3, 4, 5) %>%
# mean() %>%
# round(2)
# Funzionalita' avanzata: il punto . come segnaposto
# "mondo" %>% paste("Ciao", ., "!")
# [1] "Ciao mondo !"
Confronto tra |> e %>%
# |> (pipe nativo)
# Pro: nessun pacchetto aggiuntivo, leggermente piu' veloce
# Contro: non supporta il segnaposto . (fino a R 4.2)
# %>% (magrittr)
# Pro: supporta il punto come segnaposto, piu' flessibile
# Contro: richiede il pacchetto magrittr/dplyr
# A partire da R 4.2, il pipe nativo supporta il segnaposto _
# con l'obbligo di usare argomenti con nome:
# mtcars |> lm(mpg ~ wt, data = _)
Esempio Pratico con Pipe
# Analisi di un vettore di temperature
temperature <- c(22.5, 19.3, 25.1, 18.7, 30.2, 27.8, 21.4)
# Approccio senza pipe (funzioni annidate)
risultato <- paste("Media:", round(mean(temperature), 1), "gradi")
print(risultato) # [1] "Media: 23.6 gradi"
# Approccio con pipe (molto piu' leggibile)
temperature |>
mean() |>
round(1) |>
paste("Media:", ... = _, "gradi") -> risultato_pipe
# Filtraggio e calcolo con pipe
temperature |>
(\(x) x[x > 20])() |>
mean() |>
round(1) |>
cat("Media temperature > 20:", ... = _, "\n")
# Media temperature > 20: 25.4
Precedenza degli Operatori
In R, gli operatori seguono un ordine di precedenza che determina quale operazione viene eseguita per prima:
# Ordine di precedenza (dal piu' alto al piu' basso):
# 1. ^ (esponente)
# 2. - (unario) (negazione)
# 3. %% %/% (modulo, divisione intera)
# 4. * / (moltiplicazione, divisione)
# 5. + - (addizione, sottrazione)
# 6. < > <= >= (confronto)
# 7. == != (uguaglianza)
# 8. ! (NOT logico)
# 9. & && (AND logico)
# 10. | || (OR logico)
# 11. <- -> (assegnazione)
# Esempi di precedenza
cat("2 + 3 * 4 =", 2 + 3 * 4, "\n") # 14 (non 20)
cat("(2 + 3) * 4 =", (2 + 3) * 4, "\n") # 20
cat("2 ^ 3 ^ 2 =", 2 ^ 3 ^ 2, "\n") # 512 (^ e' associativo a destra)
cat("TRUE | FALSE & FALSE:", TRUE | FALSE & FALSE, "\n") # TRUE (& ha precedenza)
Conclusioni
Gli operatori in R coprono un’ampia gamma di operazioni, dall’aritmetica di base alla logica avanzata. Gli operatori aritmetici %% e %/% sono specifici e molto utili per operazioni con numeri interi. La distinzione tra operatori vettorizzati (&, |) e a corto circuito (&&, ||) e’ fondamentale per scrivere codice corretto. L’operatore pipe, sia nella versione nativa |> che in quella di magrittr %>%, trasforma il modo di scrivere codice R rendendolo piu’ leggibile e manutenibile.