One week. 700+ courses for $0. No credit card needed.
Start Now

Veri bilimi alanında bir kariyere başlamayı düşünüyorsanız, ne kadar erken kodlamaya başlarsanız o kadar iyi. Öğrenme yolculuğunuza başlamak için hangi programlama dilini seçmiş olursanız olun, bir noktada fonksiyonlarla tanışacaksınız.
Fonksiyonlar, veri biliminde popüler programlama dilleri olan Python, Julia ve elbette R dâhil olmak üzere, neredeyse tüm modern programlama dillerinde temel bir kavramdır.
Bu eğitimde, R fonksiyonlarının ne olduğunu ve nasıl kullanabileceğinizi inceleyeceğiz. R’deki fonksiyonların amacı, sözdizimi ve tipolojisini ele alarak, programlamadaki bu kritik kavramı ustalıkla kullanmanız için gereken her şeyi edineceksiniz. Dahası, fonksiyon yazma sanatına giriş yapacaksınız.
Programlamada fonksiyonlar, belirli bir görevi yerine getirmek için bir araya getirilen talimatlardır. Fonksiyonların mantığı, yalnızca ihtiyaç duyulduğunda çağrılabilen, kendi içinde bütün programlar oluşturmaktır.
Fonksiyonlar sayesinde programcılar, baştan program yazmaktan kurtulur; tekrarları önler, kodun sağlamlığını ve okunabilirliğini artırır. Bu nedenle, genel bir kural olarak, kodunuzda belirli bir talimat setini ikiden fazla çalıştırmayı bekliyorsanız bir fonksiyon oluşturmak iyi bir pratiktir.
Fonksiyonlar sayısız amaçla kullanılabilir ve çeşitli biçimler alabilir. Genel olarak, fonksiyonların büyük çoğunluğu girdi verisini alır, işler ve bir sonuç döndürür. Fonksiyonun üzerinde çalıştığı veri, aynı zamanda fonksiyonun görevleri nasıl yerine getirdiğini kontrol etmek veya değiştirmek için de kullanılabilen argümanlar ile belirtilir.
Fonksiyonun kaynağına bağlı olarak, R'de üç ana fonksiyon türünü ayırt edebiliriz:
Aşağıdaki bölümlerde, R'de mevcut farklı fonksiyon türlerinin özelliklerini açıklayacağız.
R, dilediğiniz zaman çağrılabilecek geniş bir yerleşik fonksiyon kataloğuna sahip güçlü bir programlama dilidir. Matematik odaklı bir dil olarak R, sayısal işlemler yapmak için oldukça fazla sayıda fonksiyonla birlikte gelir. Aşağıda en kullanışlı olanlardan bazılarının bir listesini bulabilirsiniz:
Aşağıdaki kodda, bir vektörden belirli istatistikleri hesaplamak için bu fonksiyonların ne kadar basit kullanıldığını görebilirsiniz:
>>> v <- c(1, 3, 0.2, 1.5, 1.7)
>>> print(v)
[1] 1.0 3.0 0.2 1.5 1.7
>>> sum(v)
[1] 7.4
>>> mean(v)
[1] 1.48
>>> length(v)
[1] 5
R fonksiyonlarını ve daha fazlasını kapsamlı R beceri yolumuzda ele alabilirsiniz; bu yol, bir programcı gibi kod yazmayı öğrenmenize yardımcı olacaktır.
Sayısı çok ve çeşitli olsa da, yerleşik fonksiyonlar R ile yapılabilecek, etkileyici veri görselleştirmeleri oluşturmaktan güçlü makine öğrenmesi modelleri eğitmeye kadar tüm harika işleri yapmak için yeterli değildir.
Bu görevleri gerçekleştirmeye yönelik fonksiyonların büyük çoğunluğu harici paket veya kütüphanelerde bulunur. Paketler, belirli işlevsellikler eklemek üzere iyi tanımlanmış bir formatta oluşturulmuş R fonksiyonları, veriler ve derlenmiş kod koleksiyonlarıdır. Bu paketlerin çoğu ücretsiz olarak kullanılabilir ve şu anda yaklaşık 20.000 katkı paketi içeren popüler paket depolarında bulunabilir; örneğin CRAN.
Bir paketteki fonksiyonları kullanmak için önce paketi kurmanız gerekir. Örneğin, düzenli ifadelerle çalışmak için popüler bir paket olan stringr'ı kurmak istiyorsanız, aşağıdaki ifadeyi kullanabilirsiniz:
install.packages('stringr')
Kurulumdan sonra, R ortamınıza yüklemek için library ifadesini kullanın
library(stringr)
Artık stringr paketindeki tüm fonksiyonları kullanmaya hazırsınız. Örneğin, bir dizinin her bir öğesinde desenle eşleşenler için TRUE, diğerleri için FALSE döndüren str_detect() fonksiyonunu deneyelim.
str_detect('DataCamp', "Data")
[1] TRUE
R paketleri hakkında daha fazla bilgi edinmek ve nasıl kullanılacaklarını öğrenmek istiyorsanız bu DataCamp R paketleri eğitimine göz atın.
R'de fonksiyonların nasıl çalıştığını anlamanın en iyi yolu kendi fonksiyonlarınızı oluşturmaktır. Kullanıcı Tanımlı Fonksiyonlar (UDF) olarak adlandırılan bu fonksiyonlar, belirli bir görevi yerine getirmek üzere programcılar tarafından tasarlanır.
R fonksiyonları genellikle aşağıdaki sözdizimini benimser:
function_name <- function(argument_1, argument_2) {
function body
return (output)
}
Dört ana öğeyi ayırt edebiliriz:
Örneğin, iki sayının ortalamasını hesaplayan bir fonksiyon oluşturmak isterseniz:
mean_two_numbers <- function(num_1, num_2) {
mean <- (num_1 + num_2) / 2
return (mean)
}
Artık 10 ve 20'nin ortalamasını hesaplamak isterseniz, fonksiyonu aşağıdaki gibi çağırın:
>>> mean_two_numbers(10,20)
[1] 15
Argümanlar, her fonksiyonun hayati unsurlarıdır. Teorik olarak hiç parametre içermeyen bir fonksiyon yazmak mümkün olsa da (aşağıdaki örneğe bakın), çoğu fonksiyonun argümanları vardır. Bu mantıklıdır; çünkü argümanlar, fonksiyona hangi veriyi girdi olarak alacağını söyler. Aynı şekilde, bir fonksiyona bir görevi yerine getirmenin çeşitli yollarını kazandırmak istiyorsak, bunu argümanlar sağlar.
hello <- function() {
print('hello, my friend')
}
>>> hello()
[1] "hello, my friend"
R fonksiyonlarındaki argüman sayısına bir sınır yoktur; parantez içinde virgülle ayırarak ekleyebilirsiniz. Genel olarak, daha fazla argümana sahip fonksiyonlar daha karmaşık olma eğilimindedir.
Parametreli bir fonksiyon oluşturduktan sonra, her kullanımınızda farklı parametrelerin değerlerini sağlamanız gerekir; aksi takdirde R bir hata verir. Örneğin, iki sayının ortalamasını hesaplamak için değer vermezseniz, fonksiyonumuz çalışmayacaktır.
Ancak, bir fonksiyonu tanımlarken varsayılan argümanlar kullanarak bu hatadan kaçınabilirsiniz. Varsayılan argümanlar, fonksiyonu o argümanı sağlamadan çağırırsanız kullanılacak bir varsayılan değer sunar. İki sayının ortalamasını hesaplayan fonksiyonumuza geri dönelim. Bu kez, ikinci sayı için varsayılan bir argüman ekleyecek şekilde tanımlayacağız.
mean_two_numbers <- function(num_1, num_2 = 30) {
mean <- (num_1 + num_2) / 2
return (mean)
}
Artık fonksiyonu num_2 parametresinin değerini vermeden çağırırsak, R otomatik olarak varsayılan değeri (yani 30) alacaktır:
>>> mean_two_numbers(num_1 = 10)
[1] 20
Fonksiyonlar genellikle bazı verileri girdi olarak alır ve çıktı olarak bir sonuç verir. Bazı programlama dillerinde, bir fonksiyonun sonucunu bir değişken olarak kaydetmek için fonksiyon gövdesinin sonunda açıkça return ifadesini eklemeniz gerekir. Aksi takdirde fonksiyon, yalnızca değişkenin kapsamı içinde var olan bir değeri görüntüleyecektir.
R'de durum böyle değildir; R her zaman bir değişkende saklanabilecek bir değer döndürür. Ancak okunabilirlik açısından, bir fonksiyon tanımlarken return ifadesini eklemek her zaman iyi bir pratiktir.
mean_two_numbers <- function(num_1, num_2) {
# Function with return
mean <- (num_1 + num_2) / 2
return (mean)
}
mean_two_numbers_2 <- function(num_1, num_2) {
# Function without return
mean <- (num_1 + num_2) / 2
mean
}
> mean_two_numbers(10,50)
[1] 30
> mean_two_numbers_2(10,50)
[1] 30
Son olarak, fonksiyonunuzun birden fazla değer döndürmesini istiyorsanız, farklı sonuçları bir listede saklayıp return ifadesine eklemeniz gerekir:
mean_sum <- function(num_1, num_2) {
mean <- (num_1 + num_2) / 2
sum <- num_1 + num_2
return (list(mean, sum))
}
>>> mean_sum (10, 20)
[[1]]
[1] 15
[[2]]
[1] 30
Önceki bölümlerde bir fonksiyonun nasıl çağrılacağına dair çeşitli örnekler gördük. Ancak, argümanları geçirirken R'nin perde arkasında nasıl çalıştığını netleştirmek önemlidir.
R, argümanları iki şekilde geçirmeyi kabul eder: konuma göre ve ada göre. İlk stratejiyi izlersek, değerleri, fonksiyonda tanımlanan argümanların aynı sırasına göre yazmamız gerekir.
Argümanları ada göre geçirirsek, argümanların adlarını ve ilişkilendirilmiş değerlerini açıkça belirtmemiz gerekir. Argümanlar ve değerler eşleştirildiği için sıra önemli değildir.
Son olarak, iki stratejiyi karıştırmak da mümkündür. Bu durumda, adlandırılmış argümanlar argüman listesinden alınır ve önce eşleştirilir; kalan argümanlar ise konuma göre eşleştirilir.
hello <- function(name, surname) {
print(paste('Hello', name, surname))
}
# Calling arguments by position
> hello('Greta','Thunberg')
[1] "Hello, Greta Thunberg"
# Calling arguments by name
> hello(surname='Thunberg', name='Greta')
[1] "Hello, Greta Thunberg"
# Calling arguments by position and by name
> hello(surname='Thunberg', 'Greta')
[1] "Hello, Greta Thunberg"
Fonksiyon oluştururken, özellikle fonksiyonlar karmaşıksa, nasıl kullanılacağına ilişkin belgeler sağlamak iyi bir pratiktir. Bunu yapmanın gayriresmî bir yolu, fonksiyon gövdesine yorumlar eklemektir. Belgeleri, fonksiyonu parametresiz çağırarak ekleyebilirsiniz:
hello <- function(name, surname) {
# Say hello to a person with name and surname
print(paste('Hello', name, surname))
}
>>> hello
function(name, surname) {
# Say hello to a person with name and surname
print(paste('Hello,', name, surname))
Bununla birlikte, fonksiyonunuz daha büyük bir paketin parçasıysa ve onu belgelenmek istiyorsanız, ayrı bir .Rd belgesinde resmî dokümantasyon yazmalısınız. Bu dokümantasyonun sonucunu, belirli bir fonksiyonun yardım dosyasına baktığınızda görürsünüz; ör. ?mean.
Eğitimin sonuna geldiniz. Tebrikler! Birçok dilde olduğu gibi, fonksiyonlar R'de de hayati unsurlardır. İster yerleşik olsun, ister harici paketlerin bir parçası olarak geliştirilmiş olsun ya da bizzat sizin tarafınızdan oluşturulmuş olsun, fonksiyonlara hâkim olmak programlama yolculuğunuzda önemli bir dönüm noktasıdır. R'de fonksiyon becerilerinizi geliştirmeye devam etmek isterseniz aşağıdaki kaynaklara göz atın!

blog
blog
Eğitim
R kursları
Kurs
Verimli, yeniden kullanılabilir fonksiyonlar yazmayı öğrenip R becerilerinizi geliştirin.
Kurs
Vektörler, listeler ve veri çerçeveleri de dahil olmak üzere R'da veri analizinin temellerini öğrenin ve gerçek veri setleriyle R pratiği yapın.
Kurs
Koşullu ifadeler, döngüler ve vektör fonksiyonları hakkında bilgi edinerek R ninja olma yolculuğunuza devam edin.