R’da İlk Adımlar – 1

Neden R? başlıklı yazımda R’ın benim için öneminden bahsetmiştim. Yazıyı paylaştıktan sonra Mehmet Hakan Satman hocamızdan güzel bir cevap geldi.

Şimdi, hesap makinemiz R’da ilk adımları atmaya başlayalım 😊

R programlama dili iki istatistikçi Ross Ihaka ve Robert Gentleman tarafından yazılmış ve ismini de bu istatistikçilerin baş harflerinden almıştır. Dilin tasarımında S ve Scheme dillerinin etkisi olmuştur. S, amacı to turn ideas into software, quickly and faithfully (fikirleri hızlı ve güvenli bir şekilde yazılıma dönüştürmek) olarak belirlenen ve Fortran diline alternatif olarak geliştirilen bir istatistiksel programlama dilidir. S dilinin ticari sürümü olan S-PLUS’ın lisans ücretlerinin pahalı olması sebebiyle 1991 yılında R dili ortaya çıkmış, 1993’te ilk duyurusu yapılmış ve 1995’te GPL (General Public Licence) denilen Genel Kamu Lisansı yayınlanmıştır ve R özgür yazılım olmuştur. 1997’de oluşturulan R Core Team (dünyanın çeşitli yerlerinden R’ı geliştirmek için bir araya gelenler) tarafından geliştirilen ilk sürümü R 1.0.0 2000 yılında piyasaya çıkmıştır. Bu yazı yazıldığı sırada en güncel sürümü 4.0.3’tür. Tarihsel olarak göstermek için aşağıdaki görseli hazırladım.

R-Project’in web sitesinde R şöyle tanımlanmıştır: İstatistiksel hesaplama ve grafikler için ücretsiz bir yazılım ortamıdır. Daha önce Eviews kullandığım için karşılaştırma amacıyla yazıyorum. R, Eviews ya da Eviews’e benzer programlar gibi istatistik paket programı değil; istatistiksel yazılım geliştirme ortamıdır. Aynı zamanda R interpreted denilen yorumlanan programlama dilleri arasındadır. Kısaca, makine diline çevirmeden girilen komutları doğrudan yerine getirir.

R’ı indirmek için öncelikle r-project sitesine gidilmelidir. R yazılımı CRAN (Comprehensive R Archive Network) denilen ve Kapsamlı R Arşiv Ağı diyebileceğimiz bir ağdan yüklenir. Dünyanın çeşitli yerlerindeki sunucular bu ağda yer alır ve biri seçilerek yükleme yapılabilir. Bu sunucular Türkiye’de Pamukkale Üniversitesi, Gedik Üniversitesi ve ODTÜ Kuzey Kıbrıs, Mersin kampüsünde bulunmaktadır.

R’ı indirdikten sonra bir de RStudio’yu kuracağız. RStudio, R için bir entegre geliştirme ortamıdır. Diğer bir ifadeyle, R ile olan iletişimimizi kolaylaştıran bir ortamdır. Başka bir ifade ile R konuşacağınız bir dil; Rstudio ise bu dili konuşacağınız bir yoldur. RStudio’nun sitesinden indirme işlemi gerçekleştirilebilir.

Rstudio’yu açtıktan sonra zamanla tanıyacağınız dörde bölünmüş bir ekran göreceksiniz. Biz Console bölümünden devam edeceğiz.

Dileyen Script’te de yazabilir. Bunun için File > New File > R Script seçenekleri takip edilerek ya da Ctrl + Shift + N ile bir script açılabilir.

Bilgisayarınızdan bir notepad açıp kodları yazıp .R olarak kaydetmek de aynı görevi görecektir. Script’i bu şekilde düşünebilirsiniz. Kaydettiğiniz yerde bir R dosyası görmüş olacaksınız. Console’da anlatacaklarımdan farklı olarak Script’te yazıyorsanız kodları ilgili satırdayken Ctrl+Enter ile veya Run butonu ile çalıştırabilirsiniz. Script’in tamamını çalıştırmak istiyorsanız Source’a tıklamalısınız. Script’i kaydetmek için kaydet ikonuna veya Ctrl+S’e basabilirsiniz.

