7  Apply Ailesi

Apply() ailesi, matrislerden, dizilerden, listelerden ve veri çerçevelerinden tekrarlayan bir şekilde veri dilimlerini işlemek için fonksiyonlarla doldurulur. Bu fonksiyonlar sayesinde döngü yapılarının kullanılmasından kaçınır. Bir girdi listesi, matris veya dizi üzerinde hareket ederler ve bir veya birkaç isteğe bağlı argümanla adlandırılmış bir fonksiyon uygularlar.

• apply(): bir dizinin ya da matrisin satır ya da sütunlarına fonksiyon uygular.

• lapply(): liste üzerindeki her elemana fonksiyon uygular.

• sapply(): lapply fonksiyonu ile aynıdır ancak çıktısı matris ya da veri çerçevesidir.

• mapply(): lapply fonksiyonunun çoklu versiyonudur.

• tapply(): faktör ya da grup düzeyinde fonksiyon uygular.

7.1 apply

apply fonksiyonu, bir veri yapısında bir fonksiyonu belirli bir boyuta uygulamak için kullanılır. Temel olarak üç ana parametre alır:

• X: Uygulanacak veri yapısı (matris, veri çerçevesi veya dizi).

• MARGIN: Fonksiyonun uygulanacağı boyut. 1 ise satırlar, 2 ise sütunlar üzerinde uygulanır.

• FUN: Uygulanacak fonksiyon.

set.seed(1234)

# apply
x <-matrix(rnorm(20), nrow=5, ncol=4)
x

           [,1]       [,2]        [,3]       [,4]
[1,] -1.2070657  0.5060559 -0.47719270 -0.1102855
[2,]  0.2774292 -0.5747400 -0.99838644 -0.5110095
[3,]  1.0844412 -0.5466319 -0.77625389 -0.9111954
[4,] -2.3456977 -0.5644520  0.06445882 -0.8371717
[5,]  0.4291247 -0.8900378  0.95949406  2.4158352

apply(x, 2 ,sum) # sütunların toplama işlemini yapar

[1] -1.76176834 -2.06980575 -1.22788016  0.04617308

apply(x, 1 ,mean) # satırların ortamalasını üretir

[1] -0.3221220 -0.4516767 -0.2874100 -0.9207156  0.7286040

7.1.1 Özel Fonksiyon Kullanımı

R içerisindeki hazır fonskiyonlarının yanı sıra kullanıcı tarafından belirli bir amaca yönelik olarak tanımlanmış fonksiyonlar da apply ile birlikte kullanılabilir. Örneğin aşağıdaki fonksiyon, bir sayının değerine bağlı olarak “Küçük” veya “Büyük” şeklinde bir etiket atama işlemi yapmaktadır.

Bu fonksiyon, x adında bir argüman alır ve bu argümanın değerine bağlı olarak bir etiket üretir. Eğer x 5’ten küçükse, “Küçük” değeri döndürür, aksi halde “Büyük” değerini döndürür. Daha sonra, örneğin bir veri çerçevesi oluşturarak bu fonksiyonu apply fonksiyonuyla nasıl kullanabileceğimizi gösterebiliriz:

# Özel bir fonksiyon tanımlayalım
custom_function <- function(x) {
  ifelse(x < 5, "Küçük", "Büyük")
}

# Örnek bir veri çerçevesi oluşturalım
veri <- data.frame(A = c(3, 7, 8), B = c(6, 2, 4))

# Özel fonksiyonu veri çerçevesinin her bir elemanına uygulayalım
sonuç <- apply(veri, c(1, 2), custom_function)

sonuç

     A       B      
[1,] "Küçük" "Büyük"
[2,] "Büyük" "Küçük"
[3,] "Büyük" "Küçük"

Bu kod parçacığı, apply fonksiyonunu kullanarak veri adında bir veri çerçevesinin her bir elemanına custom_function adlı özel fonksiyonu uygular. c(1, 2) parametresi, fonksiyonun hem satır hem de sütun boyunca uygulanmasını sağlar. Sonuç olarak, her elemanın “Küçük” veya “Büyük” olarak etiketlendiği bir matris elde edilir.

