Operatori in R: aritmetici, di confronto, logici, %in% e %%

Gli operatori che R ti mette a disposizione

Gli operatori di R si dividono in quattro gruppi: aritmetici (+ - * / ^ %% %/%), di confronto (== != < <= > >=), logici (& | && || ! xor) e il test di appartenenza %in%. Due cose li rendono diversi dalla maggior parte dei linguaggi: quasi tutti sono vettorizzati, cioè lavorano su interi vettori in una volta, elemento per elemento, e R ha due operatori AND e due operatori OR che non sono intercambiabili. Questa pagina li copre tutti, più le trappole di precedenza che producono risposte sbagliate senza avvisarti.

Aritmetica: +, -, *, /, ^, %% e %/%

I primi cinque fanno quello che ti aspetti. I due racchiusi tra segni di percentuale, %% (modulo, il resto) e %/% (divisione intera, il quoziente), sono quelli che la gente cerca:

a <- 17
b <- 5

print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4
print(a ^ b)    # 1419857
print(a %% b)   # 2  - the remainder of 17 / 5
print(a %/% b)  # 3  - how many whole times 5 fits into 17

Nota che / fa sempre una divisione in virgola mobile: 17 / 5 è 3.4, mai 3. Se vuoi la parte intera, è proprio a questo che serve %/%.

Il lavoro quotidiano di %% è la divisibilità. Un numero è pari quando la divisione per 2 non lascia resto:

n <- 42
print(n %% 2 == 0)   # TRUE - even

print(-7 %% 3)       # 2, not -1

Vale la pena soffermarsi sulla seconda riga: con un operando negativo, il %% di R restituisce un risultato con il segno del divisore (-7 %% 3 è 2, perché -7 = -3 * 3 + 2). Alcuni linguaggi fanno il contrario; se stai portando codice da un altro linguaggio, controlla.

Gli operatori di confronto sono vettorizzati

==, !=, <, <=, >, >= confrontano elemento per elemento e restituiscono un vettore logico, non una singola risposta:

scores <- c(45, 72, 88, 60)

print(scores >= 60)           # FALSE TRUE TRUE TRUE
print(scores[scores >= 60])   # 72 88 60

È il motore dietro quasi tutti i filtri in R: confronti un intero vettore con un valore, ottieni una maschera logica e usi la maschera per estrarre un sottoinsieme. Una cautela con == sui decimali: i numeri in virgola mobile sono memorizzati in modo approssimato, quindi 0.1 + 0.2 == 0.3 è FALSE. Per confrontare decimali, preferisci all.equal() o verifica abs(x - y) < 1e-9.

Operatori logici: & contro && (la confusione classica)

R ha due operatori AND e due operatori OR, e scegliere quello sbagliato è un rito di passaggio.

& e | sono vettorizzati. Combinano due vettori logici elemento per elemento:

sunny <- c(TRUE, TRUE, FALSE, FALSE)
warm  <- c(TRUE, FALSE, TRUE, FALSE)

print(sunny & warm)   # TRUE FALSE FALSE FALSE
print(sunny | warm)   # TRUE TRUE TRUE FALSE
print(!sunny)         # FALSE FALSE TRUE TRUE

Usali ogni volta che costruisci un filtro sui dati: df[df$age > 30 & df$city == "Lisbon", ].

&& e || sono scalari e vanno in cortocircuito. Prendono singoli valori, restituiscono un singolo TRUE/FALSE e saltano del tutto il secondo operando se il primo decide già la risposta:

x <- 8

print(x > 0 && x %% 2 == 0)         # TRUE - both checked
print(x < 0 && stop("never runs"))  # FALSE - stop() is never evaluated

La seconda riga mostra il cortocircuito: dato che x < 0 è FALSE, R non valuta mai la chiamata a stop(). È esattamente per questo che && va nelle condizioni di if(): puoi scrivere if (!is.na(x) && x > 10) e la parte x > 10 viene saltata senza rischi quando x è NA.

