Yeni Başlayanlar için R'de Pipe Eğitimi

R'de dplyr ile veri düzenlemeyi daha yakından öğrenmek ister misiniz? dplyr ile R'de Veri Manipülasyonu kursumuza göz atın.

R'de Pipe Operatörü: Giriş

R'deki pipe operatörünün ne olduğunu ve onunla neler yapabileceğinizi anlamak için, resme geniş açıdan bakmak ve tarihçesini öğrenmek gerekir. "Bu tuhaf sembol birleşimi nereden geliyor ve neden böyle yapılmış?" gibi sorular aklınızda olabilir. Bu bölümde bu ve benzeri soruların yanıtlarını keşfedeceksiniz.

Tarihe üç açıdan bakabilirsiniz: matematiksel açıdan, programlama dillerine bütünsel bir bakış açısından ve R dilinin kendi açısından. Birazdan üçünü de ele alacaksınız!

R'de Pipe Operatörünün Tarihi

Matematiksel Tarihçe

İki fonksiyonunuz varsa, diyelim ki $f : B → C$ ve $g : A → B$, bir fonksiyonun çıktısını alıp bir sonrakine vererek bu fonksiyonları birbirine bağlayabilirsiniz. Kısaca, "zincirleme" bir ara sonucu bir sonraki fonksiyona aktarmak anlamına gelir; bununla ilgili daha fazlasını birazdan göreceksiniz.

Örneğin $f(g(x))$ diyebilirsiniz: $g(x)$, $f()$ için bir girdi görevi görürken, $x$ elbette $g()$ için girdidir.

Bunu notasyonla göstermek isterseniz, "g'nin ardından f" okunacak şekilde $f ◦ g$ yazımını kullanırsınız. Alternatif olarak bunu görsel olarak şöyle gösterebilirsiniz:

Diğer Programlama Dillerinde Pipe Operatörleri

Bu bölümün girişinde belirtildiği gibi, bu operatör programlama dünyasında yeni değil: Shell veya Terminal'de komutları pipe karakteri | ile birinden diğerine aktarabilirsiniz. Benzer şekilde, F# dilinde de ileride önemli olacak bir ileri pipe operatörü vardır! Son olarak, Haskell'in de Shell veya Terminal'den türetilmiş birçok pipe işlemi içerdiğini bilmek faydalıdır.

R'de Pipes

Artık diğer programlama dillerinde pipe operatörünün tarihine kısaca baktığınıza göre, R'ye odaklanma zamanı. Bu operatörün R'deki tarihi 17 Ocak 2012'de, bir anonim kullanıcının şu Stack Overflow gönderisinde şu soruyu sormasıyla başlar:

F#'ın ileri pipe operatörü R'de nasıl uygulanabilir? Bu operatör, hesaplamalar dizisini kolayca zincirlemeyi mümkün kılar. Örneğin, bir girdi veriniz olduğunda ve foo ve bar fonksiyonlarını sırasıyla çağırmak istediğinizde, data |> foo |> bar yazabilirsiniz?

Yanıt, McMaster Üniversitesi'nden profesör Ben Bolker'den geldi ve şöyle dedi:

Gerçek bir kullanımda ne kadar işe yarar emin değilim, ama bu (sanki?) en azından tek argümanlı fonksiyonlar için istediğinizi yapıyor gibi ...

"%>%" <- function(x,f) do.call(f,list(x))
pi %>% sin
[1] 1.224606e-16
pi %>% sin %>% cos
[1] 1
cos(sin(pi))
[1] 1

Yaklaşık dokuz ay sonra, Hadley Wickham GitHub'da dplyr paketini başlattı. Hadley'i bugün RStudio'da Chief Scientist olarak, pek çok popüler R paketinin yazarı (bu son paket gibi!) ve R'de Fonksiyon Yazmaya Giriş kursumuzun eğitmeni olarak biliyor olabilirsiniz.

Ancak, bu pakette ilk pipe %.% 2013'e kadar görünmedi. Adolfo Álvarez'in blog yazısında haklı olarak belirttiği gibi, fonksiyonun adı chain() idi ve amacı birden fazla fonksiyonun tek bir R data frame'ine uygulanması için notasyonu basitleştirmekti.