Bundan sonraki derslerimi Script’ten anlatacağım.

Başlamadan bir not: Siz de eğer benim gibi beyaz ekranda çalışamıyorsanız başlamadan bunu değiştirebilirsiniz. Tools > Global Options… > Appearance yolunu takip ederek Editor Theme değiştirilebilir. Kişiselleştirdikten sonra Apply diyebilirsiniz.

Console bölümünde satırların > ile başladığını göreceksiniz. Bunlar default olarak oradadır ve her yeni satırda karşınıza çıkacaktır.

Yazdığınız her şey bir komuttur (command). Komutları yazdığınız her satır ise komut satırıdır (command-line).

Bir değeri bir değişkene atayabilmek için <- veya = operatörlerinden birini kullanabilirsiniz. Benim tercihim <- operatörüdür.

a <- 3
b = 3

Örneğin, sadece 3 yazsaydınız bu durumda bunu bellekte tutmayacaktınız. Bu, a ve b‘ye kaydedildi. Yani, obje yaratıldı. Örneğin, 3 değeri a ve b objelerine kaydedildi.

R, OOP (object oriented programming) denilen nesne yönelimli bir programlama dilidir. R’daki her şey nesnedir/objedir. Değişkenler, fonksiyonlar…

Atamayı yerlerini değiştirerek aşağıdaki gibi de yapabilirsiniz.

3 -> a

Bu objeleri Environment‘ta görebilirsiniz. Aşağıdaki gibi objeyi okutursanız içeriğini gösterecektir.

a
[1] 3

Sonucu [1] ile verdi. Bu çoklu da olabilirdi. Farkı 1:100 yazarak görmek mümkündür. [1]‘den bir sonraki satırda yer alan […] o satırın kaçıncı değer ile başladığını gösterir. Tabi bu ekran genişliğinize göre değişebilir. Bu arada : operatörü iki değer arasında yer aldığında o aralıktaki değerleri verir.

Environment’taki kayıtlı objeleri görmek için ls() fonksiyonunu kullanabilirsiniz.

ls()
[1] "a" "b"

İleride aşağıdaki kodu kullanacağız. Bu mevcut objeleri kaldırmanızı sağlar.

rm(list=ls())

Objeleri oluştururken başında sayısal bir değer ve özel bir karakter olmamasına dikkat edilmelidir. Örnek olarak aşağıdaki objeleri oluşturamayacaktır.

1a <- 3
Hata: unexpected symbol in "1a"

@a <- 3
Hata: beklenmeyen durum, '@' in "@"

Objeleri oluştururken bilinmesi gereken bir diğer konu R küçük-büyük harflere duyarlıdır. Aşağıdaki A objesi daha önce oluşturulan a objesinin yerini almayacaktır.

A <- 3

Daha önce alınmış bir obje ismi ile farklı bir değer kaydetmek isterseniz R sizden izin almadan bunu değiştirecektir. Bu durumda daha önce yaratılmış bir objenin üzerine yazmamaya dikkat etmelisiniz.

a <- 3
a
[1] 3

a <- 0
a
[1] 0

R’ı kısa bir tanıdıktan sonra şimdi veri tiplerine ve veri yapılarına bakalım.

R’ın temel veri tipleri numeric/double, integer, character ve logical‘dır (bunların dışında da duyabilirsiniz ama şimdilik onları pasifize ettim). Bir nesnenin sınıfını ve bir nesnenin tipini öğrenmek için sırasıyla class() ve typeof() fonksiyonları kullanılabilir.

numeric: Sayısal değerler içindir.

num1 <- 2020
class(num1)
[1] "numeric"

num2 <- 2.718
class(num2)
[1] "numeric"

