Pętla for w R: składnia, seq_along, break, next i kiedy nie używać pętli

Podstawowa pętla for

Pętla for w R wykonuje blok kodu raz dla każdego elementu wektora lub listy. Zmienna pętli przyjmuje po kolei każdą wartość:

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

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

Trzy elementy, trzy przebiegi. Nie trzeba ustawiać licznika ani pilnować warunku: for (fruit in fruits) czyta się jako "dla każdego owocu w fruits" i dokładnie to się dzieje. Ten sam kształt przechodzi po elementach listy, sekwencji liczb (for (i in 1:10)) albo nazwach czegokolwiek przez names().

Wypisywanie w pętli wymaga print() lub cat()

W konsoli wpisanie x wypisuje jego wartość. W treści pętli już nie: automatyczne wypisywanie działa tylko na najwyższym poziomie, a gołe wyrażenie w pętli jest obliczane i wyrzucane:

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

Gdy więc pętla "nic nie robi", to pierwsza rzecz do sprawdzenia. Użyj print(), żeby szybko obejrzeć dowolną wartość, albo cat(), gdy samodzielnie składasz linię wyniku (pamiętaj o "\n", bo cat() go nie dodaje).

Pętla po indeksach z seq_along()

Czasem potrzebujesz nie tylko wartości, ale i pozycji: żeby zapisać coś w innym wektorze pod tym samym indeksem albo wypisać numerowaną listę. Przechodź po indeksach przez seq_along():

prices <- c(9.99, 4.50, 12.00)

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

W starszym kodzie zobaczysz for (i in 1:length(prices)), a to kryje prawdziwy błąd. Gdy wektor jest pusty, length() wynosi 0, a 1:0 nie oznacza "zero iteracji", bo dwukropek liczy w dół:

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

Pętla po 1:length(empty) wykonuje się dwa razy i indeksuje elementy, które nie istnieją (empty[1] to NA, a przypisania tworzą widmowe wpisy). seq_along() zwraca pustą sekwencję dla pustego wektora, więc treść pętli po prostu się nie wykonuje. Niech seq_along() stanie się nawykiem; jego krewny seq_len(n) robi to samo, gdy masz liczbę, a nie wektor.

Zbieranie wyników: alokuj z góry, nie powiększaj

Naturalny pierwszy odruch przy budowaniu wyników wygląda tak:

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

To działa, ale każde c(squares, ...) alokuje zupełnie nowy wektor i kopiuje do niego wszystkie stare elementy. Na koniec skopiowanych zostaje około 50 milionów liczb, żeby wyprodukować 10 000. Ten antywzorzec rosnącego wektora to główny powód, dla którego ludzie mówią, że pętle w R są wolne.

Rozwiązanie: najpierw utwórz wynik w pełnym rozmiarze, a potem przypisuj po indeksie:

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)

Dla wyników, które nie są liczbami, ten sam pomysł działa z character(n), logical(n) albo vector("list", n) dla listy dowolnych rzeczy. Pętle z wcześniej zaalokowanym wynikiem są w pełni szybkie.

next i break

Dwa słowa kluczowe sterują pętlą od środka: next porzuca bieżący przebieg i przeskakuje do następnego elementu; break całkowicie kończy pętlę.

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

To wypisuje 2 4 6 8: wartości nieparzyste są pomijane przez next, a gdy przychodzi 10, break kończy pętlę przed wypisaniem. Używaj next, żeby wcześnie odfiltrować przypadki (dzięki temu główna treść nie ma dodatkowego wcięcia), a break, gdy pętla znalazła to, czego szukała, i nie ma powodu kontynuować.

Pętle zagnieżdżone

Treść pętli może zawierać inną pętlę. Pętla wewnętrzna wykonuje się do końca przy każdym przebiegu zewnętrznej; klasyczna demonstracja to tabliczka mnożenia:

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

Dla każdego wiersza i pętla wewnętrzna przechodzi przez wszystkie kolumny j, a znak nowej linii wiersza wypisuje się po jej zakończeniu. Zagnieżdżanie na dwóch poziomach jest w porządku; przy trzech i więcej treść zwykle prosi się o zamianę w funkcję albo całe obliczenie prosi się o outer() lub operację na macierzy.

Zagnieżdżanie obejmuje też przechodzenie po liście wektorów: pętla zewnętrzna po liście, wewnętrzna (albo lepiej wywołanie wektorowe) po każdym elemencie:

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

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

Zwróć uwagę, że ostatecznie nie ma pętli wewnętrznej: mean() obsługuje cały wewnętrzny wektor jednym wywołaniem. Ta obserwacja się uogólnia, co prowadzi nas do uczciwej części.

Kiedy nie używać pętli

R to język wektorowy: jego podstawowe operacje od razu działają na całych wektorach. Pętla, która przekształca każdy element po kolei, to często dłuższy zapis jednej linijki:

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)

Wybieraj formę wektorową zawsze, gdy istnieje: jest krótsza, trudniej w niej o błąd i jest szybsza. Przy stosowaniu funkcji do każdego elementu listy tę samą rolę pełni rodzina apply (sapply, lapply, vapply).

Nie zamieniaj tego jednak w dogmat "pętle są złe". Pętla to właściwe narzędzie, gdy iteracje zależą od poprzednich (stan bieżący, symulacje), gdy wykonujesz efekty uboczne, takie jak zapisywanie plików, albo po prostu gdy pętla to wersja, którą ty i twoi czytelnicy rozumiecie od pierwszego spojrzenia. Czytelna pętla wygrywa ze sprytną jedną linijką, której nikt nie potrafi rozczytać.

Co warto zapamiętać

• for (x in v) { ... } wykonuje treść raz na element, bez prowadzenia licznika.
• Wewnątrz pętli wypisuj jawnie przez print() lub cat(); gołe wyrażenia są odrzucane.
• Po pozycjach przechodź przez seq_along(v), nigdy przez 1:length(v), bo to drugie wykonuje się dwa razy na pustym wektorze.
• Alokuj wyniki z góry przez numeric(n) / vector("list", n) i przypisuj po indeksie; powiększanie przez c() kopiuje wszystko w każdym przebiegu.
• next pomija przebieg, break kończy pętlę; wybieraj operacje wektorowe, gdy istnieją, ale nie bój się czytelnej pętli.

Dalej: pętle, które działają, dopóki coś się nie stanie, a nie raz na element, czyli while i repeat.