Ciclo for in R: sintassi, seq_along, break, next e quando evitarlo

Il ciclo for di base

Un ciclo for in R esegue un blocco di codice una volta per ogni elemento di un vettore o di una lista. La variabile del ciclo assume a turno ogni valore:

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

for (fruit in fruits) {
  print(fruit)
}

Tre elementi, tre passaggi. Non c'è un contatore da impostare né una condizione da mantenere: for (fruit in fruits) si legge "per ogni frutto in fruits", ed è esattamente ciò che fa. La stessa forma scorre gli elementi di una lista, una sequenza di numeri (for (i in 1:10)) o i nomi di qualsiasi cosa tramite names().

Per stampare dentro un ciclo servono print() o cat()

In console, scrivere x stampa il suo valore. Dentro il corpo di un ciclo no: la stampa automatica avviene solo al livello più alto, e un'espressione nuda dentro un ciclo viene valutata e buttata via:

for (n in 1:3) {
  n                       # evaluated, silently discarded
  cat("n is", n, "\n")    # this is what actually prints
}

Quindi quando un ciclo "non fa niente", questa è la prima cosa da controllare. Usa print() per dare un'occhiata veloce a qualsiasi valore, oppure cat() quando componi tu una riga di output (ricorda il "\n": cat() non lo aggiunge).

Scorrere gli indici con seq_along()

A volte ti serve la posizione oltre al valore: per scrivere in un altro vettore allo stesso indice, o per stampare un elenco numerato. Scorri gli indici con seq_along():

prices <- c(9.99, 4.50, 12.00)

for (i in seq_along(prices)) {
  cat("Item", i, "costs", prices[i], "\n")
}

Nel codice più vecchio vedrai for (i in 1:length(prices)), e nasconde un vero bug. Quando il vettore è vuoto, length() vale 0, e 1:0 non significa "nessuna iterazione": i due punti contano all'indietro:

empty <- numeric(0)

print(1:length(empty))   # 1 0  - two iterations against nothing!
print(seq_along(empty))  # integer(0) - zero iterations, as it should be

Un ciclo su 1:length(empty) viene eseguito due volte, indicizzando elementi che non esistono (empty[1] è NA, e gli assegnamenti creano voci fantasma). seq_along() restituisce una sequenza vuota per un vettore vuoto, quindi il corpo del ciclo semplicemente non viene mai eseguito. Fai di seq_along() un'abitudine; la sua sorella seq_len(n) fa lo stesso lavoro quando hai un conteggio invece di un vettore.

Raccogliere i risultati: prealloca, non far crescere

Il primo istinto naturale per accumulare risultati è questo:

squares <- c()
for (i in 1:10000) {
  squares <- c(squares, i^2)   # copies the ENTIRE vector every pass
}

Funziona, ma ogni c(squares, ...) alloca un vettore nuovo di zecca e ci copia dentro tutti gli elementi vecchi. Alla fine hai copiato circa 50 milioni di numeri per produrne 10.000. Questo anti-pattern del vettore che cresce è il motivo principale per cui si dice che i cicli di R sono lenti.

La soluzione: crea prima il risultato alla dimensione completa, poi assegna per indice:

n <- 5
squares <- numeric(n)          # c(0, 0, 0, 0, 0), allocated once

for (i in seq_len(n)) {
  squares[i] <- i^2
}

print(squares)

Per risultati che non sono numeri vale la stessa idea con character(n), logical(n) o vector("list", n) per una lista di cose arbitrarie. I cicli con preallocazione sono perfettamente veloci.

next e break

Due parole chiave guidano un ciclo dall'interno del suo corpo: next abbandona il passaggio corrente e salta all'elemento successivo; break esce del tutto dal ciclo.

for (n in 1:10) {
  if (n %% 2 != 0) next   # skip odd numbers
  if (n > 8) break        # stop once past 8
  print(n)
}

Questo stampa 2 4 6 8: i valori dispari vengono saltati da next, e quando arriva 10, break termina il ciclo prima di stampare. Usa next per escludere subito certi casi (mantiene il corpo principale senza rientri in più), e break quando un ciclo ha trovato ciò che cercava e non ha motivo di continuare.

Cicli annidati

Il corpo di un ciclo può contenere un altro ciclo. Il ciclo interno viene eseguito fino alla fine per ogni singolo passaggio di quello esterno; la dimostrazione classica è una tavola pitagorica:

for (i in 1:3) {
  for (j in 1:3) {
    cat(sprintf("%2d ", i * j))
  }
  cat("\n")
}

Per ogni riga i, il ciclo interno percorre tutte le colonne j, e l'a capo della riga viene stampato quando il ciclo interno finisce. I cicli annidati vanno bene su due livelli; da tre in su, di solito il corpo chiede di diventare una funzione, o l'intero calcolo chiede di diventare un outer() o un'operazione su matrici.

L'annidamento copre anche lo scorrimento di una lista di vettori: ciclo esterno sulla lista, ciclo interno (o meglio, una chiamata vettoriale) su ogni elemento:

results <- list(alice = c(80, 91), bob = c(72, 65, 88))

for (name in names(results)) {
  cat(name, "average:", mean(results[[name]]), "\n")
}

Nota che alla fine non c'è nessun ciclo interno: mean() gestisce l'intero vettore interno in una chiamata. Questa osservazione vale in generale, e ci porta alla parte onesta.

Quando non usare un ciclo

R è un linguaggio vettoriale: le sue operazioni di base lavorano già su interi vettori in una volta. Un ciclo che trasforma ogni elemento uno alla volta è spesso un modo più lungo di scrivere una riga sola:

prices <- c(100, 250, 40)

# The loop version
taxed <- numeric(length(prices))
for (i in seq_along(prices)) {
  taxed[i] <- prices[i] * 1.2
}
print(taxed)

# The vectorized version - same result
print(prices * 1.2)

Preferisci la forma vettoriale ogni volta che esiste: è più breve, più difficile da sbagliare e più veloce. Per applicare una funzione a ogni elemento di una lista, la famiglia apply (sapply, lapply, vapply) svolge lo stesso ruolo.

Ma non trasformare questo in un dogma del tipo "i cicli sono il male". Un ciclo è lo strumento giusto quando le iterazioni dipendono da quelle precedenti (stato che si accumula, simulazioni), quando produci effetti collaterali come scrivere file, o semplicemente quando il ciclo è la versione che tu e chi legge capite al primo sguardo. Un ciclo chiaro batte una riga ingegnosa che nessuno riesce a decifrare.

Cosa ti porti a casa

• for (x in v) { ... } esegue il corpo una volta per elemento, senza contatori da gestire.
• Dentro un ciclo, stampa esplicitamente con print() o cat(); le espressioni nude vengono scartate.
• Scorri le posizioni con seq_along(v), mai con 1:length(v): quest'ultimo viene eseguito due volte su un vettore vuoto.
• Prealloca i risultati con numeric(n) / vector("list", n) e assegna per indice; far crescere con c() copia tutto a ogni passaggio.
• next salta un passaggio, break esce; preferisci le operazioni vettoriali quando esistono, ma non temere un ciclo leggibile.

Prossimo passo: i cicli che vengono eseguiti finché succede qualcosa invece che una volta per elemento, cioè while e repeat.