%.% pipe uzun süre ortalıkta kalmadı; zira Stefan Bache, 29 Aralık 2013'te bugün bildiğiniz operatörü de içeren bir alternatif önerdi:

iris %>%
  subset(Sepal.Length > 5) %>%
  aggregate(. ~ Species, ., mean)

Bache bu pipe işlemi üzerinde çalışmaya devam etti ve 2013'ün sonunda magrittr paketi ortaya çıktı. Bu sırada Hadley Wickham dplyr üzerinde çalışmayı sürdürdü ve Nisan 2014'te, %.% operatörü bugün bildiğiniz %>% ile değiştirildi.

Aynı yılın ilerleyen döneminde, Kun Ren GitHub'da pipeR paketini yayımladı; bu paket, pipe sürecine daha fazla esneklik katmak üzere tasarlanan farklı bir pipe operatörü %>>% içeriyordu. Ancak, özellikle Tidyverse'ün son yıllardaki popülaritesiyle %>%'ün R dilinde yerini sağlamlaştırdığını söylemek güvenli olur.

R Pipe Operatörü Nedir?

Tarihçeyi bilmek bir şey, ama bu yine de F#'ın ileri pipe operatörünün ne olduğu ve R'de gerçekte ne yaptığı hakkında bir fikir vermez.

F#'ta ileri pipe operatörü |>, zincirlenmiş metot çağrıları için bir sözdizimi kolaylığıdır. Daha basit söylemek gerekirse, bir ara sonucu bir sonraki fonksiyona geçirmenizi sağlar.

Unutmayın ki "zincirleme", birden fazla metot çağrısı yapmanız anlamına gelir. Her metot bir nesne döndürdüğünden, ara sonuçları depolamak için değişkenlere ihtiyaç duymadan, çağrıların tek bir ifadede birbirine zincirlenmesine olanak tanırsınız.

R'de pipe operatörü, gördüğünüz gibi, %>%'dür. F# ile aşina değilseniz, bu operatörü bir ggplot2 ifadesindeki +'ya benzetebilirsiniz. İşlevi F# operatörünün gördüğünüz işleve çok benzer: Bir ifadenin çıktısını alır ve bir sonraki ifadenin girdisi yapar. Bunu tarif ederken bir "SONRA" gibi düşünebilirsiniz.

Örneğin aşağıdaki kod bloğunu alın ve yüksek sesle okuyun:

iris %>%
  subset(Sepal.Length > 5) %>%
  aggregate(. ~ Species, ., mean)

Doğru, yukarıdaki kod bloğu "Iris verisini alıyorsunuz, sonra veriyi alt kümeliyorsunuz ve sonra veriyi özetliyorsunuz" gibi bir şeye karşılık gelir.

Bu, Tidyverse'ün en güçlü yönlerinden biridir. Aslında, standartlaştırılmış bir işleme adımları zincirine "pipeline" denir. Bir veri biçimi için pipeline oluşturmak harikadır; çünkü aynı biçimlendirmeye sahip gelen verilere bu pipeline'ı uygulayıp örneğin ggplot2 dostu bir çıktı elde edebilirsiniz.

Neden R Pipe'larını Kullanmalı?

R fonksiyonel bir dildir; bu da kodunuzun sıklıkla çok sayıda parantez, ( ve ) içerdiği anlamına gelir. Kodunuz karmaşıklaştığında, genellikle bu parantezleri iç içe geçirmeniz gerekir. Bu da R kodunuzu okumayı ve anlamayı zorlaştırır. İşte burada %>% imdadınıza yetişir!

Aşağıdaki örneğe bakın; bu, iç içe yazılmış koda tipik bir örnektir:

# `x`'i başlatın
x <- c(0.109, 0.359, 0.63, 0.996, 0.515, 0.142, 0.017, 0.829, 0.907)

# `x`'in logaritmasını hesaplayın, uygun şekilde gecikmeli ve yinelenen farkları döndürün, 
# üstel fonksiyonu hesaplayın ve sonucu yuvarlayın
round(exp(diff(log(x))), 1)

1. 3.3
2. 1.8
3. 1.6
4. 0.5
5. 0.3
6. 0.1
7. 48.8
8. 1.1

