Giriş

  • Rahatsızlığım sebebiyle katılamadığım 10.12.2024 tarihli R ile veri analizi dersinde geçen haftanın devamı işlendiğini öğrendim. Öğrenme günlüğümü ona göre şekillendirmeye karar verdim.

  • kontrol yapıları ve döngüler konusundaki bilgilerimi pekiştirmek amacıyla öğrendiklerimi kaydediyorum. Bu süreçte R programlama dili kullanılarak döngülerle ilgili birçok önemli kavramı anladım ve uygulamaya çalışıyorum.

  • Döngülerin mantığını anlamanın, program akışını kontrol etmede ne kadar önemli olduğunu fark ettim. Özellikle for, while ve repeat döngülerinin işlevleri ve hangi durumlarda kullanılacağı konusunda bilinçlendim, bilinçleniyorum.

  • break ve next gibi komutların döngüleri nasıl kontrol ettiğini öğrenmeye çalıştım.

  • Bu haftam Kübra hocanın git-hub sayfası ve tavsiye edilen udemy internet sitesindeki Modern R Programlama Eğitimi videoları ile eksiklerimi kapatmaya çalışacağım.

  • for döngüsü: Belirli bir sıralı işlemi tekrar etmek için kullanılıyor. Bu, özellikle veri seti işlemlerinde çok faydalı.

  • while döngüsü: Belirli bir koşula bağlı olarak çalışıyor ve koşul sağlanmadığında sonlanıyor. Sonsuz döngülere dikkat edilmesi gerektiğini anladım.

  • repeat döngüsü: Diğer döngülerden farklı olarak belirli bir koşula bağlı olmadan çalışıyor ve break ile durdurulabiliyor.

  • Döngüler ve kontrol yapılarının performans açısından ne kadar önemli olduğunu fark ettim.

  • Matriste indeksleme ile işlem yaparken iç içe döngülerin kullanılabileceğini ve bunların okunabilirliği zorlaştırabileceğini öğrendim.

  • Bunun yerine, döngüleri parçalayarak daha okunabilir kod yazılabileceğini fark ettim.

Öğrendiğim Konular ve Örnek Kodlar

for ve while Döngüleri

Örnek: next ve break Kullanımı

for (i in 1:6) {
  if (i == 3) {
    next
  }
  print(i)
}
## [1] 1
## [1] 2
## [1] 4
## [1] 5
## [1] 6

Döngü 3’e geldiğinde atladı ve diğer elemanları yazdırdı.

for (i in 1:12) {
  if (i == 3) {
    break
  }
  print(i)
}
## [1] 1
## [1] 2

Döngü 3’e geldiğinde durdu.

İç İçe Döngüler ve Matris İşlemleri

Örnek: Matris Elemanlarının Hesaplanması

m2 <- matrix(0, nrow = 5, ncol = 5)

for (i in 1:nrow(m2)) {
  for (j in 1:ncol(m2)) {
    m2[i, j] <- i * j
  }
}
print(m2)
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    2    3    4    5
## [2,]    2    4    6    8   10
## [3,]    3    6    9   12   15
## [4,]    4    8   12   16   20
## [5,]    5   10   15   20   25

Bu işlemde matrisin her bir elemanına, satır ve sütun indekslerinin çarpımını atadım.

Performans Farklılıkları

Döngü ile ve Döngüsüz İşlem Karşılaştırması

set.seed(853)
y <- matrix(rnorm(1000000), nrow = 1000)
z <- 0 * y

Döngü ile hesaplama

time2 <- system.time({
  for (i in 1:1000) {
    for (j in 1:1000) {
      z[i, j] <- y[i, j]^2
    }
  }
})
print(time2)
##    user  system elapsed 
##    0.09    0.02    0.10

Döngüsüz hesaplama

time3 <- system.time({
  z <- y^2
})
print(time3)
##    user  system elapsed 
##       0       0       0

Bu testten döngüsüz işlemlerin performans açısından çok daha verimli olduğunu öğrendim.

  • next() ve break() gibi kontrol mekanizmalarının döngülerde akışı yönlendirmek için kullanıldığını anladım.
  • Döngülerin, özellikle iç içe for döngülerinin, matris işlemlerinde ve hiyerarşik veri yapılarında ne kadar önemli olduğunu gördüm.
  • Döngüsüz işlemler genellikle performans açısından daha iyidir.
  • next() ifadesi döngünün mevcut yinelemesini atlar ve bir sonrakine geçer.
  • break() ifadesi ise döngüyü tamamen sonlandırır.
  • while() döngüsü koşullar doğru olduğu sürece çalışır, ancak sonsuz döngülerden kaçınılmalıdır.
  • repeat() döngüsü yalnızca bir break ifadesiyle durdurulabilir.
  • Performans karşılaştırması yaparak döngülerin alternatif yöntemlerden daha yavaş olabileceğini öğrendim.
  • Döngülerin kullanımını optimize etmek için gerekirse parçalama ve fonksiyonlaştırma gibi yöntemler kullanılabilir.

next() ve break() Kullanımı Örnekleri

for (i in 1:6) {
  if (i == 3) {
    next
  }
  print(i)
}
## [1] 1
## [1] 2
## [1] 4
## [1] 5
## [1] 6
for (i in 1:12) {
  if (i == 3) {
    break
  }
  print(i)
}
## [1] 1
## [1] 2

İç İçe Döngülerle Matris İşlemleri

m2 <- matrix(0, nrow = 5, ncol = 5)

for (i in 1:nrow(m2)) {
  for (j in 1:ncol(m2)) {
    m2[i, j] <- i * j
  }
}
print(m2)
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    2    3    4    5
## [2,]    2    4    6    8   10
## [3,]    3    6    9   12   15
## [4,]    4    8   12   16   20
## [5,]    5   10   15   20   25