Yukarıdaki değişkenlerin sınıfının numeric olduğunu öğrendik. Peki, veri tipleri nedir?

dbl1 <- 2020
typeof(dbl1)
[1] "double"

dbl2 <- 2.718
typeof(dbl2)
[1] "double"

Veri tipleri ise hem tam sayı hem ondalıklı olabilen double‘dır.

num2 değişkenine ait değer integer ya da tam sayı olarak int1 değişkenine atanabilir. as. yazdıktan sonra çıkan seçeneklerden dönüştürmek istediğinize tıklayabilirsiniz.

int1 <- as.integer(num2)
int1
[1] 2

typeof(int1)
[1] "integer"

integer olarak yazmanın bir diğer yolu da sonuna L (Long) eklemektir. Bu da aynı as.‘de olduğu gibi is. ile kontrol edilebilir. Eğer sonucu TRUE döndürüyorsa doğru; FALSE döndürüyorsa yanlış olacaktır.

is.integer(2)
[1] FALSE

is.integer(2L)
[1] TRUE

Her integer numeric’tir fakat her numeric integer değildir. Ne demek istediğimi numeric, double ve integer karşılaştırması ile anlatmaya çalışayım: 1 sayısının sınıfı numeric; tipi double’dır. 1.0 sayısının sınıfı numeric; tipi double’dır. 1L sayısının sınıfı da tipi de integer’dır ama bu aynı zamanda numeric’tir.

class(1);typeof(1);is.double(1);is.integer(1);is.numeric(1)
[1] "numeric"
[1] "double"
[1] TRUE
[1] FALSE
[1] TRUE

class(1.0);typeof(1.0);is.double(1.0);is.integer(1.0);is.numeric(1.0)
[1] "numeric"
[1] "double"
[1] TRUE
[1] FALSE
[1] TRUE

class(1L);typeof(1L);is.double(1L);is.integer(1L);is.numeric(1L)
[1] "integer"
[1] "integer"
[1] FALSE
[1] TRUE
[1] TRUE

R’da ; operatörünü kullanarak yukarıdaki gibi komutları yan yana da yazabilirsiniz.

Matematiksel işlemler yaptığımızda veri tipleri ne olur gelin bakalım.

typeof(1L + 2L)
[1] "integer"

İki integer veri tipini topladık ve tipinin integer olduğunu gösterdik. Şimdi de bölelim.

typeof(1L / 2L)
[1] "double"

Bölme işleminin sonucu 0.5 çıkacağı için veri tipi double oldu.

character: Tırnak içinde yazılanlar character’i işaret eder. character’i diğer programlama dillerinde string olarak da görebilirsiniz.

char1 <- "R"
typeof(char1)
[1] "character"

char2 <- "2.718"
typeof(char2)
[1] "character"

char2 değişkeni için double bir değer yazdık fakat tırnak içinde belirtmemiz onu character sınıfına dahil etti. Değişkenin numeric olup olmadığını kontrol edebiliriz.

is.numeric(char2)
[1] FALSE

Yeri gelmişken bahsedelim. Örneğin, mevsimler character olabilir. Ama bunlar bir kategoriyi temsil ediyorsa factor‘dır. İleride bolca karşılaşacağız.

logical:

is. kullandığımız zaman bize döndürdüğü sonuçların TRUE veya FALSE olduğunu gördük. Bu sonuçlar logical sınıfını temsil eder. Buna ilave olarak TRUE 1; FALSE 0‘dır. Örneğin, aşağıdaki sonucun 1 olması beklenir.

TRUE + FALSE
[1] 1

Bazı örneklere bakalım.

0.25 değeri 0.025’ten büyüktür.

0.25 > 0.025
[1] TRUE

-0.05 değeri -0.5’ten küçüktür.

-0.05 < -0.5
[1] FALSE

num2 değişkeni char2 değişkenine eşit değildir.

num2 == char2
[1] TRUE