%<%'ün yardımıyla yukarıdaki kodu şu şekilde yeniden yazabilirsiniz:

# `magrittr`'ı içe aktarın
library(magrittr)

# Yukarıdakiyle aynı hesaplamaları `x` üzerinde gerçekleştirin
x %>% log() %>%
    diff() %>%
    exp() %>%
    round(1)

Zor mu görünüyor? Endişelenmeyin! Bu eğitimin ilerleyen kısımlarında bunu nasıl yapacağınızı daha ayrıntılı öğreneceksiniz.

Not: Yukarıdaki kodun çalışması için magrittr kütüphanesini içe aktarmanız gerekir. Çünkü pipe operatörü, yukarıda okuduğunuz gibi, magrittr kütüphanesinin bir parçasıdır ve 2014'ten beri dplyr'ın da bir parçasıdır. Kütüphaneyi içe aktarmayı unutursanız, Error in eval(expr, envir, enclos): could not find function "%>%" gibi bir hata alırsınız.

Ayrıca, log, diff ve exp sonrası parantez eklemek zorunlu olmasa da, R topluluğunda bazıları kodun okunabilirliğini artırmak için bunu tercih eder.

Kısacası R'de pipe kullanmanız için dört neden şunlardır:

• Veri işlemlerinizin sırasını içten dışa doğru değil, soldan sağa doğru kurgularsınız;
• İç içe fonksiyon çağrılarından kaçınırsınız;
• Yerel değişkenlere ve fonksiyon tanımlarına olan ihtiyacı en aza indirirsiniz; ve
• İşlem dizisinin herhangi bir yerine adım eklemeyi kolaylaştırırsınız.

Bu nedenler magrittr dokümantasyonundan alınmıştır. Okunabilirlik ve esneklik argümanlarının öne çıktığını görüyorsunuz.

Ek Pipe'lar

%>% her ne kadar magrittr paketinin (ana) pipe operatörü olsa da, aynı paketin parçası olan ve bilmeniz gereken birkaç başka operatör daha vardır:

• Bileşik atama operatörü %<>%;

# `x`'i başlatın 
x <- rnorm(100)

# `x`'in değerini güncelleyin ve `x`'e atayın
x %<>% abs %>% sort

• Tee operatörü %T>%;

rnorm(200) %>%
matrix(ncol = 2) %T>%
plot %>% 
colSums

Not: Şimdilik bilmeniz gereken, yukarıdaki kod bloğunun aslında şunun kısayolu olduğudur:

rnorm(200) %>%
matrix(ncol = 2) %T>%
{ plot(.); . } %>% 
colSums

Ama bununla ilgili daha fazlasını ileride göreceksiniz!

• Serim (exposition) pipe operatörü %$%.

data.frame(z = rnorm(100)) %$% 
  ts.plot(z)

Elbette bu üç operatör, ana %>% operatöründen biraz farklı çalışır. Bu eğitimin ilerleyen kısımlarında işlevlerini ve kullanım biçimlerini göreceksiniz.

Not: En sık magrittr pipe'larını görseniz de, ilerledikçe başka pipe'larla da karşılaşabilirsiniz! Örneğin wrapr'ın dot arrow pipe'ı %.>% ya da to dot pipe'ı %>.% veya Bizarro pipe ->.;.

R'de Pipe'lar Nasıl Kullanılır

Artık %>% operatörünün nasıl ortaya çıktığını, ne olduğunu ve neden kullanmanız gerektiğini bildiğinize göre, şimdi onu nasıl avantajınıza kullanabileceğinizi keşfetme zamanı. Göreceksiniz ki pek çok kullanım yolu var!

Temel R Piping

Operatörün daha gelişmiş kullanımlarına geçmeden önce, en temel örneklere bakmak iyi olur. Özünde, yeni başlarken izleyebileceğiniz üç kural göreceksiniz:

• f(x), x %>% f olarak yeniden yazılabilir

Kısaca, tek argüman alan function(argument) biçimindeki fonksiyonlar şöyle yeniden yazılabilir: argument %>% function(). Bu ikisinin eşdeğer olduğunu anlamak için aşağıdaki daha pratik örneğe bakın:

# `x`'in logaritmasını hesaplayın 
log(x)

# `x`'in logaritmasını hesaplayın 
x %>% log()

