R'de Fonksiyonlar: Tanım, Argümanlar ve Dönüş Değerleri

Fonksiyon Tanımlama ve Çağırma

R'de bir fonksiyon, sayı ya da metin gibi bir değerdir. Onu function anahtar sözcüğüyle kurar ve başka her şeyi bir değişkende saklayacağınız gibi <- ile bir isme sabitlersiniz:

square <- function(x) {
  x^2
}

print(square(4))
print(square(9))

Parçalar: function(x), x adında bir parametre bildirir, süslü parantezler gövdeyi tutar ve square(4) çağrısı gövdeyi x değeri 4 olarak çalıştırır. Tek satırlık bir gövdede süslü parantezler isteğe bağlıdır - square <- function(x) x^2 aynı fonksiyondur - ama gövde büyüdükçe parantezler daha iyi okunur.

Bir fonksiyon sadece bir değer olduğu için değişkenler hakkında bildiğiniz her şey geçerlidir: onu yeniden atayabilir, başka bir fonksiyona geçirebilir ya da bir listede saklayabilirsiniz. Bu tek olgu, tüm apply ailesi dahil deyimsel R'nin yarısını çalıştırır.

Dönüş Değerleri: Son İfade Kazanır

Bir R fonksiyonu, değerlendirdiği son ifadenin ürettiği şeyi döndürür. Zorunlu bir return ifadesi yoktur:

fahrenheit_to_celsius <- function(f) {
  (f - 32) * 5 / 9
}

print(fahrenheit_to_celsius(212))
print(fahrenheit_to_celsius(32))

return() vardır ve beklediğiniz gibi çalışır - fonksiyonu anında durdurup argümanını geri verir. Deyimsel R onu erken çıkışlar için saklar: bir girdi işin geri kalanını anlamsız kıldığında en başta dışarı çıkmak için. Onu if-else kontrolleriyle eşleştirin:

safe_divide <- function(a, b) {
  if (b == 0) {
    return(NA)   # early exit: division by zero has no useful answer
  }
  a / b          # normal path: last expression, returned automatically
}

print(safe_divide(10, 2))
print(safe_divide(10, 0))

Son satıra return(a / b) yazmak yanlış olmazdı, sadece gürültü olurdu. return() fonksiyonunu erken gerçekleşen çıkışlara ayırın ve normal yol için son ifadenin konuşmasına izin verin.

Varsayılan Değerler ve İsimli Argümanlar

Bir parametre, parametre listesinde = ile bildirilen bir varsayılan değer taşıyabilir. Varsayılandan memnun olan çağıranlar argümanı basitçe atlar:

greet <- function(name, greeting = "Hello", punctuation = "!") {
  paste0(greeting, ", ", name, punctuation)
}

print(greet("Ada"))
print(greet("Ada", "Hi"))
print(greet(punctuation = "?", name = "Ada", greeting = "Hey"))

Üçüncü çağrı hikâyenin diğer yarısını gösterir: isimli argümanlar. Çağrı yerinde name = "Ada" yazdığınızda konum önemini yitirir - R önce isme göre eşleştirir, sonra kalan parametreleri konuma göre doldurur. Bundan iki pratik kural çıkar:

• Zorunlu parametreleri başa, varsayılanlı olanları arkasına koyun ki konumsal çağrılar doğal kalsın.
• Çağrı yerinde, konumdan bariz olmayan her argümanı isimlendirin. greet("Ada", punctuation = "?"), okuru virgül saymaya zorlamaktan daha nettir.

... ile Argüman Aktarma

Özel parametre ... ("noktalar" diye okunur), "herhangi bir sayıda ek argüman" demektir. ... bildiren bir fonksiyon, hiç listelemediği argümanları kabul edip başka bir fonksiyona iletebilir:

shout <- function(..., punctuation = "!") {
  words <- paste(..., sep = " ")
  paste0(toupper(words), punctuation)
}

print(shout("good", "morning"))
print(shout("wait", "for", "it", punctuation = "..."))

shout(), kaç sözcük geçirdiğinizi bilmez ve umursamaz - hepsini paste() fonksiyonuna verir. punctuation parametresinin noktalardan sonra geldiğine dikkat edin: ... sonrasında bildirilen her parametre yalnızca isimle ayarlanabilir; seçenekler için tam olarak istediğiniz şey budur. Bu aktarma kalıbı temel R'de her yerdedir - sapply(x, round, digits = 2) çalışır, çünkü sapply kendi ... parametresi üzerinden digits = 2 argümanını round fonksiyonuna iletir.