Son örnekte şaşırdınız mı? num2 için double; char2 için character demiştik. Nasıl olur? Sebebi şu: Böyle durumlarda her iki taraf da character’e zorlanır. Aslında aşağıdaki yapılmıştır.

as.character(num2) == as.character(char2)
[1] TRUE

Bir de şu örneğe bakalım: 6 sayısı 3’e veya 9’a eşittir. | operatörü mantıksal veya demektir.

6 == 3 | 9
[1] TRUE

Sonucun FALSE olmasını bekleriz. Çünkü, 6 sayısı 3’e veya 9’a eşit değildir. Ancak sonucun TRUE olarak döndüğünü görüyoruz. Sebebi şu: 6 == 3 ifadesi FALSE’tur.

6 == 3
[1] FALSE

Mantıksal operatör olduğundan dolayı 9 sayısı aşağıdaki gibi logical ifadeye döner.

as.logical(9)
[1] TRUE

| operatörünün sol tarafı FALSE; sağ tarafı TRUE’dur. Bu durumda veya olduğu için sonucu TRUE döndürür. Mantıksal veya varsa bir tane TRUE olması yeterlidir.

FALSE | TRUE
[1] TRUE

Mantıksal operatör ve anlamına gelen & operatörü olsaydı, bu durumda FALSE döndürecekti.

6 == 3 & 9
[1] FALSE

Şunu da ekleyelim: Kısaca TRUE için T; FALSE için F kullanılabilir.

F & T
[1] FALSE

Veri tiplerinden sonra şimdi de veri yapılarına bakalım.

Dimension/BoyutHomogeneous/HomojenHeterogeneous/Heterojen
1Atomic/AtomikList/Liste
2Matrix/MatrisData Frame/Veri Çerçevesi
>2Array/Dizi

Scalar (skaler), R’daki en basit objedir ve tek bir değerden başka bir şey değildir.

skaler <- "R"
is.vector(skaler)
[1] TRUE

Vector (vektör) aynı tipteki elementler dizisidir ya da skalerlerin birleştirilmiş halidir. Aynı tipteki diyerek vektörlerin homojen olduğunu belirtmiş olduk. Vektör oluşturabilmek için c() fonksiyonunu kullanabiliriz.

vektor <- c(1,2,3,4,5)
class(vektor)
[1] "numeric"

typeof(vektor)
[1] "double"

Bu bir atomik vektördür. c() fonksiyonu birden çok elementi tek bir atomik vektörde birleştirdi. Atomik vektörün bir boyutu yoktur. Bunu dim() ile kontrol edebiliriz. Sonucu NULL olarak döndürecektir.

dim(vektor)
NULL

Yazılan değerlerin ise aynı sınıfa ait olması gerekiyor.

vektor <- c(1,2,3,4,"5")

Yukarıda görüldüğü gibi her ne kadar numeric değer yazsak da sonuçta bir tane bile character olduğu için hepsini character sınıfına zorladı. Tabi bu numeric sınıfına zorlanabilir.

vektor <- as.numeric(vektor)
class(vektor)
[1] "numeric"

Objeyi çalıştırdığınız zaman içindeki değerleri verecektir.

vektor
[1] 1 2 3 4 5

Bunlara names() fonksiyonu ile başlık atanabilir.

baslik <- c("B1","B2","B3","B4","B5")
names(vektor) <- baslik
vektor
B1 B2 B3 B4 B5 
 1  2  3  4  5 

Şu da yapılabilirdi:

vektor <- c("B1"=1,"B2"=2,"B3"=3,"B4"=4,"B5"=5)
vektor
B1 B2 B3 B4 B5 
 1  2  3  4  5 

Element sayısını ya da uzunluğu öğrenmek için ise length() fonksiyonu kullanılabilir.

length(vektor)
[1] 5

Eğer character olsaydı length() fonksiyonu şöyle sayacaktı:

vektor <- c("R Programlama Dili","Python Programlama Dili")
length(vektor)
[1] 2