• f(x, y), x %>% f(y) olarak yeniden yazılabilir

Elbette sadece tek argüman alan değil, birden fazla argüman alan birçok fonksiyon vardır. Burada da durum böyle: Fonksiyon iki argüman alıyor, x ve y. İlk örnekte gördüklerinize benzer şekilde fonksiyonu şu yapıyı izleyerek yeniden yazabilirsiniz: argument1 %>% function(argument2); burada argument1 magrittr yer tutucusu, argument2 ise fonksiyon çağrısıdır.

Tüm bunlar teorik geliyor olabilir. Daha pratik bir örneğe bakalım:

# Pi'yi yuvarlayın
round(pi, 6)

# Pi'yi yuvarlayın 
pi %>% round(6)

• x %>% f %>% g %>% h, h(g(f(x))) olarak yeniden yazılabilir

Karmaşık görünebilir, ama gerçek bir R örneğine baktığınızda öyle değildir:

# `babynames` verisini içe aktarın
library(babynames)
# `dplyr` kütüphanesini içe aktarın
library(dplyr)

# Veriyi yükleyin
data(babynames)

# "Taylor" isimli küçük erkek bebeklerden kaç kişi doğmuş sayın
sum(select(filter(babynames,sex=="M",name=="Taylor"),n))

# Aynısını şimdi `%>%` ile yapın
babynames%>%filter(sex=="M",name=="Taylor")%>%
            select(n)%>%
            sum

Not: İç içe yazılmış kodu yeniden yazarken içten dışa doğru çalıştığınıza dikkat edin: Önce babynames'i koyuyor, sonra %>% ile önce veriyi filter() ediyorsunuz. Ardından n'i seçiyor ve son olarak her şeyi sum() ile topluyorsunuz.

Unutmayın ki bu eğitimin başında x üzerinde hesaplama yapmak için log(), diff(), exp() ve round() fonksiyonlarını kullandığınız, böyle bir iç içe kodun daha okunabilir koda dönüştürüldüğü başka bir örnek daha görmüştünüz.

Geçerli Ortamı Kullanan Fonksiyonlar

Ne yazık ki, önceki bölümde belirtilen genel kuralların bazı istisnaları vardır. Bunlardan bazılarına burada bakalım.

assign() fonksiyonunu kullanarak x değişkenine 10 değerini atadığınız şu örneği düşünün.

# `10`'u `x`'e atayın
assign("x", 10)

# `100`'ü `x`'e atayın 
"x" %>% assign(100)

# `x`'i döndürün
x

10

assign() fonksiyonunun pipe ile yapılan ikinci çağrısının düzgün çalışmadığını görüyorsunuz. x'in değeri güncellenmedi.

Neden?

Çünkü fonksiyon, yeni 100 değerini %>% tarafından kullanılan geçici bir ortama atar. Bu nedenle assign()'i pipe ile kullanmak istiyorsanız, ortamı açıkça belirtmelisiniz:

# Ortamınızı tanımlayın
env <- environment()

# Ortamı `assign()`'e ekleyin
"x" %>% assign(100, envir = env)

# `x`'i döndürün
x

100

Tembel Değerlendirmeye Sahip Fonksiyonlar

R'de fonksiyon içindeki argümanlar, fonksiyon onları kullandığında hesaplanır. Bu, fonksiyonunuzu çağırmadan önce hiçbir argümanın hesaplanmadığı anlamına gelir. Bu da pipe'ın fonksiyonun her öğesini sırayla hesapladığı anlamına gelir.

Bu durumun sorun olduğu yerlerden biri, hataları yakalayıp ele almanızı sağlayan tryCatch()'tir; örneğin şu şekilde:

tryCatch(stop("!"), error = function(e) "An error")

stop("!") %>% 
  tryCatch(error = function(e) "An error")

'An error'

Error in eval(expr, envir, enclos): !
Traceback:


1. stop("!") %>% tryCatch(error = function(e) "An error")

2. eval(lhs, parent, parent)

3. eval(expr, envir, enclos)

4. stop("!")

Bu satırı iç içe yazmanın gayet iyi çalıştığını, pipe'lı alternatifin ise hata döndürdüğünü göreceksiniz. Benzer davranışa sahip diğer fonksiyonlar base R'deki try(), suppressMessages() ve suppressWarnings()'dır.