Noktaların bedeli, yazım hatalarının sessizce sızmasıdır: punctuation yerine punctation yazın; hata vermek yerine ... içine yutulur. Nokta kullanan fonksiyonları küçük tutun.

İsimsiz Fonksiyonlar

Bir fonksiyona yalnızca bir kez ihtiyaç duyulduğunda - genellikle başka bir fonksiyona argüman olarak - ismi tamamen atlayabilirsiniz:

nums <- c(1, 2, 3, 4)

print(sapply(nums, function(x) x^2))
print(sapply(nums, \(x) x^2))

İki satır da aynı şeyi yapar. function(x) x^2 klasik yazımdır; \(x) x^2 ise R 4.1'de eklenen kısayoldur ve \ işareti function sözcüğünün yerini tutar. Tuş vuruşları dışında her açıdan özdeştirler - kısayol farklı türde bir fonksiyon değildir.

İşlem tek bir çağrı yerine bağlı tek satırlıksa isimsiz fonksiyon kullanın. Aynı lambda'yı iki yere yapıştırdığınız ya da o tek satırı aştığı anda ona bir isim verin - isimli bir fonksiyon test edilebilir ve kendini belgeler.

Kapsam: Bir Fonksiyon Neyi Görebilir

R sözcüksel kapsam kullanır: bir fonksiyon kendi parametreleri ve yerel atamaları arasında bulamadığı bir değişkene ihtiyaç duyduğunda, çağrıldığı yere değil tanımlandığı ortama bakar. Pratikte bu, bir fonksiyonun çevresindeki betikten değişken okuyabileceği anlamına gelir:

rate <- 0.1

add_tax <- function(price) {
  price * (1 + rate)   # rate is found in the surrounding script
}

print(add_tax(100))

change_inside <- function() {
  rate <- 0.5          # a new local variable - the outer rate is untouched
  rate
}

print(change_inside())
print(rate)

Madalyonun diğer yüzü: bir fonksiyonun içindeki atama asla dışarı sızmaz. change_inside içindeki rate <- 0.5, fonksiyon döndüğünde ölen yeni bir yerel değişken oluşturur; dıştaki rate hâlâ 0.1 yazdırır. Bu bir özelliktir - fonksiyonlar çalışma alanınızı kazara ezemez - ama iç atamanın kalıcı olmasını bekleyen yeni başlayanları şaşırtır. Bir fonksiyonun sonucu dış dünyaya vermesi gerekiyorsa onu döndürün ve çağrı yerinde atayın. (Dışarı uzanan bir <<- operatörü vardır; gerçekten ihtiyaç duyana kadar onu bir kod kokusu olarak görün.)

İşlenmiş Bir Örnek

İşte kazanç kalıbı: üç satır analizi tekrarladığınızı fark edin, onları bir fonksiyona sarın, yeniden kullanın. Diyelim ki ölçüm vektörlerini sürekli özetliyorsunuz:

describe <- function(x, digits = 2) {
  out <- c(
    n    = length(x),
    min  = min(x),
    mean = mean(x),
    max  = max(x)
  )
  round(out, digits)
}

print(describe(c(3.14159, 2.71828, 1.41421)))
print(describe(c(10, 20, 30, 40), digits = 0))

Bu sayfadan her şey burada: varsayılanlı bir digits parametresi, onu geçersiz kılan isimli bir çağrı ve döndürme işini yapan bir son ifade (round(out, digits)). Fonksiyon bir cümle gibi okunur, herhangi bir sayısal vektörde çalışır ve bir medyan eklemeye karar verdiğinizde tek bir yerde durur.

Buradan Ne Çıkarıyorsunuz

• name <- function(args) { body } bir fonksiyon oluşturur; değerlendirilen son ifade onun dönüş değeridir.
• return() erken çıkışlar içindir, normal son satır için değil.
• Varsayılanlar parametre listesinde = ile bildirilir; isimli argümanlar çağrı yerlerini sıradan bağımsız ve okunabilir kılar.
• ... fazladan argümanları kabul edip iletir - güçlüdür, ama yazım hatalarını gizler.
• function(x) ve \(x) aynı şeydir; tek seferlik tek satırlıklar için isimsiz fonksiyonlar kullanın.
• Fonksiyonlar değişkenleri tanımlandıkları yerden okur; içlerindeki atamalar içeride kalır.

Sırada: apply ailesi - sizin fonksiyonlarınızı alıp bütün vektörler ve listeler boyunca çalıştıran fonksiyonlar.