7.1.2 Fonksiyonun apply ile Birlikte Tanımlanması

apply fonksiyonu içinde bir fonksiyon tanımlayıp kullanmak da oldukça yaygın bir uygulamadır. Bu, özellikle küçük veya bir kez kullanılacak fonksiyonlar için faydalıdır çünkü bu fonksiyonları ayrı olarak tanımlamak yerine, doğrudan apply fonksiyonu içine yazarak kodunuzu daha temiz ve derli toplu hale getirebilirsiniz.

# Örnek bir matris oluşturalım
matris <- matrix(1:9, nrow = 3, ncol = 3)

# Her bir sütunun maksimum değerini bulan özel bir fonksiyonu apply ile kullanalım
sütun_max <- apply(matris, 2, function(x) max(x))

sütun_max

[1] 3 6 9

Bu kod parçasında, apply fonksiyonu içinde, her bir sütunun maksimum değerini bulmak için özel bir fonksiyon tanımlıyoruz. Bu fonksiyon, function(x) ile başlayıp x argümanını alır ve bu argümanın maksimum değerini döndürür. apply fonksiyonu bu özel fonksiyonu matrisin her bir sütununa uygular ve her sütunun maksimum değerlerini içeren bir vektör döndürür.

Bu şekilde, tek seferlik veya daha spesifik kullanımlar için özel fonksiyonları apply fonksiyonu içinde tanımlayabilirsiniz. Bu, kodunuzu daha okunabilir ve anlaşılır hale getirebilir ve gereksiz isim çakışmalarını önleyerek kod tabanınızı daha düzenli hale getirebilir.

7.1.3 Ek Argümanların Kullanımı

apply fonksiyonu, birinci argüman olarak veri yapısını (X), ikinci argüman olarak işlem yapılacak boyutu (MARGIN) ve üçüncü argüman olarak uygulanacak fonksiyonu (FUN) alır. Ancak, FUN (üçüncü argüman) dışında ek argümanlar da kullanabilirsiniz. Bu, apply fonksiyonunu daha esnek hale getirir ve işlemlerinizi daha geniş bir yelpazede yapmanıza olanak tanır.

Örneğin, eğer kullanacağınız fonksiyonun ek argümanları varsa, bu argümanları ... (üç nokta) kullanarak apply fonksiyonuna iletebilirsiniz. Bu argümanlar, FUN fonksiyonuna aktarılır ve işlemlerde kullanılabilir.

# Özel bir fonksiyon tanımlayalım
custom_function <- function(x, threshold) {
  ifelse(x < threshold, "Küçük", "Büyük")
}

# Özel fonksiyonu apply ile kullanırken ek bir argümanı (threshold) nasıl iletebileceğimizi görelim
threshold_value <- 5
sonuç <- apply(matris, c(1, 2), custom_function, threshold = threshold_value)

sonuç

     [,1]    [,2]    [,3]   
[1,] "Küçük" "Küçük" "Büyük"
[2,] "Küçük" "Büyük" "Büyük"
[3,] "Küçük" "Büyük" "Büyük"

Bu kod parçasında, custom_function adlı özel bir fonksiyon tanımlıyoruz. Bu fonksiyon, x değerini ve threshold adında ek bir argümanı alır. x değeri, elemanın değerini temsil ederken, threshold değeri ise bir eşik değeri olarak kullanılır.

Daha sonra, apply fonksiyonunu kullanırken threshold argümanını belirli bir değere (threshold_değer) ayarlıyoruz. Bu, apply fonksiyonu tarafından çağrılan custom_function fonksiyonuna bu değerin iletileceği anlamına gelir.

Sonuç olarak, apply fonksiyonu custom_function fonksiyonunu çağırırken her elemanın değerini ve belirlenen eşik değerini dikkate alarak sonuçları oluşturur. Bu şekilde, apply fonksiyonunu çok daha esnek bir şekilde kullanabilir ve ihtiyacınıza göre işlevsellik ekleyebilirsiniz.