Argüman Yer Tutucusu

Pipe operatörünü bir argüman yer tutucusu olarak kullanabileceğiniz durumlar da vardır. Aşağıdaki örneklere bakın:

• f(x, y), y %>% f(x, .) olarak yeniden yazılabilir

Bazı durumlarda, magrittr yer tutucusunu fonksiyon çağrısında ilk pozisyona koymak istemezsiniz; şimdiye dek gördüğünüz tüm örneklerde durum böyleydi. Şu kod satırını yeniden ele alın:

pi %>% round(6)

Bu satırı yeniden yazarsanız, pi, round() fonksiyonunuzda ilk argüman olur. Peki ya ikinci, üçüncü vb. argümanı değiştirip onu fonksiyon çağrınızda magrittr yer tutucusu olarak kullanmak isterseniz?

Değerin fonksiyon çağrısında aslında üçüncü pozisyonda olduğu şu örneğe bakın:

"Ceci n'est pas une pipe" %>% gsub("une", "un", .)

'Ceci n\'est pas un pipe'

• f(y, z = x), x %>% f(y, z = .) olarak yeniden yazılabilir

Benzer şekilde, fonksiyon çağrınızdaki belirli bir argümanın değerini magrittr yer tutucusu yapmak isteyebilirsiniz. Şu kod satırını düşünün:

6 %>% round(pi, digits=.)

Yer Tutucuyu Özelliklerde Yeniden Kullanma

Sağ taraftaki ifadede yer tutucuyu birkaç kez kullanmak açıktır. Ancak yer tutucu yalnızca iç içe ifadelerde görünüyorsa, magrittr yine de ilk argüman kuralını uygular. Bunun nedeni, çoğu durumda daha temiz kodla sonuçlanmasıdır.

İç içe fonksiyon çağrılarında argüman yer tutucularıyla çalışırken dikkate alabileceğiniz bazı genel "kurallar" şunlardır:

• f(x, y = nrow(x), z = ncol(x)), x %>% f(y = nrow(.), z = ncol(.)) olarak yeniden yazılabilir

# `ma` matrisini başlatın 
ma <- matrix(1:12, 3, 4)

# Girilen değerlerin maksimumunu döndürün
max(ma, nrow(ma), ncol(ma))

# Girilen değerlerin maksimumunu döndürün
ma %>% max(nrow(ma), ncol(ma))

12

12

Bu davranış, sağ tarafı süslü parantez içine alarak geçersiz kılınabilir:

• f(y = nrow(x), z = ncol(x)), x %>% {f(y = nrow(.), z = ncol(.))} olarak yeniden yazılabilir

# Yalnızca `nrow(ma)` ve `ncol(ma)` giriş değerlerinin maksimumunu döndürün
ma %>% {max(nrow(ma), ncol(ma))}

4

Son olarak, iç içe fonksiyon çağrısında argüman yer tutucusunun çalışma şeklini ayarlamak isteyebileceğiniz aşağıdaki örneğe de bakın:

# Yeniden yazmak istediğiniz fonksiyon
paste(1:5, letters[1:5])

# Nokta yer tutuculu iç içe fonksiyon çağrısı
1:5 %>%
  paste(., letters[.])

1. '1 a'
2. '2 b'
3. '3 c'
4. '4 d'
5. '5 e'

1. '1 a'
2. '2 b'
3. '3 c'
4. '4 d'
5. '5 e'

Yer tutucu yalnızca iç içe bir fonksiyon çağrısında kullanılırsa, magrittr yer tutucusunun da ilk argüman olarak yerleştirildiğini görürsünüz! Bunun olmasını istemiyorsanız, süslü parantezleri { ve } kullanabilirsiniz:

# Nokta yer tutuculu ve süslü parantezli iç içe fonksiyon çağrısı
1:5 %>% {
  paste(letters[.])
}

# Yukarıdaki fonksiyon çağrısını yeniden yazın 
paste(letters[1:5])

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

Unary Fonksiyonlar Oluşturma