Eğer içerideki her bir karakteri saydırmak istiyorsanız bunun için nchar() fonksiyonunu kullanabilirsiniz. nchar() fonksiyonu boşluklar dahil olmak üzere kaç tane karakter olduğu bilgisini verecektir.

nchar(vektor)
[1] 18 23

Boyut bilgisi alınmak istenirse bunu veren dim() fonksiyonunun sonucu NULL olacaktır. Yani, bir boyut yoktur.

vektor <- c("R Programlama Dili","Python Programlama Dili")
dim(vektor)
NULL

Yeri gelmişken NULL‘dan da bahsedelim. Çokça göreceğimiz NULL, NA, NaN ifadelerini karıştırılmamalıdır. Yukarıda olduğu gibi sonuç tanımlanamıyorsa fonksiyon NULL döndürür. Eğer sayısal olmayan bir ifade varsa bu durumda fonksiyon NaN (Not a Number) döndürür. Örneğin, sıfırı sıfıra bölelim.

0/0
[1] NaN

Son olarak, fonksiyon NA (Not Available) de döndürebilir. Bu kayıp veri olduğunu söyler. sum() fonksiyonu ile toplam almaya çalışalım.

sum(99,100,101,NA)
[1] NA

Ek olarak, eğer NA‘ye rağmen işlem gerçekleştirilmek istenirse na.rm = TRUE ile NA yok sayılabilir.

sum(99,100,101,NA, na.rm = TRUE)
[1] 300

Sütunları birleştiren cbind() ile iki tane vektör oluşturalım ve bunları satırları birleştiren rbind() ile birleştirelim. Böyle olunca dim() NULL vermeyecektir.

vektor1 <- cbind(1,2,3,4,5)
vektor2 <- cbind(-5,-4,-3,-2,-1)
matris <- rbind(vektor1, vektor2)
dim(matris)
[1] 2 5

Gördüğünüz gibi 2 satır ve 5 sütundan oluşan bir matrix (matris) oluşturdu. Birden fazla satır ve sütunlardan oluşan iki boyutlu yapıları matris olarak tanımlıyoruz. Array (dizi) ise iki boyuttan daha fazlasına sahiptir.

Yukarıdaki gibi yapmayıp matrix() ile aşağıdaki gibi de bir matris oluşturabiliriz.

matris <- matrix(data = 1, nrow = 5, ncol = 4)
class(matris)
[1] "matrix" "array"

dim(matris)
[1] 5 4

matris
     [,1] [,2] [,3] [,4]
[1,]    1    1    1    1
[2,]    1    1    1    1
[3,]    1    1    1    1
[4,]    1    1    1    1
[5,]    1    1    1    1

Şöyle bir vektörü matrise çevirelim.

vektor <- c(1,2,3,4,5,6,7,8,9)
matris <- matrix(data = vektor, nrow = 3, ncol = 3)
matris
     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

matrix() fonksiyonunun içindeki byrow seçeneğini kullanmadık ve önce sütunları doldurarak ilerledi. Aradaki farkı görmek için byrow = TRUE yapalım. Bu, önce satırları doldurarak ilerle anlamına gelmektedir.

matris <- matrix(data = vektor, nrow = 3, ncol = 3, byrow = TRUE)
matris
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9

Dizilerin matrislerden farkının 2 boyuttan fazlasına sahip olduklarını söylemiştik. Şimdi bir de dizi oluşturalım. Bu, array() ile yapılabilir. sample() ile iki tane random sayılardan (1 ve 100 arasında sırasıyla 10 ve 2 tane) oluşan bir vektör yaratılacak. Ardından bu iki vektör array() fonksiyonunun içinde birleştirilecek. Boyutu ise 2,2,3 olarak ayarlanacak. Bu, 2 satır ve 3 sütundan oluşan 2 ayrı matris oluşturacaktır.