La regola pratica: &/| per i vettori e il filtraggio dei dati, &&/|| per le condizioni di if(). E da R 4.3 la regola è imposta sul serio: passare a && o || un vettore di lunghezza maggiore di 1 è un errore (le versioni più vecchie di R usavano in silenzio solo il primo elemento, e questo ha nascosto bug reali per anni).

xor(a, b) completa il gruppo: TRUE quando esattamente uno dei due è TRUE.

print(xor(TRUE, FALSE))  # TRUE
print(xor(TRUE, TRUE))   # FALSE

%in%: verificare l'appartenenza

x %in% table chiede, per ogni elemento di x, "compare da qualche parte in table?". È uno degli operatori più usati nel codice R reale:

basket <- c("apple", "banana", "cherry")

print("banana" %in% basket)   # TRUE
print("mango" %in% basket)    # FALSE

wanted <- c("cherry", "mango", "apple")
print(wanted %in% basket)     # TRUE FALSE TRUE

Il lato verificato può essere un intero vettore, e questo rende %in% lo strumento naturale per filtrare righe in base a un insieme di valori ammessi.

Batte anche l'alternativa che scriveresti altrimenti, una catena di == incollati con |:

day <- "sat"

print(day == "sat" | day == "sun")   # works, but scales badly
print(day %in% c("sat", "sun"))      # same answer, stays readable

Con cinque valori ammessi, la catena di == diventa un muro di ripetizioni; la versione con %in% allunga solo il vettore. C'è un secondo vantaggio, più sottile: %in% non restituisce mai NA:

print(NA == 1)             # NA - comparison with a missing value is unknown
print(NA %in% c(1, 2, 3))  # FALSE - %in% gives a definite answer

NA == 1 è NA perché R non può sapere se un valore sconosciuto è uguale a 1, un comportamento trattato a fondo in valori mancanti. Quell'NA poi avvelena qualsiasi if() che raggiunge. %in% aggira del tutto il problema rispondendo sempre TRUE o FALSE, ed è per questo che è la scelta più sicura per le condizioni su dati che potrebbero mancare.

Trappole di precedenza

Due trappole di precedenza degli operatori sono responsabili di una quota sproporzionata di momenti "R è rotto". Primo, ^ ha la precedenza sul meno unario:

print(-2^2)     # -4  - parsed as -(2^2)
print((-2)^2)   #  4  - the square of negative two

Secondo, i due punti hanno la precedenza sull'aritmetica binaria:

n <- 5

print(1:n - 1)     # 0 1 2 3 4  - parsed as (1:n) - 1
print(1:(n - 1))   # 1 2 3 4    - probably what you meant

Nel dubbio, aggiungi le parentesi. Non costano niente e ogni lettore (compreso il te del futuro) le interpreta nello stesso modo dell'interprete.

$ e [ ]: gli operatori di accesso

Vedrai di continuo anche $, [ ] e [[ ]]: tecnicamente sono operatori anche loro, usati per estrarre valori dalle strutture invece che per calcolare:

person <- list(name = "Rosa", age = 30)

print(person$name)     # by name, with $
print(person[["age"]]) # by name, with [[ ]]

Sono trattati per intero nelle pagine su vettori, liste e data frame; qui basta riconoscerli come membri della stessa famiglia di operatori.

Cosa ti porti a casa

• %% dà il resto, %/% il quoziente intero; x %% 2 == 0 verifica se un numero è pari.
• I confronti sono vettorizzati: restituiscono un vettore logico con cui puoi filtrare.
• &/| combinano vettori elemento per elemento; &&/|| servono per singoli valori negli if() e vanno in cortocircuito. Da R 4.3, && su un vettore più lungo è un errore.
• x %in% table sostituisce le catene di == e non restituisce mai NA.
• -2^2 è -4 e 1:n - 1 parte da 0: nel dubbio, metti le parentesi.

Prossimo passo: mettere al lavoro questi operatori dentro if, else e ifelse(), le istruzioni condizionali di R.