7.2 lapply

Elbette, lapply fonksiyonu, listenin her bir elemanına belirtilen bir işlevi uygulamak için kullanılır ve sonuçları bir liste olarak döndürür. Bu fonksiyon, R’deki döngü yapısını vektörleştirmenin güçlü bir yoludur ve kodunuzu daha temiz ve etkili hale getirebilir.

# Örnek bir liste oluşturalım
liste <- list(a = 1:5, b = 6:10, c = 11:15)

# Her bir liste elemanının karesini alalım
kareler <- lapply(liste, function(x) x^2)

kareler

$a
[1]  1  4  9 16 25

$b
[1]  36  49  64  81 100

$c
[1] 121 144 169 196 225

Bu kod, liste adlı bir liste oluşturur ve her bir liste elemanının karesini almak için lapply fonksiyonunu kullanır. Sonuç olarak, her bir liste elemanının karesini içeren yeni bir liste oluşturulur.

Örneğin, bir liste içindeki veri çerçevelerini düşünelim. Her bir veri çerçevesinin farklı sayıda sütunu olabilir ve her bir veri çerçevesinin sadece ilk sütununu alan ve bu sütunları bir liste olarak döndüren bir işlem yapmak istiyoruz.

# Örnek bir liste oluşturalım
mylist <- list(data.frame(A = 1:3, B = 4:6),
               data.frame(X = 7:9, Y = 10:12),
               data.frame(M = 13:15, N = 16:18))

# Her bir liste elemanının ilk sütununu alalım
sonuç <- lapply(mylist, function(x) x[,1])

sonuç

[[1]]
[1] 1 2 3

[[2]]
[1] 7 8 9

[[3]]
[1] 13 14 15

Bu kod, mylist adlı bir liste oluşturur ve her bir elemanı farklı sütunlara sahip üç adet veri çerçevesi içerir. Yukarıdak işlem her bir veri çerçevesinin ilk sütununu seçer ve bu sütunları bir liste olarak döndürür. Sonuç olarak, her bir liste elemanının ilk sütununu içeren yeni bir liste elde edilir.

Örneğin, her biri bir veri çerçevesi için sütunların ortalamasını hesaplamak isteyelim. Bunun için önceki aşamada oluşturduğumuz listeyi kullanalım.

lapply(mylist,colMeans)

[[1]]
A B 
2 5 

[[2]]
 X  Y 
 8 11 

[[3]]
 M  N 
14 17 

Bu örnek, lapply fonksiyonunu yerleşik bir R fonksiyonu olan colMeans ile kullanmanın bir örneğidir. Bu tür işlevler, veri analizi yaparken veri yapısının her bir elemanına uygulanarak kolayca özet istatistikler elde etmenizi sağlar.

7.3 sapply

sapply, bir işlevi bir veri yapısının her bir elemanına uygular ve sonuçları bir vektör veya dizi olarak döndürür. Diğer apply fonksiyonlarından farkı, sonucun yapısını belirleyebilme esnekliğine sahip olmasıdır.

Örneğin bir liste elemanlarının ortalamasını bulmak isteyelim.

# Örnek bir liste oluşturalım
liste <- list(a = c(1, 2, 3), b = c(4, 5, 6), c = c(7, 8, 9))

# Her bir liste elemanının ortalamasını bulalım
ortalama <- sapply(liste, mean)

ortalama

a b c 
2 5 8 

Bu kod, liste adlı bir liste oluşturur ve her bir liste elemanının ortalamasını bulmak için sapply fonksiyonunu kullanır. Sonuç olarak, her bir liste elemanının ortalamasını içeren bir vektör elde edilir.

sapply fonksiyonu sonucun yapısını belirlemek için, veri yapısının elemanlarına uygulanan işlevin çıktısına dayanır. Örneğin, eğer uygulanan işlevin çıktısı her bir eleman için bir skaler (tek bir değer) ise, sonuç bir vektör olacaktır. Eğer uygulanan işlevin çıktısı farklı uzunlukta vektörler ise, sonuç bir matris olacaktır. Eğer uygulanan işlevin çıktısı liste ise, sonuç da bir liste olacaktır.

