R'de For Döngüleri: Söz Dizimi, seq_along, break, next ve Ne Zaman Döngü Kurmamalı

Temel for Döngüsü

R'de bir for döngüsü, bir vektörün ya da listenin her elemanı için bir kod bloğunu bir kez çalıştırır. Döngü değişkeni her değeri sırayla alır:

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

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

Üç eleman, üç tur. Kurulacak bir sayaç ya da sürdürülecek bir koşul yoktur - for (fruit in fruits) "fruits içindeki her fruit için" diye okunur ve tam olarak bunu yapar. Aynı biçim bir listenin elemanları, bir sayı dizisi (for (i in 1:10)) ya da names() yoluyla herhangi bir şeyin isimleri üzerinde de yinelenir.

Döngü İçinde Yazdırmak print() veya cat() İster

Konsolda x yazmak değerini yazdırır. Bir döngü gövdesinin içinde ise yazdırmaz - otomatik yazdırma yalnızca en üst düzeyde gerçekleşir ve döngü içindeki yalın bir ifade değerlendirilip atılır:

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

Yani bir döngü "hiçbir şey yapmadığında" kontrol edilecek ilk şey budur. Herhangi bir değere hızlıca göz atmak için print(), bir çıktı satırını kendiniz kurarken cat() kullanın ("\n" unutmayın - cat() eklemez).

seq_along() ile İndeksler Üzerinde Dönmek

Bazen değerin yanı sıra konuma da ihtiyacınız olur - aynı indekste başka bir vektöre yazmak ya da numaralı bir liste yazdırmak için. İndeksler üzerinde seq_along() ile dönün:

prices <- c(9.99, 4.50, 12.00)

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

Eski kodda for (i in 1:length(prices)) göreceksiniz ve bu gerçek bir hatayı barındırır. Vektör boş olduğunda length() 0'dır ve 1:0 "hiç yineleme yok" anlamına gelmez - iki nokta üst üste geriye sayar:

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

1:length(empty) üzerindeki bir döngü iki kez çalışır ve var olmayan elemanları indeksler (empty[1] NA'dır ve atamalar hayalet girdiler oluşturur). seq_along() boş bir vektör için boş bir dizi döndürür, dolayısıyla döngü gövdesi hiç çalışmaz. seq_along() alışkanlık olsun; kardeşi seq_len(n), elinizde vektör yerine bir sayı olduğunda aynı işi yapar.

Sonuç Toplama: Büyütmeyin, Önceden Ayırın

Sonuçları biriktirmek için doğal ilk içgüdü şuna benzer:

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

Çalışır, ama her c(squares, ...) yepyeni bir vektör ayırır ve tüm eski elemanları içine kopyalar. Sonunda 10.000 sayı üretmek için kabaca 50 milyon sayı kopyalamış olursunuz. Bu büyüyen vektör anti-kalıbı, insanların R döngülerine yavaş demesinin bir numaralı nedenidir.

Çözüm: sonucu önce tam boyutunda oluşturun, sonra indeksle atayın:

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)

Sayı olmayan sonuçlarda aynı fikir character(n), logical(n) ya da rastgele şeylerden oluşan bir liste için vector("list", n) ile geçerlidir. Önceden yer ayrılmış döngüler gayet hızlıdır.

next ve break

İki anahtar sözcük bir döngüyü gövdesinin içinden yönlendirir: next mevcut turu terk edip bir sonraki elemana atlar; break ise döngüden tamamen çıkar.

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

Bu 2 4 6 8 yazdırır: tek değerler next ile atlanır ve 10 geldiğinde break döngüyü yazdırmadan önce bitirir. Durumları erkenden elemek için next kullanın (ana gövdeyi girintisiz tutar), bir döngü aradığını bulduğunda ve devam etmek için nedeni kalmadığında break kullanın.

İç İçe Döngüler

Bir döngü gövdesi başka bir döngü içerebilir. İç döngü, dış döngünün her turu için baştan sona çalışır - klasik gösterim bir çarpım tablosudur:

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

Her i satırı için iç döngü tüm j sütunlarını dolaşır ve satırın yeni satır karakteri iç döngü bittikten sonra yazdırılır. İç içe döngüler iki düzeyde sorunsuzdur; üç ya da daha fazlasında gövde genellikle bir fonksiyona dönüşmek ister ya da hesabın tamamı bir outer() veya matris işlemi olmak ister.

İç içe koyma, vektörlerden oluşan bir liste üzerinde dönmeyi de kapsar - dış döngü liste üzerinde, iç döngü (ya da daha iyisi, vektörleştirilmiş bir çağrı) her eleman üzerinde:

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

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

Sonunda hiç iç döngü olmadığına dikkat edin - mean(), tüm iç vektörü tek bir çağrıda halleder. Bu gözlem geneller ve bizi dürüst kısma getirir.

Ne Zaman Döngü Kurmamalı

R vektörleştirilmiş bir dildir: temel işlemleri zaten bütün vektörler üzerinde aynı anda çalışır. Her elemanı teker teker dönüştüren bir döngü, çoğu zaman tek satırlık bir ifadeyi yazmanın uzun yoludur:

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)

Var olduğu her yerde vektörleştirilmiş biçimi tercih edin - daha kısadır, yanlış yapması zordur ve daha hızlıdır. Bir listenin her elemanına bir fonksiyon uygulamak için apply ailesi (sapply, lapply, vapply) aynı rolü oynar.

Ama bunu "döngüler kötüdür" diye kargo kültüne çevirmeyin. Yinelemeler öncekilere bağlı olduğunda (birikimli durum, simülasyonlar), dosya yazmak gibi yan etkiler ürettiğinizde ya da basitçe döngü sizin ve okurlarınızın bir bakışta anladığı sürüm olduğunda döngü doğru araçtır. Net bir döngü, kimsenin çözemediği zekice bir tek satırlığı yener.

Buradan Ne Çıkarıyorsunuz

• for (x in v) { ... }, gövdeyi eleman başına bir kez çalıştırır - sayaç muhasebesi yok.
• Döngü içinde print() ya da cat() ile açıkça yazdırın; yalın ifadeler atılır.
• Konumlar üzerinde seq_along(v) ile dönün, asla 1:length(v) ile değil - ikincisi boş bir vektörde iki kez çalışır.
• Sonuçlar için numeric(n) / vector("list", n) ile önceden yer ayırın ve indeksle atayın; c() ile büyütmek her turda her şeyi kopyalar.
• next bir turu atlar, break çıkar; var olduğunda vektörleştirilmiş işlemleri tercih edin, ama okunabilir bir döngüden korkmayın.

Sırada: eleman başına bir kez değil, bir şey olana kadar çalışan döngüler - while ve repeat.