Unary fonksiyonlar tek argüman alan fonksiyonlardır. Bir nokta . ile başlayan, ardından fonksiyonlar gelen ve %>% ile zincirlenen herhangi bir pipeline, daha sonra değerlere uygulamak istediğinizde kullanılabilir. Böyle bir pipeline'a şu örneğe bakın:

. %>% cos %>% sin

Bu pipeline bir girdi alır, ardından buna hem cos() hem de sin() fonksiyonları uygulanır.

Ancak henüz bitmedi! Bu pipeline'ın az önce okuduğunuz şeyi yapmasını istiyorsanız, önce onu örneğin f adlı bir değişkene atamanız gerekir. Sonrasında pipeline içinde yer alan işlemleri diğer değerler üzerinde yapmak için tekrar kullanabilirsiniz.

# Unary fonksiyon
f <- . %>% cos %>% sin 

f

structure(function (value) 
freduce(value, `_function_list`), class = c("fseq", "function"
))

Unutmayın ki okunabilirliği artırmak isterseniz, kod satırında cos() ve sin() fonksiyonlarından sonra parantez de koyabilirsiniz. Parantezli aynı örneği düşünün: . %>% cos() %>% sin().

Görüyorsunuz, magrittr ile fonksiyon inşa etmek base R ile fonksiyon inşa etmeye oldukça benzer! Ne kadar benzer olduklarından emin değilseniz, yukarıdaki satıra bakın ve aşağıdaki satırla karşılaştırın; Her iki satır da aynı sonucu verir!

# eşdeğerdir 
f <- function(.) sin(cos(.)) 

f

function (.) 
sin(cos(.))

Bileşik Atama Pipe İşlemleri

Bazen sol taraftaki değeri üzerine yazmak istersiniz; hemen aşağıdaki örnekte olduğu gibi. Sezgisel olarak bunu yapmak için atama operatörü <-'ı kullanırsınız.

# Iris verisini yükleyin
iris <- read.csv(url("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"), header = FALSE)

# Iris verisine sütun adları ekleyin
names(iris) <- c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species")

# `iris$Sepal.Length`'in karekökünü hesaplayın ve değişkene atayın
iris$Sepal.Length <- 
  iris$Sepal.Length %>%
  sqrt()

Ancak, pipeline sonucunu doğrudan sol tarafa atamanıza olanak veren bir bileşik atama pipe operatörü vardır:

# `iris$Sepal.Length`'in karekökünü hesaplayın ve değişkene atayın
iris$Sepal.Length %<>% sqrt

# `Sepal.Length`'i döndürün
iris$Sepal.Length

Not: Bileşik atama operatörü %<>%'nün çalışması için zincirdeki ilk pipe operatörü olması gerekir. Bu, operatörün, tekrara dayalı daha uzun bir gösterimin kısaltması olmasıyla tamamen tutarlıdır; o uzun gösterimde normal <- atama operatörünü kullanırsınız.

Sonuç olarak bu operatör, bir pipeline'ın sonucunu döndürmek yerine atama yapar.

Tee Operatörü ile Tee İşlemleri

Tee operatörü tıpkı %>% gibi çalışır, ancak sağ taraftaki işlemlerin olası sonucunu değil, sol taraftaki değeri döndürür.

Bu, plot() ile çizim yapmak veya bir dosyaya yazdırmak gibi yan etkisi için kullanılan fonksiyonları dahil ettiğiniz durumlarda işinize yarar.

Başka bir deyişle, plot() gibi fonksiyonlar genellikle bir şey döndürmez. Bu da örneğin plot()'u çağırdıktan sonra pipeline'ınızın biteceği anlamına gelir. Ancak aşağıdaki örnekte %T>% tee operatörü, plot()'u kullandıktan sonra bile pipeline'a devam etmenizi sağlar:

set.seed(123)
rnorm(200) %>%
matrix(ncol = 2) %T>%
plot %>% 
colSums

Serim Operatörü ile Veri Değişkenlerini Açığa Çıkarmak

R ile çalışırken birçok fonksiyonun bir data argümanı aldığını görürsünüz. Örneğin lm() fonksiyonu veya with() fonksiyonu. Bu fonksiyonlar, verinizin önce işlenip ardından fonksiyona geçirildiği bir pipeline'da kullanışlıdır.