# Her bir liste elemanının uzunluğunu bulan işlev
uzunluk_bul <- function(x) length(x)

# Her bir liste elemanının uzunluğunu bulalım
sonuç <- sapply(liste, uzunluk_bul)

sonuç

a b c 
3 3 3 

Bu kod içerisinde her bir elemanının uzunluğunu bulmak için uzunluk_bul adlı bir işlev tanımlanır. sapply fonksiyonu, bu işlevi listenin her bir elemanına uygular. Çıktıya dikkat ederseniz, işlevin çıktısı her eleman için bir skaler (uzunluk) olduğu için sonuç bir vektör olarak döner. Ancak, eğer işlevin çıktısı her bir eleman için farklı uzunlukta bir vektör olsaydı, sonuç bir matris olarak dönecekti.

# Her bir liste elemanının karelerini bulan işlev
kare_bul <- function(x) x^2

# Her bir liste elemanının karelerini bulalım
sonuç <- sapply(liste, kare_bul)

sonuç

     a  b  c
[1,] 1 16 49
[2,] 4 25 64
[3,] 9 36 81

Bu kodda, kare_bul işlevi her bir liste elemanının karesini alır. Ancak, çıktıdaki farklı uzunluktaki vektörler, sonucun bir matris olmasını sağlar.

Bu örneklerden de görebileceğiniz gibi, sapply fonksiyonunun sonucun yapısını belirlemek için uygulanan işlevin çıktısına dayandığını görebiliriz. Bu, sapply fonksiyonunun sonucun yapısını esnek bir şekilde belirlemesini sağlar.

7.4 tapply

R programlama dilinde, verileri bir faktöre veya belirli bir kategorik değişkene göre gruplamak ve her bir grup için bir işlem yapmak sıkça gereklidir. tapply fonksiyonu, bu tür durumlar için kullanışlı bir araçtır. tapply, bir veri setini bir veya birden fazla faktöre göre gruplayarak her grup için bir işlem yapmanıza olanak tanır.

apply fonksiyonlarının aksine, tapply fonksiyonu veri setini faktörlere veya gruplara göre böler ve her bir grup için belirtilen bir işlemi uygular. Temel kullanımı şu şekildedir:

tapply(X, INDEX, FUN)

Burada:

• X : Uygulanacak işlemi gerektiren vektör.

• INDEX: Gruplandırılacak faktör veya grup değişkeni.

• FUN: Her bir gruba uygulanacak işlev.

# Örnek veri seti oluşturalım
veri <- data.frame(Aylar = rep(c("Ocak", "Şubat", "Mart"), each = 4),
                   Degerler = c(10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65))

# Aylara göre değerlerin ortalamasını hesaplayalım
ortalama <- tapply(veri$Degerler, veri$Aylar, mean)

ortalama

 Mart  Ocak Şubat 
 57.5  17.5  37.5 

Bu kod parçası, veri adında bir veri seti oluşturur. Bu veri setinde “Aylar” ve “Değerler” adlı iki sütun bulunmaktadır. tapply fonksiyonu, veri$Değerler sütununu veri$Aylar sütununa göre gruplar ve her bir ay için değerlerin ortalamasını hesaplar.

Eğer iki faktöre ya da değişkene göre bir hesapalama yapmak istersek faktörleri bir liste olarak fonksiyona belirtmemiz yeterlidir. Diyelim ki, bir veri setindeki öğrencilerin matematik ve fen bilgisi notları var ve bu notları cinsiyet ve sınıf düzeyi gibi iki farklı grup değişkenine göre incelemek istiyoruz. tapply fonksiyonunu kullanarak her bir kombinasyon için not ortalamalarını bulabiliriz.