vektor1 <- sample(x = 1:100, size = 10)
vektor2 <- sample(x = 1:100, size = 2)

dizi <- array(data = c(vektor1,vektor2), dim = c(2,3,2))
dizi
, , 1

     [,1] [,2] [,3]
[1,]   61   62   53
[2,]   73   74   80

, , 2

     [,1] [,2] [,3]
[1,]   89   25   70
[2,]  100   29   56

Şimdi list (liste) oluşturacağız. Bir listenin içine değerlerinizi koyabilirsiniz.

liste <- list(3.14, 2.71)

c() fonksiyonu ile birleştirdiklerinizi koyabilirsiniz.

liste <- list(c(3.14, 2.71), c(3,4,5))

Farklı sınıfları koyabilirsiniz.

liste <- list(3.14, c(3,4,5), "Euler")

Hatta farklı listeleri bir listenin içine koyabilirsiniz.

liste1 <- list(3.14, 2.71)
liste2 <- list(c(3,4,5), c("x","y","z"))
liste <- list(liste1, liste2)
class(liste)
[1] "list"

İçeriğini str() fonksiyonu ile görebilirsiniz.

str(liste)
List of 2
 $ :List of 2
  ..$ : num 3.14
  ..$ : num 2.71
 $ :List of 2
  ..$ : num [1:3] 3 4 5
  ..$ : chr [1:3] "x" "y" "z"

RStudio’daki ekranlardan Environment’a gelip oluşturulan listenin yanındaki küçük okları aşağıya indirerek de içerik görüntülenebilir.

Geldik R’daki kutsal veri çerçevesine.

Bir data frame ya da veri çerçevesi içine her şeyi alabilir.

df <- data.frame(
  sutun1 = seq(1,9,1),
  sutun2 = letters[1:9],
  sutun3 = rep(c("A1","A2","A3"), each = 3),
  sutun4 = seq(as.Date("2020-11-21"), as.Date("2020-11-29"), "days")
)

str(df)
'data.frame':	9 obs. of  4 variables:
 $ sutun1: num  1 2 3 4 5 6 7 8 9
 $ sutun2: chr  "a" "b" "c" "d" ...
 $ sutun3: chr  "A1" "A1" "A1" "A2" ...
 $ sutun4: Date, format: "2020-11-21" "2020-11-22" "2020-11-23" ...

Yukarıdaki veri çerçevesinin içine sırasıyla numeric, character, factor ve Date attık. Her biri df (data frame’e atıf) isimli veri çerçevesinin içinde saklanıyor. Bunu str() fonksiyonu ile gördük. Ama bir şey dikkatinizi çekmiştir: sutun3 factor değil. Başta da factor sınıfının character sınıfına benzediğini ama kategoriyi temsil edişi bakımından ayrıldığını söylemiştik. Bunu veri çerçevesini oluştururken başına as.factor() yazarak da çevirebilirdik; aşağıdaki gibi de.

df$sutun3 <- as.factor(df$sutun3)
class(df$sutun3)
[1] "factor"

Yukarıda olduğu gibi $ operatörü ile veri çerçevesinin sütunlarını görebiliriz.

Veri çerçevesini oluştururken bazı yeni fonksiyonlar görmüş oldunuz. seq() ile değerleri tek tek yazmak yerine başlangıç ve bitiş değerleri ile ardışıklığı belirledik. Yine aynı fonksiyon ile başlangıç ve bitiş ile frekansı belirleyerek tarihleri yazdırdık. letters() ile dokuz tane harfi aldık. rep() ile belirttiğimiz kategorik değerleri her biri üç defa olacak şekilde yazdırdık.

Bu fonksiyonlar üzerine biraz daha örnek yapalım.

-10’dan 10’a kadar ikişer artacak şekilde yazdıralım.

seq(-10, 10, 2)
[1] -10  -8  -6  -4  -2   0   2   4   6   8  10

A1, B1, C1 değerlerini 3 defa yazdır.