cor() gibi data argümanı olmayan fonksiyonlar için de verideki değişkenleri açığa çıkarabilmek faydalıdır. İşte %$% operatörü burada devreye girer. Şu örneği düşünün:

iris %>%
  subset(Sepal.Length > mean(Sepal.Length)) %$%
  cor(Sepal.Length, Sepal.Width)

0.336696922252551

%$% yardımıyla Sepal.Length ve Sepal.Width'ün cor()'a açığa çıkmasını sağlıyorsunuz. Benzer şekilde, data.frame() fonksiyonundaki verinin, bir grafikte birden çok zaman serisini çizdirmek için ts.plot()'a geçirildiğini görürsünüz:

data.frame(z = rnorm(100)) %$%
  ts.plot(z)

dplyr ve magrittr

Bu eğitimin girişinde, dplyr ve magrittr geliştirmesinin yaklaşık aynı dönemde, yani 2013-2014 civarında gerçekleştiğini öğrenmiştiniz. Ve okuduğunuz gibi, magrittr paketi Tidyverse'ün de bir parçasıdır.

Bu bölümde, R kodunuzda her iki paketi birleştirmenin ne kadar keyifli olabileceğini keşfedeceksiniz.

dplyr paketine yeni olanlar için, bu R paketinin beş fiil etrafında inşa edildiğini bilmelisiniz: "select", "filter", "arrange", "mutate" ve "summarize". Daha önce herhangi bir veri bilimi projesi için veriyi düzenlediyseniz, bu fiillerin veriniz üzerinde genel olarak gerçekleştirmeniz gereken veri manipülasyonu görevlerinin çoğunu oluşturduğunu bilirsiniz.

Bu dplyr fonksiyonlarını kullanan bazı geleneksel koda bir örnek verelim:

library(hflights)

grouped_flights <- group_by(hflights, Year, Month, DayofMonth)
flights_data <- select(grouped_flights, Year:DayofMonth, ArrDelay, DepDelay)
summarized_flights <- summarise(flights_data, 
                arr = mean(ArrDelay, na.rm = TRUE), 
                dep = mean(DepDelay, na.rm = TRUE))
final_result <- filter(summarized_flights, arr > 30 | dep > 30)

final_result

Bu örneğe baktığınızda, dplyr ve magrittr'ın neden birlikte bu kadar iyi çalışabildiğini hemen anlarsınız:

hflights %>% 
    group_by(Year, Month, DayofMonth) %>% 
    select(Year:DayofMonth, ArrDelay, DepDelay) %>% 
    summarise(arr = mean(ArrDelay, na.rm = TRUE), dep = mean(DepDelay, na.rm = TRUE)) %>% 
    filter(arr > 30 | dep > 30)

Her iki kod bloğu da oldukça uzun, ancak ikinci kod bloğunun tüm işlemleri takip etmek açısından daha net olduğunu söyleyebilirsiniz. İlk kod bloğunda ara değişkenler oluşturarak kodun "akıcılığını" kaybedebilirsiniz. %>% kullanarak, veriler üzerinde gerçekleştirilen işlemlere daha net bir genel bakış elde edersiniz!

Kısacası, R'de veri manipülasyonu için dplyr ve magrittr hayal gibi bir ikilidir!

RStudio'da Pipe'lar için Klavye Kısayolları

Tüm bu pipe'ları R kodunuza eklemek zorlayıcı olabilir! İşinizi kolaylaştırmak için, Win-Vector, LLC'nin kurucu ortağı ve Baş Danışmanı ve DataCamp eğitmeni John Mount, R'de pipe'lar için klavye kısayolları oluşturmanıza olanak tanıyan bazı RStudio eklentileri içeren bir paket yayımladı. Eklentiler aslında biraz özel kayıt metadatasına sahip R fonksiyonlarıdır. Basit bir eklenti örneği, sık kullanılan bir metin parçasını ekleyen bir fonksiyon olabilir; ancak çok karmaşık da olabilir!

Bu eklentilerle, RStudio IDE içinde R fonksiyonlarını etkileşimli olarak çalıştırabilir, bunu klavye kısayollarıyla veya Addins menüsü üzerinden yapabilirsiniz.