# Örnek veri seti oluşturalım
ogrenciler <- data.frame(
  Cinsiyet = c("K", "E", "K", "E", "K", "E", "K", "E", "K", "E"),
  Sinif = c(9, 9, 10, 10, 11, 11, 9, 9, 10, 10),
  Matematik = c(70, 75, 80, 85, 90, 95, 85, 80, 75, 70),
  FenBilgisi = c(75, 80, 85, 90, 95, 100, 80, 85, 90, 95)
)

# Her bir kombinasyon için matematik ve fen bilgisi notlarının ortalamasını bulalım
sonuç <- with(ogrenciler, tapply(Matematik, list(Cinsiyet, Sinif), mean))
sonuç

     9   10 11
E 77.5 77.5 95
K 77.5 77.5 90

Bu kod, öğrencilerin cinsiyet ve sınıf düzeylerine göre matematik notlarının ortalamasını hesaplar. list(Cinsiyet, Sinif) ifadesi, Cinsiyet ve Sinif değişkenlerinin tüm kombinasyonlarını oluşturur. tapply fonksiyonu, bu kombinasyonlar için matematik notlarının ortalamasını hesaplar.

7.4.1 tapply’ın Avantajları ve Kullanım Alanları

1. Grup Bazında İşlem Yapma: tapply fonksiyonu, verileri belirli faktörler veya gruplar altında gruplayarak her bir grup için işlem yapmanıza olanak tanır. Bu, veri analizi ve özetleme işlemlerinde çok kullanışlıdır.

2. Esneklik: tapply fonksiyonu, birden fazla faktörü kullanarak verileri gruplamak ve her bir grup için farklı işlemler yapmak için esneklik sağlar. Bu, çeşitli veri analizi senaryolarına uyarlanabilirlik sağlar.

3. Faktörlere Göre Toplamak ve Özetlemek: tapply fonksiyonu, verileri belirli bir faktöre göre toplamak ve özetlemek için ideal bir araçtır. Özellikle kategorik değişkenlerle çalışırken grup bazında işlem yapmak istediğinizde kullanışlıdır.

tapply fonksiyonu, veri analizi ve işleme süreçlerinde grup bazında işlem yapmanın hızlı ve etkili bir yolunu sunar. Farklı faktörler veya gruplar altında verileri gruplamak ve her bir grup için farklı işlemler yapmak için kullanılabilir. Bu, veri analizindeki pek çok senaryoda kullanışlı bir araçtır.

7.5 mapply

R programlama dilinde, bir işlevi birden çok giriş değeri veya argüman ile uygulamak gerekebilir. mapply fonksiyonu, bu tür durumlar için kullanışlı bir araçtır. Bu fonksiyon, birden çok vektör veya listeye sahip olduğunuzda, her bir girişe bir işlev uygular ve sonuçları birleştirir. Temel kullanımı şu şekildedir:

mapply(FUN, ..., MoreArgs = NULL, SIMPLIFY = TRUE, USE.NAMES = TRUE)

Burada:

• FUN: Uygulanacak işlev.

• ...: Birden çok vektör veya liste.

• MoreArgs: İşlevin sabit argümanları (opsiyonel).

• SIMPLIFY: Sonuçların basitleştirilip basitleştirilmeyeceğini belirten bir mantıksal değer (varsayılan olarak TRUE).

• USE.NAMES: Sonuçlarda isimlerin kullanılıp kullanılmayacağını belirten bir mantıksal değer (varsayılan olarak TRUE).

Aşağıdaki örnekte, mapply fonksiyonu * (çarpma) işlemini a ve b vektörlerinin karşılıklı elemanlarına uygular.

# İki vektör oluşturalım
a <- c(1, 2, 3)
b <- c(4, 5, 6)

# Her iki vektördeki elemanları çarparak sonuçları hesaplayalım
sonuç <- mapply(FUN = "*", a, b)

sonuç

[1]  4 10 18

Bu örnekte ise mapply fonksiyonu iki farklı işlevi (üs_al ve çarp) aynı anda iki vektörün karşılıklı elemanlarına uygular.

# İki farklı fonksiyon tanımlayalım
üs_al <- function(x, y) x^y
çarp <- function(x, y) x * y

# İki vektör oluşturalım
a <- c(1, 2, 3)
b <- c(2, 3, 4)

# Her bir vektördeki elemanları farklı işlevlere uygulayarak sonuçları hesaplayalım
sonuç1 <- mapply(üs_al, a, b)
sonuç2 <- mapply(çarp, a, b)

sonuç1

[1]  1  8 81

sonuç2

[1]  2  6 12

Bu örnekte, mapply fonksiyonu paste işlemini liste elemanlarına uygular ve collapse argümanını kullanarak sonuçları birleştirir.

# Örnek bir liste oluşturalım
liste <- list(a = c(1, 2, 3), b = c(4, 5, 6), c = c(7, 8, 9))

# Her bir liste elemanını birleştirerek sonuçları hesaplayalım
sonuç <- mapply(FUN = paste, liste, collapse = "-")

sonuç

      a       b       c 
"1-2-3" "4-5-6" "7-8-9" 

7.5.1 mapply Fonksiyonunun Kullanım Alanları

• Birden Çok Vektör veya Liste ile İşlev Uygulama: mapply, birden çok giriş değeri ile bir işlevi uygulamak için kullanılır.

• Döngüsüz Programlama: mapply, döngüsüz programlama yaklaşımını benimseyerek kodun daha temiz ve etkili olmasını sağlar.

• Veri Çerçevesi İşlemleri: mapply, veri çerçevelerinde veya matrislerdeki satır veya sütunlar arasında işlevleri uygulamak için kullanılabilir.

mapply fonksiyonu, birden çok giriş değeri ile bir işlevi uygulamak için kullanılan kullanışlı bir araçtır. Bu fonksiyon, programlamada döngülerin azaltılması ve kodun daha temiz hale getirilmesine yardımcı olur.

7.6 vapply

vapply fonksiyonu, bir vektör üzerinde belirli bir işlevi uygularken, işlevin çıktı türünü önceden belirleyebileceğiniz bir yöntem sunar. Genel olarak, sapply fonksiyonuna benzer şekilde çalışır, ancak dönüş değerlerinin türünü belirleyebilme özelliğiyle farklılık gösterir. Bu, çıktının türünü bilmeniz gerektiğinde ve istenmeyen bir tür dönüşümünü önlemek istediğinizde oldukça faydalıdır.

İşlevi şu şekildedir:

vapply(X, FUN, FUN.VALUE, ...)

Burada:

• X: İşlevin uygulanacağı vektör veya dizi.

• FUN: Uygulanacak işlev.

• FUN.VALUE: İşlevin çıktı türünü belirten bir örnek veya örnek vektör.

• ...: Ek argümanlar (opsiyonel).

Örnek olarak, bir vektördeki her bir elemanın uzunluğunu bulalım, ancak çıktı olarak her zaman bir tamsayı vektörü almak isteyelim:

# Örnek bir vektör oluşturalım
v <- c("abc", "de", "fghi")

# Her bir elemanın uzunluğunu bulan işlevi tanımlayalım
uzunluk_bul <- function(x) {
  return(nchar(x))
}

# Çıktı olarak her zaman bir tamsayı vektörü almak için vapply'i kullanalım
sonuç <- vapply(v, uzunluk_bul, FUN.VALUE = integer(1))

sonuç

 abc   de fghi 
   3    2    4 

Bu örnekte, vapply, “v” vektöründeki her bir elemanın uzunluğunu bulmak için nchar işlevini uygular. Ancak, FUN.VALUE = integer(1) argümanı sayesinde, her zaman bir tamsayı vektörü döndürülmesini sağlar. Bu, her elemanın uzunluğunun tamsayı olarak dönmesini garanti eder.

vapply fonksiyonu, işlevin çıktı türünü önceden belirlemek istediğinizde oldukça kullanışlıdır ve programınızın daha sağlam ve öngörülebilir olmasına yardımcı olabilir.