rep(c("A1","B1","C1"), times = 3)
[1] "A1" "B1" "C1" "A1" "B1" "C1" "A1" "B1" "C1"

A1, B1, C1 değerlerinin her birini 3 defa yazdır.

rep(c("A1","B1","C1"), each = 3)
[1] "A1" "A1" "A1" "B1" "B1" "B1" "C1" "C1" "C1"

Kullanıcıdan bir isim isteyelim ve ismini yazdığında ona “Günaydın, …” diyelim. readline() fonksiyonunu önce bir değişkene atamadan çalıştırın ve sonucu görün. Ardından bunu bir isim değişkenine atayarak devam edelim.

readline(prompt = "Merhaba, isminizi öğrenebilir miyim? ")
Merhaba, isminizi öğrenebilir miyim? 
[1] "RPy"

print() ile sonucu yazdırabiliriz.

isim <- readline(prompt = "Merhaba, isminizi öğrenebilir miyim? ")
print(isim)
[1] "RPy"

Çıktıyı güzelleştirmek için paste() veya paste0() fonksiyonlarından faydalanabiliriz. Bunlar birleştirme görevi görür. İkisi de kullanılabilir.

paste("Günaydın,",isim,sep = " ")
[1] "Günaydın, RPy"

paste0("Günaydın, ",isim)
[1] "Günaydın, RPy"

İlk fonksiyonda birleştireceklerimizi yazıp sonunda ne ile ayrılacağını belirtebiliriz. İkincisinde ise nasıl yazarsak o şekilde birleştirir.

print(paste0("Günaydın, ",isim))
[1] "Günaydın, RPy"

Bir de şu örneğe bakalım.

paste0(1,"-",2,"-",3,"-",4,"-",5,"-",6,"-",7,"-",8,"-",9,"-",10)
[1] "1-2-3-4-5-6-7-8-9-10"

paste(1,2,3,4,5,6,7,8,9,10, sep = "-")
[1] "1-2-3-4-5-6-7-8-9-10"

paste(1:10, collapse = "-")
[1] "1-2-3-4-5-6-7-8-9-10"

1’den 10’a kadar sayıları aralarında “-“ olacak şekilde üç farklı yol ile yazdırdık. paste() fonksiyonunda sep ayırma görevi görürken; collapse birleştirme görevi görür.

Bir diğer işe yarar fonksiyonlardan tolower() ve toupper()‘ı tanıyalım. İlki büyük harfleri küçük; ikincisi küçük harfleri büyük yapar.

tolower("EGE")
[1] "ege"

toupper("assos")
[1] "ASSOS"

Uygulama yaptıkça daha çok fonksiyon ile karşılaşacağız.

R’da paket kavramı da değinmem gereken bir nokta. Yukarıda herhangi bir pakete ihtiyaç duymadan bazı R ile beraber gelen fonksiyonları kullandık. Fakat ilerledikçe paketlere olan ihtiyacımız da artacak. Paketler işlerimizi kolaylaştıran kütüphanelerdir. Eğer bir paketten faydalanmak istiyorsak öncelikle onu bir defalığına yüklememiz gerekiyor.

install.packages("paket_ismi")

Paketi yükledikten sonra ondan faydalanmak için onu çağırmamız gerekiyor.

library(paket_ismi)

Başta da isminden bahsettiğimiz CRAN çok geniş bir paket ağına sahiptir. Fakat kullanmak istediğimiz paketler her zaman CRAN‘de olmayabilir. Github hesabından da pakete ihtiyacımız olabilir. Bu durumda başka bir paketten faydalanıp github‘taki paketi yükleyebiliriz.

install.packages("devtools")
library(devtools)
install_github("github_hesabı/paket_ismi")

Paketin bir fonksiyonundan faydalanmak için o paketi library() ile çağırmak şart değildir. Aşağıdaki :: yöntemi ile de pakete ait fonksiyon kullanılabilir.