Sıra Sizdeler

S1:

n <- 3 
m <- matrix(0, nrow = n, ncol = n)

for (i in 1:nrow(m)) {
  for (j in 1:ncol(m)) {
    m[i, j] <- i * j
  }
}

if (n > 10) {
  print(head(m, 10))
} else {
  print(m)
}
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    2    4    6
## [3,]    3    6    9

S2

# For döngüsü ile hesaplama
n <- 10
fibonacci <- numeric(n)
fibonacci[1] <- 1
fibonacci[2] <- 1

for (i in 3:n) {
  fibonacci[i] <- fibonacci[i - 1] + fibonacci[i - 2]
}
print(fibonacci)
##  [1]  1  1  2  3  5  8 13 21 34 55
# While döngüsü ile hesaplama
fib <- c(1, 1)
i <- 3
while (i <= n) {
  fib <- c(fib, fib[i - 1] + fib[i - 2])
  i <- i + 1
}
print(fib)
##  [1]  1  1  2  3  5  8 13 21 34 55

S3

set.seed(1786)
ornek <- exp(matrix(rnorm(2000), nrow = 100))
index1.temp <- sample(1:100, 10)
index2.temp <- sample(1:20, 10)

for (i in 1:10) {
  ornek[index1.temp[i], index2.temp[i]] <- -1
}

negatif_toplam <- 0

for (i in 1:nrow(ornek)) {
  if (any(ornek[i, ] < 0)) {
    negatif_toplam <- negatif_toplam + sum(ornek[i, ] < 0)
    cat("Satır", i, "negatif sayı içermektedir.\n")
  } else {
    cat("Satır", i, "ortalaması", mean(ornek[i, ]), "dir\n")
  }
  
  if (negatif_toplam > 3) {
    cat("Çok sayıda negatif sayı!\n")
    break
  }
}
## Satır 1 ortalaması 1.810246 dir
## Satır 2 ortalaması 1.385186 dir
## Satır 3 ortalaması 1.913065 dir
## Satır 4 ortalaması 1.411238 dir
## Satır 5 ortalaması 1.444987 dir
## Satır 6 ortalaması 1.450956 dir
## Satır 7 ortalaması 1.283952 dir
## Satır 8 ortalaması 1.092563 dir
## Satır 9 ortalaması 1.423682 dir
## Satır 10 negatif sayı içermektedir.
## Satır 11 ortalaması 1.638674 dir
## Satır 12 negatif sayı içermektedir.
## Satır 13 ortalaması 1.470122 dir
## Satır 14 ortalaması 1.68761 dir
## Satır 15 ortalaması 1.515547 dir
## Satır 16 ortalaması 1.995183 dir
## Satır 17 ortalaması 1.479423 dir
## Satır 18 ortalaması 1.444495 dir
## Satır 19 ortalaması 1.543788 dir
## Satır 20 ortalaması 2.179839 dir
## Satır 21 ortalaması 1.48708 dir
## Satır 22 ortalaması 2.109184 dir
## Satır 23 ortalaması 2.537019 dir
## Satır 24 negatif sayı içermektedir.
## Satır 25 negatif sayı içermektedir.
## Çok sayıda negatif sayı!

S4

İçi Dolu Kare

n <- 5
for (i in 1:n) {
  cat(rep("s", n), "\n")
}
## s s s s s 
## s s s s s 
## s s s s s 
## s s s s s 
## s s s s s

İçi Boş Kare

for (i in 1:3) {
  if (i == 1 || i == 3) {
    cat(rep("a", 3), "\n")
  } else {
    cat("a", rep(" ", 3), "a", "\n", sep = "")
  }
}
## a a a 
## a   a
## a a a

Dolu Üçgen

for (i in 1:5) {
  cat(rep("m", i), "\n")
}
## m 
## m m 
## m m m 
## m m m m 
## m m m m m

Eşkenar Üçgen

for (i in 1:5) {
  cat(rep(" ", 5 - i), rep("e", 2 * i - 1), "\n", sep = "")
}
##     e
##    eee
##   eeeee
##  eeeeeee
## eeeeeeeee

İçi Boş Eşkenar Üçgen

for (i in 1:5) {
  if (i == 1) {
    cat(rep(" ", 4), "t", "\n", sep = "")
  } else if (i == 5) {
    cat(rep("t", 9), "\n", sep = "")
  } else {
    cat(rep(" ", 5 - i), "t", rep(" ", 2 * i - 3), "t", "\n", sep = "")
  }
}
##     t
##    t t
##   t   t
##  t     t
## ttttttttt

Dik Üçgen

for (i in 1:5) {
  cat(rep(" ", 5 - i), rep("R", i), "\n", sep = "")
}
##     R
##    RR
##   RRR
##  RRRR
## RRRRR

Diyagonal Çizgi

for (i in 1:5) {
  cat(rep(" ", i - 1), "R", "\n", sep = "")
}
## R
##  R
##   R
##    R
##     R

Sonuç

  • Öğrenme günlüğünü yazarken, kontrol yapılarının önemini kavradım ve döngülerin program akışını kontrol etmek için nasıl kullanılacağını öğrendim.

  • Performans farklılıklarını deneyimleyerek kod yazarken verimliliğin ne kadar önemli olduğunu fark ettim.

  • İçi boş kare, içi boş eşkenar üçgen ve diyagonal çizgide yapay zekadan yardım aldım.

Kendime Notlar

  • Döngülerden kaçınılabilecek durumlarda apply fonksiyonlarını kullanmaya çalış.
  • Kodun okunabilirliği için döngüleri basitleştirmeye ve parçalamaya özen göster.
  • Performans testi yapmayı unutma!