Not: Bu paket aslında RStudio'nun orijinal eklenti paketinin bir çatallanmasıdır. Ancak dikkatli olun; eklentiler için destek yalnızca RStudio'nun en güncel sürümünde mevcuttur! Konu hakkında daha fazla bilgi için RStudio eklentileri hakkındaki bu makaleye göz atın.

Eklentileri ve klavye kısayollarını GitHub'dan indirebilirsiniz.

R'de Pipe Operatörünü Ne Zaman Kullanmamalı

Yukarıda, R ile programlama yaparken pipe'ların kesinlikle kullanmanız gereken bir şey olduğunu gördünüz. Daha spesifik olarak, pipe'ların çok faydalı olduğunu kanıtladığı bazı durumları ele aldınız! Ancak, Hadley Wickham'ın "R for Data Science" kitabında belirttiği bazı durumlarda pipe'lardan kaçınmanız daha iyidir:

• Pipe'larınız (örneğin) on adımdan uzunsa.

Bu tür durumlarda, anlamlı isimlere sahip ara nesneler oluşturmak daha iyidir. Bu yalnızca kodunuzu hata ayıklamayı kolaylaştırmakla kalmaz; kodunuzu daha iyi anlarsınız ve başkalarının da anlaması kolaylaşır.

• Birden fazla girdiniz veya çıktınız varsa.

Eğer tek bir birincil nesneyi dönüştürmüyor, iki veya daha fazla nesneyi birleştiriyorsanız, pipe kullanmamak daha iyidir.

• Karmaşık bağımlılık yapısına sahip yönlendirilmiş bir grafiği düşünmeye başladıysanız.

Pipe'lar temelde doğrusaldır ve onlarla karmaşık ilişkileri ifade etmek yalnızca okunması ve anlaşılması zor karmaşık kodla sonuçlanır.

• Dahili paket geliştirmesi yapıyorsanız

Dahili paket geliştirmede pipe kullanmak uygun değildir; hata ayıklamayı zorlaştırır!

Bu konuya dair daha fazla görüş için bu Stack Overflow tartışmasına bakın. O tartışmada geçen diğer durumlar arasında döngüler, paket bağımlılıkları, argüman sırası ve okunabilirlik vardır.

Kısacası, bu yapıyı harika kılan iki şeyi aklınızda tutabilirsiniz: okunabilirlik ve esneklik. Bu iki büyük avantajdan biri tehlikeye girdiği anda, pipe'lar yerine alternatifleri düşünmeniz yerinde olabilir.

R'de Pipe Alternatifleri

Tüm bu okuduklarınızdan sonra R programlama dilindeki bazı alternatiflerle de ilgileniyor olabilirsiniz. Bu eğitimde gördüğünüz çözümlerden bazıları şunlardı:

• Anlamlı isimlere sahip ara değişkenler oluşturmak;

Tüm işlemleri birbirine zincirleyip tek bir sonuç üretmek yerine zinciri parçalayın ve ara sonuçları ayrı değişkenlerde saklayın. Bu değişkenlerin adlandırılmasına dikkat edin: Amaç her zaman kodunuzu mümkün olduğunca anlaşılır kılmak olmalıdır!

• Kodunuzu içten dışa doğru okunacak şekilde iç içe yazmak;

Pipe'lara karşı olası itirazlardan biri, base R ile alıştığınız "akıma" aykırı olmasıdır. Çözüm, kodunuzu iç içe yazmaya devam etmektir! Ama pipe'ları sevmiyorsanız ve iç içe yazımın da kafa karıştırıcı olduğunu düşünüyorsanız? Burada çözüm, hiyerarşiyi vurgulamak için sekmeler kullanmak olabilir.

Sonuç

Bu R pipe'ları eğitiminde çok şey öğrendiniz: %>%'ün nereden geldiğini, tam olarak ne olduğunu, neden ve nasıl kullanmanız gerektiğini gördünüz. dplyr ve magrittr paketlerinin birlikte harika çalıştığını ve daha başka operatörler de olduğunu gördünüz. Son olarak, R ile programlarken kullanmamanız gereken bazı durumları ve bu durumlarda kullanabileceğiniz alternatifleri de öğrendiniz.

Tidyverse hakkında daha fazla bilgi edinmek istiyorsanız, DataCamp'in Introduction to the Tidyverse kursunu değerlendirin.