devtools::install_github("github_hesabı/paket_ismi")

Eğer kodların başına # koyarsanız bu yorum (comment) anlamına gelir. Bu işaret kodu pasifize eder; yani çalıştırmaz. Ya da yazılan kodların yanına yorumlar eklenebilir.

#devtools::install_github("github_hesabı/paket_ismi")

Yeri gelmişken bir comment kültürüne ihtiyacımız olduğunu hatırlatmak istiyorum. Lütfen yazdığınız kodlara comment ekleyin ki bir sonraki kodunuzu okuyan kişi ne döndüğünü anlasın. Hatta o kişiyi geçtim o anlamayan kişi, kendi koduna yabancı, siz bile olabilirsiniz 😒

m <- mean(c(3.14,2.71)) #pi ve euler sayısının ortalamasını aldım

Kod yazarken bug ve debug kelimeleri ile sık sık karşılacağız. Bug hatayı; debug bu hataları ayıklamayı ifade eder. R’da nelerle karşılaşabileceğinizden kısaca bahsedeyim.

Yazının başlarından da bahsettiğim gibi R’da kod yazma satırı > sembolü ile başlar. Kod sırasında eğer bir alt satıra geçerseniz bu defa > sembolü yerine + sembolünü görürsünüz.

> vektorum <- c(1,2,
+

Örneğin, bir de 3 yazacağınızı varsayalım. Bu durumda ya 3) şeklinde 3 yazıp parantezi kapatırsınız ya da klavyenizdeki Esc tuşu ile default’a dönebilirsiniz. Yani, > sembolüne.

Tabi her zaman + sembolünü görmeyebilirsiniz. RStudio’da parantez açtığınızda o parantez aynı anda otomatik olarak kapatılır.

vektorum <- c(1,2,)
Error in c(1, 2, ) : argüman 3 boş

Yukarıdaki gibi bir anda enter‘a basarsanız Error alırsınız.

Bir diğer hata olarak fonksiyon ismini ya da değişken ismi yanlış yazılabilir.

veri <- c(1,2,3,4,5,6)
sun(veri)
Error in sun(veri) : "sun" fonksiyonu bulunamadı

sum() fonksiyonu yanlış yazıldığı için hata verdi.

Ya da fonksiyon doğru yazılıp obje yanlış yazılabilir.

sum(verı)
Hata: 'verı' nesnesi bulunamadı

.

.

.

Evet, geldik yazının sonuna. R’da İlk Adımlar serisinin ilkini bitirmiş olduk. Bu yazıda R’ın tarihinden, nasıl yükleneceğinden, R ve Rstudio’nun ne olduğundan; ayrıca özellikle console’dan, veri tipleri ve yapılarından (özellikle vektörlerden), temel bazı fonksiyonlardan, birkaç hatadan olabildiğince dengeleyerek bahsetmiş oldum. Daha detaylı anlatılabilirdi fakat bir anda her şeyin öğrenilmeyeceğini bildiğim için uzatıp kafa karıştırmak istemedim. İleride çok fazla uygulama yapacağız. Bu seride öğrendiklerinizi o uygulamalarda yerine koyacak ve hatta doğal olarak daha fazlasını öğreneceksiniz.

Bir sonraki yazıda görüşmek dileğiyle.

3 thoughts on “R’da İlk Adımlar – 1

  • Geri bildirim: R’da İlk Adımlar – 2 – 3σ Eğitim

  • 11 Nisan 2021 tarihinde, saat 15:57
    Permalink

    Anlatımınız için çok teşekkürler. 3 günde yavaş yavaş okuyup uygulayarak yazınızı tamamladım ve defterime notlar aldım. R ile ilgili yeni yazılarınızı görmek umuduyla… İyi günler dilerim.

    Yanıtla
    • 1 Mayıs 2021 tarihinde, saat 11:43
      Permalink

      İlginize çok teşekkür eder; başarılar dilerim.

      Yanıtla

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir