Dr. Öğr. Üyesi İsmail Hakkı KINALIOĞLU


Merhaba arkadaşlar dersimizle ilgili döküman ve paylaşımlara Netderslerim adresinden erişebilirsiniz…


Yorum Satırı Oluşturma

Yorum satırı yaratmaak için satır başına # işareti koyulur. Eğer çok satırlı bir yorum yapılacaksa “Ctlr + Shift + C” kısayolu veya Code menüsü altındaki “Comment/Uncomment Lines” komutu kullanılabilir.


Değişken Tanımlama

R’da değişken yaratmak için ekstra bir tanımlama satırına ihtiyaç yoktur. Değişkene atadığınız değere göre tipi otomatik belirlenir.

Bu ders notlarında çoğu zaman atama operatörü olarak “=” kullanılmıştır.

numeric veya double (reel sayılar)

a=1.2

integer (tamsayılar)

b=5L

complex (karmaşık sayılar)

c=complex(real = a, imaginary = b)
d=complex(2, 3) #complex (karmaşık sayılar)

#character (metin)

e="Selçuk Üniversitesi"

#ogical veya boolean: TRUE,FALSE (mantıksal)

f=TRUE

Eğer bir değer atamadan değişken oluşturmak istersek değişkenin tipini aşağıdaki örneklerde görüldüğü gibi belirtmemiz gerekir.

num <-numeric()
int <- integer()
com <- complex()
char <- character()
log <- logical()

Bir değişkeni silmek için “rm” komutu kullanılır.

d1=5
rm(d1)

Değişken Tip Kontrolü ve Tip Dönüşümü

Deişken tiplerini birbirine dönüştürmek için “as.” komutu kullanılır. Ör:“as.integer()”, “as.character” gibi…

Değişken tiplerini kontrol etmek için “is.” komutu kullanılır. Ör:“is.integer()”, “is.character” gibi…

d1=175
is.double(d1) #Reel sayı kontrolü
## [1] TRUE
is.integer(d1) #Tam sayı kontrolü
## [1] FALSE
is.character(d1) #String ifade kontrolü
## [1] FALSE
d1_i=as.integer(d1) 
is.double(d1_i) #Reel sayı kontrolü
## [1] FALSE
is.integer(d1_i) #Tam sayı kontrolü
## [1] TRUE
is.character(d1_i) #String ifade kontrolü
## [1] FALSE
d1_c=as.character(d1)
is.double(d1_c) #Reel sayı kontrolü
## [1] FALSE
is.integer(d1_c) #Tam sayı kontrolü
## [1] FALSE
is.character(d1_c) #String ifade kontrolü
## [1] TRUE
# is.numeric ise sayısal ifade kontrolü için kullanılır. Reel ya da tam sayı olması farketmez.
is.numeric(d1)
## [1] TRUE
is.numeric(d1_i)
## [1] TRUE
is.numeric(d1_c)
## [1] FALSE

Nchar() Fonksiyonu

Character (String) tipli değişkenlerin yada metinsel ifadelerin uzunluğunu **"nchar()*"" komutu ile öğreniriz.

c1="Selçuk Üniversitesi"
uzunluk=nchar(c1)
uzunluk
## [1] 19

PASTE, CAT, PRINT

R’ın base paketinde console’a birşeyler yazdırmak için farklı alternatiflere sahibiz. Print, Paste ve Cat fonksiyonları bu amaçla sıklıkla kullanılmaktadır.

Tek bir değişkeni ya da sonucu yazdırırken genelde Print fonksiyonunu kullanırken birden çok değerin aynı anda ekrana yazdırılacağı durumlarda Paste ve Cat fonksiyonlarını kullanabiliriz. Bu iki fonksiyon küçük farklarla birbirinden ayrılır ve genelde birbirleri yerine de kullanılabilirler. Bazı durumlarda ise sahip oldukları farklılıklardan yararlanmak amacıyla özellikle bir tanesini seçebiliriz. Bu farklılıkları anlamanız amacıyla aşağıdaki örnekleri inceleyebilirsiniz. Örneklerde vektör tipli değişkenler kullanılmıştır. Vektör ve benzeri değişkenler hakkında ilerleyen bölümlerde detaylı bilgiler verilecektir.

v1=123
v2=456 
paste(v1,v2)  #paste kullanımı sonucu oluşan çıktı character tipli bir değerdir ve character tipli bir değişkene aktarılabilir. 
## [1] "123 456"
cat(v1,v2) # cat kullanımı sonucu oluşan çıktı print ile elde edilen çıktı gibidir ve bir değişkene aktarılamaz.
## 123 456
paste_ciktisi=paste(v1,v2)

cat_ciktisi=cat(v1,v2)
## 123 456
print(paste_ciktisi) #bu değişkenin değeri "123 456" dır.
## [1] "123 456"
print(cat_ciktisi) #bu değişkenin değeri ise NULL yani yoktur...
## NULL

Hem paste hem de cat fonksiyonlarında birleştirilen değerler arasında kullanılacak bir ayıraç belirlenebilir. Bir ayıraç belirlenmedği sürece boşluk " " varsayılan ayıraç olarak kullanılır…

v1=123
v2=456 
paste(v1,v2,sep = "-")  
## [1] "123-456"
cat(v1,v2,sep = "-") 
## 123-456

Elde edilen bu çıktılar bir değişkene aktarılsa paste ile elde edilen çıktının birleştirilen değerler kadar eleman sayısına sahip character tipli bir vektör olduğu görülür. cat ile elde edilen değer bir değişkene aktarılmak istendiğine ise değişkenin değerinin NULL yani boş olduğu görülür.

paste ile birleştirilen değerleri karakter tipli bir dizi yerine tek bir değişkende toplamak istersek collapse parametresini kullanabiliriz.

m1="Merhaba"
m2="Dünya"
m3=paste(m1,m2,collapse="")
m3 #sep parametresi belirtilmediği için varsayılan ayıraç boşluk olarak kullanılıyor.
## [1] "Merhaba Dünya"

paste kullanılırken collapse parametresi ile aynı zamanda bir dizinin elemanları yan yana yazılmış karakter tipli bir değişkene dönüştürülür. Bu işlem esnasında collapse içerisinde yazılacak değer ayıraç olarak kullanılır.

v1=c("a","b","c")
v2=c(1,2,3)

birlestirilmis_v1=paste(v1,collapse = "-")
birlestirilmis_v2=paste(v2,collapse = "-")

birlestirilmis_v1
## [1] "a-b-c"
birlestirilmis_v2
## [1] "1-2-3"
#kontrol edersek değişken tiplerinin karakter olduğu görülmektedir.
class(birlestirilmis_v1) 
## [1] "character"
class(birlestirilmis_v1)
## [1] "character"

cat ve paste fonksiyonlar vektörlerin birleşiminde de kullanılır.

vektor1=c(1,2,3,4,5,6)
vektor2=c("a","b","c")

paste(vektor1,vektor2)
## [1] "1 a" "2 b" "3 c" "4 a" "5 b" "6 c"
cat(vektor1,vektor2)
## 1 2 3 4 5 6 a b c
#iki birleşimin arasındaki farkı incelerseniz cat ve paste arasındaki farklara güzel bir örnek olduğunu göreceksiniz...
u1=c("a","b")
u2=25
u3=c("1,2,3,4")
u4="Programlama"

paste(u1,u2,u3,u4)
## [1] "a 25 1,2,3,4 Programlama" "b 25 1,2,3,4 Programlama"
cat(u1,u2,u3,u4)
## a b 25 1,2,3,4 Programlama
#ayıraç olarak "-" kullanarak yazarsak çıktısı aşağıdaki gibi olur.
a5=paste(u1,u2,u3,u4,sep="-")
a6=cat(u1,u2,u3,u4,sep="-")
## a-b-25-1,2,3,4-Programlama
#paste birleştirilen ilk vektörün eleman sayısı kadar uzunlukta ve elemanları karakter tipinde olan bir vektör oluşturur. Vektörün elemanları birleştirilen vektörlerin belirtilen ayıraçlar ile yan yana yazılmış halleridir. 
#cat belirtilen ayıracı araya koyup herşeyi birleştirip tek bir değer üretir.

Paste ve Cat’i ilerleyen bölümlerde daha farklı örneklerle de kullanma şansı yakalayacağız.

Prompt
Kullanıcıdan veri almak için “prompt” komutu kullanılır.

ad <- readline(prompt="Adınızı girin: ")
## Adınızı girin:
yas <- readline(prompt="Yaşınızı girin: ")
## Yaşınızı girin:
yas <- as.integer(yas)
#print(paste("Merhaba,", ad, " yaşınızı", yas , "olarak girdiniz"))

Substr ve Substring
Bir string ifadeden belli bir parça almak için “substr()” ya da “substring()” komutu kullanılabilir. Substr ve Substring kullanımında üç parametre vardır. İlk olarak parça alınacak olan karakter dizini ya da bu kararkter dizinini temsil eden değişkenin adı yazılır ardından virgüller ile ayrılarak sırası ile kopyalamaya başlanacak kararkter indisi ve kopyalamanın sonlanacağı kararkter indisi yazıır.
Yani substr(“Programlama”,2,4) demek “programlama” kelimesinin 2. harfinden 4. harfine kadar kopyala ve al demektir. Kelimenin ilk harfinin indisi 1 olarak kabul edilir.

metin="Selçuk Üniversitesi"
ch1=substr(metin,3,6) 
ch2=substring(metin,9,14)
ch1
## [1] "lçuk"
ch2
## [1] "nivers"


Koşul İfadeleri “if else”

Birçok programlama dilinde olduğu gibi R programlama dilinde de belli bir koşulun gerçekleşip gerçekleşmediğini sınamak adına en sık kullanılan komut if komutudur. Sorgu oluşturulurken tek bir koşul ya da birden çok koşulun gerçekleşme durumu kontrol edilebilir.

En basit haliye bir sorgu örneği aşağıdaki gibidir.

sayi=5
if (sayi>3) {print("sayı 3'den büyük...")}
## [1] "sayı 3'den büyük..."

Sorgu kalıbı oluşturulurken if ifadesinden sonra ilk olarak normal parantezler arasında sorguyu ardından da küme parantezleri arasında bu sorgu sağlandığı zaman gerçekleşecek olan olayı yazarız. Bazı durumlarda sorgu sağlanmadığı zaman da gerçekleşecek bir olay olabilir. Bu durumu ifade etmek için sorguya else ifadesi ekleyerek sorgu sağlanmadığı zaman gerçekleşecek olan olayı da belirtiriz.

sayi=2
if (sayi>3) {print("sayı 3'den büyük...")} else {print("sayı 3'den büyük değil")}
## [1] "sayı 3'den büyük değil"

Bazen de if kalıbı içerisine yazılan sorgunun sağlanmaması durumunda birden çok olay gerçekleşebilir. Örneğin bir öğrencinin ortalamasına bakara harf notu belirlemek istediğimiz bir problemi baz alalım ve aşağıdaki gibi bir not baremi kullanalım.

85-100 —-> AA
80-84 —-> BA
75-79 —-> BB
70-74 —-> CB
60-69 —-> CC
<60 —-> FF

Bu durumda sorguya AA ya da FF’i sağlayan şartı yazarak başlayıp diğer durumları sorgunun sağlanmadığı durumlar olarak ele alalım. Böyle bir sorguyu oluşturabilmek için sorgunun devamında else yerine else if ifadesi kullanılmaktadır.

vize=80
final=60
ort=vize*0.4+final*0.6
ort=round(ort,0)
if (ort>=60) {sonuc="Geçtiniz"} else {sonuc="Kaldınız"}

if (ort>=85) {harf="AA"} else
  if (ort<85 && ort>=80) {harf="BA"} else
    if(ort<80 && ort>=75) {harf="BB"} else
      if(ort<75 && ort>=70) {harf="CB"} else
        if(ort<70 && ort>=60) {harf="CC"} else
          if(ort<60) {harf="FF"} 


cat(ort,"Ortalama ve",harf,"harf notu ile",sonuc)
## 68 Ortalama ve CC harf notu ile Geçtiniz

Sorgunun sağlanmadığı durumda birden fazla sonucun olduğu olaylara farklı bir örnek olarak aşağıda vücut kitle indeksi hesaplaması yapılmıştır.

yas <- readline(prompt="Yaşınızı girin: ")
## Yaşınızı girin:
if (yas<18) {print("18 Yaşından büyük olmalısınız")} 
## [1] "18 Yaşından büyük olmalısınız"
#Vücut Kitle Endeksi Hesaplama
# İdeal Kilonun Altı                   vki < 18.5
# İdeal Kilo                      18.5 < vki < 25
# İdeal Kilonun Üzeri             25 < vki < 30
# İdeal Kilonun Çok Üzeri              vki > 30

#boy <- as.numeric(readline(prompt="Metre cinsinden boyunuzu yazınız: "))

#kilo <- as.numeric(readline(prompt = "Kilonuzu yazınız: ")) 

boy <- 1.75

kilo <- 85


vki=kilo/(boy*boy)

if (vki>30) {print("İdeal kilonuzun çok üzerindesiniz")} else 
  if (vki>25 && vki<30) {print("İdeal kilonuzun üzerindesiniz")} else 
    if (vki>18.5 && vki<25) {print("İdeal kilonuzdasınız")} else 
      if (vki<18.5) {print("ideal kilonuzun altındasınız")}
## [1] "İdeal kilonuzun üzerindesiniz"

If koşul ifadesinde birden çok şartın aynı anda sağlanması gerekirse && ayıracı ile ard arda yazılabilirler. Eğer birden çok şart var ise sadece bir tanesinin sağlanması yeterliyse bu durumda || ayıracı ile ard arda yazılabilirler…


Döngüler

For döngüsü 
for (i in 1:5){
print("Merhaba Dünya")
}
## [1] "Merhaba Dünya"
## [1] "Merhaba Dünya"
## [1] "Merhaba Dünya"
## [1] "Merhaba Dünya"
## [1] "Merhaba Dünya"
for (i in 1:nchar(metin)){
print(substr(metin,i,i))
}
## [1] "S"
## [1] "e"
## [1] "l"
## [1] "ç"
## [1] "u"
## [1] "k"
## [1] " "
## [1] "Ü"
## [1] "n"
## [1] "i"
## [1] "v"
## [1] "e"
## [1] "r"
## [1] "s"
## [1] "i"
## [1] "t"
## [1] "e"
## [1] "s"
## [1] "i"
For döngüsünden kaçış 
for (i in 1:10) {
  print("Selçuk Üniversitesi")
   if (i == 4) {
    break
  } 
  
}
## [1] "Selçuk Üniversitesi"
## [1] "Selçuk Üniversitesi"
## [1] "Selçuk Üniversitesi"
## [1] "Selçuk Üniversitesi"
While döngüsü 
i <- 1
while (i < 6) {
  print(i)
  i <- i + 1
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
While döngüsünden kaçış 
i <- 1
while (i < 6) {
  print(i)
  i <- i + 1
  if (i == 4) {
    break
  }
}
## [1] 1
## [1] 2
## [1] 3
While döngüsünde değer atlama 
i <- 0
while (i < 6) {
  i <- i + 1
  if (i == 3) {
    next
  }
  print(i)
}
## [1] 1
## [1] 2
## [1] 4
## [1] 5
## [1] 6


Bazı Basit Matematiksel Fonksiyonlar

Toplama işlemi için " + " operatörü kullanılır. Fark işlemi için " - " operatörü kullanılır. Çarpma işlemi için " * " operatörü kullanılır. Bölme işlemi için " / " operatörü kullanılır. Üs alma işlemi için " ^ " operatörü kullanılır.


Karekök işlemi için sqrt() fonksiyonu kullanılır.

k1=sqrt(9)
print(k1)
## [1] 3

Faktöriyel için factorial() fonksiyonu kullanılır.

k2=factorial(5)
print(k2)
## [1] 120

Kombinasyon işlemi için choose(n,x) fonksiyonu kullanılır.

k3=choose(7,4)
print(k3)
## [1] 35

Bir sayıyı kendinden küçük en yakın tam sayıya yuvarlamak için floor() fonksiyonu kullanılır.

k4=floor(15.4)
print(k4)
## [1] 15

Bir sayıyı kendinden büyük en yakın tam sayıya yuvarlamak için ceiling() fonksiyonu kullanılır.

k5=ceiling(15.4)
print(k5)
## [1] 16

Bir sayının virgülden sonraki basamak sayısını belirlemek için round(x , digits = ) fonksiyonu kullanılabilir. Round fonksiyonu aynı zamanda bir sayıyı kendine en yakın tam sayıya yuvarlamak için de kullanılır.

k6=round(10/3,digits = 5)
print(k6)
## [1] 3.33333

Bir sayıyı soldan belirlenen basamak sayısına göre yuvarlamak için signif(x , digits) fonksiyonu kullanır.

k7=signif(175869.14543,digits=4)
print(k7)
## [1] 175900

Bir sayının mutlak değerini almak için abs() fonksiyonu kullanılır.

k8=abs(-2.45)
print(k8)
## [1] 2.45


VEKTÖR - MATRİS - DİZİ - VERİ ÇERÇEVESİ - LİSTE

Pek çok programlama dilinde yukarıda bahsi geçen kavramlar sadece dizi olarak adlandırılır. R programlama dili gerek vektör tabanlı çalışma mantığı gerekse de sahip olduğu matematiksel ve istatistiksel hesaplama olanaklarının yanında etkin veri analizi kütüphanelerine de paralel olarak dizi veri tipini çeşitli amaçlar doğrultusunda kullanılabilecek farklı tiplere ayırmıştır.


VEKTÖRLER

Vektörler tek boyutlu dizilerdir. Sayısal, karakter ya da mantıksal değerler içerebilirler ancak tüm elemanları aynı türde olmalıdır. Atomik vektörler olarak da adlandırılırlar. Farklı tipte veriler içeren vektörler ise liste olarak adlandırılır. Vektörler aşağıdaki örneklerde gösterildiği gibi oluşturulabilir… Tek satır ve eleman sayısı kadar sütuna sahip olan bir matris olarak da değerlendirilebilirler.
Vektörleri yaratmak için c() komutu kullanılır

Vektor1=c(3,7,-5,2)  # Yöntem - 1

#veya

assign("Vektor1",c(3,7,-5,2)) # Yöntem - 2

##şeklinde tanımlanabilir ama genelde pratikliği açısından 1. yöntem tercih edilir.

Vektor1
## [1]  3  7 -5  2
Vektor2=c(1:6)
Vektor2
## [1] 1 2 3 4 5 6
vektor3=c("a",5,9) #vektör tanımlanırken "a" karakteri oluşturulduğu için normalde nümerik değerler olan 5 ve 9 da vektör içerisine karakter olarak tanımlanır.
vektor3
## [1] "a" "5" "9"

Bir vektör yaratılırken daha önceden var olan başka bir vektör de kullanılabilir…

Vektor4=c(1,2,3)
Vektor5=c(4,5,Vektor4)
Vektor5
## [1] 4 5 1 2 3

Vektörlerin ve Elemanlarının Uzunlukları

Vektörlerin boyutları olmaz uzunlukları olur, bu uzunlukları öğrenmek için length komutu kullanılır.

Vektor6=c(3,5,6,7,2,6,7)
length(Vektor6)
## [1] 7

Vektörlerin elemanlarının karakter tipli değerler olduğu durumlarda bu elemanların her birinin karakter sayısını öğrenmek için nchar() fonksiyonu kullanılabilir…

Vektor7=c("abc","def","ghıi","jklmno")

nchar(Vektor7)
## [1] 3 3 4 6

Vektöre Yeni Eleman Ekleme
Bir vektöre yeni bir eleman eklemek için “append()” komutu kullanılır.

Vektor8=c(1,2,3,4,5,6)
append(Vektor8,7) #Bu kod parçacığı ekleme işleminin önizlemesini gösterir. Eğer ekleme işlemini gerçekleştirmek istiyorsak ekleme işlemine ek olarak oluşan yeni vektörü bir değişkene atamalıyız. Bu değişken vektörün kendisi de olabilir.
## [1] 1 2 3 4 5 6 7
Vektor8=append(Vektor8,7)
Vektor8
## [1] 1 2 3 4 5 6 7

Vektör Elemanlarının İndeksi
Vektöerleri tek boyutlu diziler olarak tanımlamıştık. İndeksler, her bir vektör elemanının bu dizi içerisindeki konumunu bir başka deyişle de kaçıncı elemanı olduğunu gösterir. Vektörün ilk elemanının indeksi 1’dir. İndeks değerleri vektör isminin önüne yazılan [] köşeli parantezler arasında yazılır.Ör: Vektor_ismi[indeks_değeri]

Vektor9=c(11,12,13,14,15)
Vektor9[1]
## [1] 11
Vektor9[3]
## [1] 13

Vektör Elemanlarının Güncellenmesi
İndeks değerleri kullanılarak vektör elemanları silinebilir yada içerikleri değerler güncellenebilir.

Vektor10=c(11,12,13,14,15)
Vektor10[1]=22 #Güncellendi
Vektor10
## [1] 22 12 13 14 15
Vektor11=c(11,12,13,14,15)
print("Vektor11'in ilk hali")
## [1] "Vektor11'in ilk hali"
Vektor11
## [1] 11 12 13 14 15
print("Silme işlemi sonrası oluşacak yeni vektör içeriğinin ön izlemesi")
## [1] "Silme işlemi sonrası oluşacak yeni vektör içeriğinin ön izlemesi"
Vektor11[-3] # İndeksi 3 olan eleman yani soldan 3. eleman silindi.
## [1] 11 12 14 15
#Eleman silme işlemi bu haliyle gerçekleştirilirse Vektor11'in içeriğinde bir değişiklik olmaz.
#Vektor11'in içeriğini de değiştirmek istersek, atama ve silme işlemini aynı anda yapmalıyız.

print("Silme ile atama yapılmadığı için Vektor11'in içeriği korunuyor")
## [1] "Silme ile atama yapılmadığı için Vektor11'in içeriği korunuyor"
Vektor11
## [1] 11 12 13 14 15
print("Atama ve silme aynı anda yapıldığı için 3. eleman silinmiş ve vektör içeriği güncellenmiş")
## [1] "Atama ve silme aynı anda yapıldığı için 3. eleman silinmiş ve vektör içeriği güncellenmiş"
Vektor11=Vektor11[-3]
Vektor11
## [1] 11 12 14 15

Vektörlerde Mantıksal Sorgulamalar
s Vektör elemanları ile çeşitli şekillerde mantıksal sınamalar gerçekleştirilebilir.
Örneğin mantıksal operatörleri kullanarak bir vektörün elemanlarının belirli bir şarta uyup uymadığını kontrol edelim.

Vektor12=c(-2,3,-4,1,0,-7,5,-7)
Vektor12<3 #Bu şartı sağlayan elemanlar için "TRUE", sağlamayanlar için ise "FALSE" değeri üretilecek.
## [1]  TRUE FALSE  TRUE  TRUE  TRUE  TRUE FALSE  TRUE
#dilersek birden çok da şart yazabiliriz.

Vektor12>-2 & Vektor12!=0 & Vektor12<5 #-2'den büyük 5'ten küçük aynı zamanda da 0'a eşit olmayan değerler için "TRUE" üretilecek.
## [1] FALSE  TRUE FALSE  TRUE FALSE FALSE FALSE FALSE

Eğer belirli bir şarta uyan vektör elemanlarını elde etmek istersek vektör elemanlarını gösteren indeks değeri yerine şartımızı yazabiliriz. Ör: Vektor_ismi[Vektor_ismi>0] gibi…

Vektor13=c(2,3,7,-1,-2,5,-4)
Vektor13[Vektor13>=0]
## [1] 2 3 7 5
#dilersek sorgulama sonucu oluşan filtrelenmiş vektör içeriğini vektörün kendisine ya da yeni bir vektöre atayabiliriz.
Vektor14=Vektor13[Vektor13>0]
Vektor14
## [1] 2 3 7 5

Vektörlerde Pratik Bazı İşlemler
Vektörler arası dört işlem

Eleman sayısı eşit iki vektör arasında toplama, çıkarma, çarpma ya da bölme işlemi yapılabilir. Tıpkı iki sayısal değer arasında yapılıyormuş gibi bir sözdizimi kullanılır. Ör: Vektör1*Vektör2 gibi…

Vektor15=c(1,2,3,4,5,6)
Vektor16=c(10,20,30,40,50,60)

Vektor15+Vektor16
## [1] 11 22 33 44 55 66
Vektor15-Vektor16
## [1]  -9 -18 -27 -36 -45 -54
Vektor15*Vektor16
## [1]  10  40  90 160 250 360
Vektor15/Vektor16
## [1] 0.1 0.1 0.1 0.1 0.1 0.1

Dilersek bir vektrörü sabit bir değer ile de işleme sokabiliriz.

Vektor17=c(1,2,3,4,5,6)

Vektor17+5
## [1]  6  7  8  9 10 11
Vektor17-5
## [1] -4 -3 -2 -1  0  1
Vektor17*5
## [1]  5 10 15 20 25 30
Vektor15/5
## [1] 0.2 0.4 0.6 0.8 1.0 1.2

Vektör elemanlarının yok edilmesi

Vektor18=c(1,2,3,4,5,6)
Vektor18=NULL

Vektör elemanlarının toplanması

Vektor19=c(1,2,3,4,5,6)
Toplam=sum(Vektor19)
Toplam
## [1] 21

Vektör elemanları arasındaki en büyük ve en küçük değerin bulunması

Vektor20=c(1,2,3,4,5,6)
En_kucuk=min(Vektor20)
En_kucuk
## [1] 1
En_buyuk=max(Vektor20)
En_buyuk
## [1] 6

Vektör elemanlarının ortalaması ve medyanı

Vektor21=c(1,2,3,4,5,6)
Ortalama=mean(Vektor21)
Ortalama
## [1] 3.5
Medyan=median(Vektor21)
Medyan
## [1] 3.5

Vektör elemanlarının sıralanması

Vektor22=c(7,8,2,6,3,2,4,5,1)
Siralanmis=sort(Vektor22)
Siralanmis
## [1] 1 2 2 3 4 5 6 7 8
FONKSİYON TANIMLAMA

Programlama dillerinde sıklıkla kullanılan fonksiyon kavramı esasında matematikten aşina olduğumuz fonksiyondan farksızdır. Fonksiyonlar sonucunda birtakım işlemler gerçekleşir ve bu işlemler çoğu zaman fonksiyonu girdilerine bağlıdır… Fonksiyonlar sıklıkla gerçekleştirilen işlemlerin defalarca kodlanmasını ortadan kaldırmak için kullanılırlar. Halihazırda diğer programlama dillerinde olduğun gibi R’ın da gerek “Base” paketinde gerekse pek çok kütüphanesinde binlerce farklı fonksiyon mevcuttur. Varlığını bildiğimizi hazır fonksiyonlar aracılığı ile çözemediğimiz sorunları çözmek adına sıklıkla fonksiyonlar tanımlamamız gerekir.

Tanımlanan fonksiyonun olmazsa olmaz ilk parçası fonksiyonun ismidir. Dilden dile değişmekle birlikte yazım esnasında ilk belirtilen parametre fonksiyonun ismidir. Ardından şayet varsa girdi argümanları tanımlanır devamında da fonksiyon içerisinde gerçekleşecek işlemler kodlanır… R programlama dilinde de bu kalıp aşağıdaki gibidir.

Fonksiyon_Adi = function(girdi_1, girdi_2) #girdi sayısı birden çok olabileceği gibi sıfır da olabilir.
{
  
  #Gerçekleştirilecek işlemler bu blokta yazılır.
  #İşlemler bittiğinde bir çıktı üretilir.
  
}

Aşağıdaki üç fonksiyon örneği de benzer girdiler için aynı çıktıyı üretecektir. Fonksiyon isimlerini yazdıktan sonra atama operatörü olarak tıpkı değişken tanımlamada da olduğu gibi = ya da <- komutları kullanılabilir. Çalışma boyunca olduğu gibi bu bölümde de atama operatörü olarak = kullanılmıştır.

fonksiyon1=function(x,y)
{
  x+y
}

fonksiyon2=function(x,y)
{
  return(x+y)
}

fonksiyon3=function(x,y)
{
  toplam=x+y
  return(toplam)
}


fonksiyon1(2,3)
## [1] 5
fonksiyon2(2,3)
## [1] 5
fonksiyon3(2,3)
## [1] 5

Eğer fonksiyon sonucu ulaşılmak istenen çıktı bir değişkene atanacak ise ya da başka bir fonksiyonda girdi olarak kullanılacaksa fonksiyonun çıktısını “return()” komutu ile belirtmek daha sağlıklı olacaktır. Aksi takdirde fonksiyon içerisinde son gerçekleştirilen işlem fonksiyonun sonucu olacaktır. Bu durumu daha iyi anlamak için aşağıdaki örneğe bakabiliriz.

fonksiyon1=function(x,y)
{
  x+y
  x*y
}

fonksiyon2=function(x,y)
{
    
  return(x+y)
  x*y
  
}

fonksiyon3=function(x,y)
{
  toplam=x+y
  carpim=x*y
  return(toplam)
}

f1=fonksiyon1(2,3)
f2=fonksiyon2(2,3)
f3=fonksiyon3(2,3)

cat(f1,f2,f3)
## 6 5 5

Farkettiyseniz ilk fonksiyonda x ve y’nin toplamı return ile belirtilmediğinden fonksiyonun çıktısı fonksiyon içerisinde yazılan son satırdaki değere atanıyor, yani x*y değerine… Esasında bu durum birazda R programlama dilinin yapısından kaynaklanmaktadır. Birçok programlama dilinde fonksiyon tanımlarken çıktı değerinin belirtilmesi gerekmektedir. R’daki esnek yapı bazen ufak tefek sorunları beraberinde getirmekle birlikte genel itibariyle aşırı kullanıcı dostu bir sözdizimine sahiptir.


MATRİSLER

Matrisler iki boyutlu ve sayısal değerler alan dizilerdir. R programlama dilinde matrislerin nasıl yaratılacağına dair aşağıda çeşitli örneklere yer verilmiştir. Matrisler ile gerçekleştirilebilecek işlemler ise ilerleyen bölümlerde örneklendirilecektir.

#Örnek-1
Matris_1 = matrix(c(7,3,4,3,5,2))
Matris_1
##      [,1]
## [1,]    7
## [2,]    3
## [3,]    4
## [4,]    3
## [5,]    5
## [6,]    2
#Örnek-2, nrow parametresi ile satır sayısının 3 olduğu belirtiliyor
Matris_2 = matrix(c(7,3,4,3,5,2),nrow=3)
Matris_2
##      [,1] [,2]
## [1,]    7    3
## [2,]    3    5
## [3,]    4    2
#Örnek-2, ncol parametresi ile sütun sayısının 3 olduğu belirtiliyor
Matris_3 = matrix(c(7,3,4,3,5,2),ncol=3)
Matris_3
##      [,1] [,2] [,3]
## [1,]    7    4    5
## [2,]    3    3    2

nrow ve ncol komutları kullanılarak bir vektör matrise dönüştürüldüğünde vektör içerisindeki değerler ilk sutundan başlayarak matrise dağıtılır. Yani önce 1. sütun sonra 2. sütün şeklinde devam eder. Eğer bu işlemin sütun yerine satırlara göre gerçekleşmesini istersek byrow komutunu kullanmamız gerekir.

Matris_4 = matrix(c(7,3,4,3,5,2),nrow=3,byrow = T)
Matris_4
##      [,1] [,2]
## [1,]    7    3
## [2,]    4    3
## [3,]    5    2
Matris_5 = matrix(c(7,3,4,3,5,2),ncol=3,byrow = T)
Matris_5
##      [,1] [,2] [,3]
## [1,]    7    3    4
## [2,]    3    5    2
Matris_6 = matrix(1:20,nrow=4,ncol=5)
Matris_6
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    5    9   13   17
## [2,]    2    6   10   14   18
## [3,]    3    7   11   15   19
## [4,]    4    8   12   16   20

Matrislerin hem boyutları hemde uzunlukları (eleman sayıları) olur. Boyut öğrenmek için dim uzunluk öğrenmek için length kullanılır.

Matris_7 = matrix(c(1,2,3,7,3,4,3,5,2),ncol=3,byrow = T)
dim(Matris_7)
## [1] 3 3
length(Matris_7)
## [1] 9

R programlama dilinde rbind komutu satırları cbind komutu ise sütunları birleştirmek için kullanılır. Bu komutlar matris oluştururken de vektörleri birleştirmek amacıyla kullanılır.

Sutun_1 = c(1,2,3,4,5,6) 
Sutun_2 = c(7,8,9,10,11,12) 
Sutun_3 = c(13,14,15,16,17,18)
Matris_8 = as.matrix(cbind(Sutun_1,Sutun_2,Sutun_3))
Matris_8
##      Sutun_1 Sutun_2 Sutun_3
## [1,]       1       7      13
## [2,]       2       8      14
## [3,]       3       9      15
## [4,]       4      10      16
## [5,]       5      11      17
## [6,]       6      12      18
LİSTELER

Listeler farklı türden nesneleri içeren vektörlerdir. Atomik vektörlerden ayrılan en temel özellikleri de bu farklılıktır. Liste elemanlarından her birisi nümerik ya da karakter biçimli bir değişken olabilecekleri gibi bir vektör, matris veya veri çerçevesi de olabilirler. Listeler, R’deki en esnek veri yapılarıdır. İçerisindeki öğelerin sınıfı, uzunluğu veya yapısı ile ilgili herhangi bir kısıtlama yoktur. Bir liste altındaki öğelere aynı ismi verdiğinizde R size bunun için bir uyarı vermez. Listlerde satır ve sütun kavramı yoktur. Liste elemanlarının her biri birbirinden tamamen farklı yapı ve boyutta olabilirler. Öyleki bir liste elemanlarından birisi başka bir liste de olabilir. Listeler iç içe bir veri yapısı oluşturmak istediğimizde kullanabileceğimiz en mantıklı seçenektir. Aşağıda farklı şekillerde tanımlanmış listeler ve bu liste öğelelerine nasıl erişilebileceğine dair örnekler mevcuttur.

L1=list(1,2,3,4)
L1[1]
## [[1]]
## [1] 1
L1[[2]]
## [1] 2
L2_1=c(1,2,3,4,5,6,7,8,9,0)
L2_2=c("Kırmızı","Beyaz","Bordo","Mavi")
L2_3=c("Ayşe","Fatma","Hayriye")

L2=list(Numara=L2_1,Renk=L2_2,İsim=L2_3)


L2$Numara
##  [1] 1 2 3 4 5 6 7 8 9 0
L2$Renk
## [1] "Kırmızı" "Beyaz"   "Bordo"   "Mavi"
L2$İsim
## [1] "Ayşe"    "Fatma"   "Hayriye"
L3=list(Liste1=L1,Liste2=L2)

L3$Liste2$İsim
## [1] "Ayşe"    "Fatma"   "Hayriye"
L3[[2]]
## $Numara
##  [1] 1 2 3 4 5 6 7 8 9 0
## 
## $Renk
## [1] "Kırmızı" "Beyaz"   "Bordo"   "Mavi"   
## 
## $İsim
## [1] "Ayşe"    "Fatma"   "Hayriye"
L3$Liste2$Renk[2]
## [1] "Beyaz"
VERİ ÇERÇEVELERİ

Veri çerçeveleri listeler gibi çok boyutlu vektörlerdir fakat satır ve sütün denkliğini kontrol ederler. Her bir öğe eşit sayıda elemana sahip olmalıdır. Her bir öğe farklı veri tipinde olabilir. Çoğu kez dışarıdan çalışmamıza aktadırğımız veri setlerini veri çerçevesi tipinde değişkenlere aktarırız.

VC_1 = data.frame (
  İsimler = c("ali", "ayşe", "fatma", "mehmet"),
  Boy = c(177,165,158,190),
  Yaş = c(25,27,19,41)
)

Bir veri çerçevesindeki elemanlara erişmek için köşeli parantezler arasında satır ve sütun indisleri kullanılır. Ör: VC[satır no, sütun no]

VC_1[1,] #1. satırdaki değerler
VC_1[1] #1. sütun
VC_1[,1] #1. sütündaki değerler
## [1] "ali"    "ayşe"   "fatma"  "mehmet"
VC_1[[1]] #1. sütündaki değerler
## [1] "ali"    "ayşe"   "fatma"  "mehmet"
VC_1[["Boy"]] #sütun indisi yerine sütun adı da kullanılabilir.
## [1] 177 165 158 190
VC_1[1,3] #1. satır 3. sütündaki değer.
## [1] 25
VC_1[2,2] #2. satır 2. sütündaki değer.
## [1] 165
VC_1[c(2,3),] # 2. ve 3. satırlar.
VC_1[,c(2,3)] # 2. ve 3. sütunlar.

Bir veri çerçevesinin satır ve sütun isimlerini öğrenmek için attributes() fonksiyonu kullanılır.

attributes(VC_1) #satır isimlerini ya da numaralarını verir.
## $names
## [1] "İsimler" "Boy"     "Yaş"    
## 
## $class
## [1] "data.frame"
## 
## $row.names
## [1] 1 2 3 4
attributes(VC_1)$row.names #satır isimlerini ya da numaralarını verir.
## [1] 1 2 3 4
attributes(VC_1)$names #sütun isimlerini (öznitelikleri) verir.
## [1] "İsimler" "Boy"     "Yaş"

Bir veri çerçevesiniin boyutlartını öğrenmek için dim, nrow ve ncol fonksiyonları kullanılır.

    dim(VC_1) #boyutu verir. Satır X Sütun şeklinde...
## [1] 4 3
    nrow(VC_1) #satır sayısını verir.
## [1] 4
    ncol(VC_1) #sütun sayısını verir.
## [1] 3

Bir veri çerçevesinin satır ve sütün isimlerini değiştirmek için colnames ve rownames fonksiyonları kullanılır.

  colnames(VC_1) = c("Adı", "Boyu", "Yaşı")  #sütun isimleri
  attributes(VC_1)$names
## [1] "Adı"  "Boyu" "Yaşı"
  rownames(VC_1) = c("1. aday","2. aday", "3. aday", "4. aday") #satır isimleri
  attributes(VC_1)
## $names
## [1] "Adı"  "Boyu" "Yaşı"
## 
## $class
## [1] "data.frame"
## 
## $row.names
## [1] "1. aday" "2. aday" "3. aday" "4. aday"

Satır isimlerini değiştirme işlemini otomatik olarak da yaptırabiliriz. Aşağıdaki basit kod ile veri çerçevesindeki satır sayısı kadar satır ismi oluşturabiliriz.

  rownames(VC_1) = paste(seq(1,nrow(VC_1)),". Aday", sep = "")

Bir veri çerçevesini görüntülemek için show fonksiyonu kullanılır.

show(VC_1)
##            Adı Boyu Yaşı
## 1. Aday    ali  177   25
## 2. Aday   ayşe  165   27
## 3. Aday  fatma  158   19
## 4. Aday mehmet  190   41

Bir veri çerçevesine sütun eklemek için cbind fonksiyonu kullanılır.

  Kilo = c(75,65,57,80)
  VC_1=cbind(VC_1,Kilo)
  VC_1

Bir veri çerçevesinde araya sütun eklemek istersek de aşağıdaki şekilde yapabiliriz.

  #araya sütun ekeleme
  Soyad = c("yilmaz", "türkmen", "aydin", "keskin")
  VC_1=data.frame(VC_1[,1:1],Soyad,VC_1[,2:4])
  colnames(VC_1) = c("Ad", "Soyad", "Boy", "Yaş", "Kilo") 
  VC_1

Bir veri çerçevesine satır eklemek için rbind fonksiyonu kullanılır.

  yeni_satir=c("ahmet", "aksoy", "184","29","79")
  VC_1=rbind(VC_1,yeni_satir) 
  rownames(VC_1) = paste(seq(1,nrow(VC_1)),". Aday", sep = "") #satır isimleri
  VC_1

Veri çerçevelerinin birleştirilmesi için merge fonksiyonu kullanılır. Bu işlem yapılırken birleştirilen veri çerçeveleri arasında ismi ve içeriği bakımından ortak bir ya da birden çok sütun bulunmaldır. Aksi takdirde birleştirme işlemi sonucunda çalışma mantığı gereği satır sayısı artacaktır.

VC_2 = data.frame (
  isim = c("ali", "ayşe", "fatma", "mehmet"), #ortak isim ve içerikli sütun
  boy = c(177,165,158,190),
  yas = c(25,27,19,41)
)

VC_3 = data.frame (
  isim = c("ali", "ayşe", "fatma", "mehmet"), #ortak isim ve içerikli sütun
  memleket = c("Trabzon","Uşak","Konya","Ankara"),
  meslek = c("Öğretmen","Doktor","Öğrenci","Müzisyen")
)

Birlestirilmis_VC_1 =  merge(VC_2,VC_3)
Birlestirilmis_VC_1

Aşağıdaki örnekte ortak isim ve içerikli herhangi bir sütun bulunmadığından birleştirme işlemi sonucu daha fazla satır sayısına sahip yeni bir veri çerçevesi oluşur. Oluşan yeni veri çerçevesinin satır sayısı birleşen veeri çerçevelerinin satır sayılarının çarpımı kadardır.

VC_4 = data.frame (
  isim = c("ali", "ayşe", "fatma", "mehmet"),
  boy = c(177,165,158,190),
  yas = c(25,27,19,41)
)

VC_5 = data.frame (

  memleket = c("Trabzon","Uşak","Konya","Ankara"),
  meslek = c("Öğretmen","Doktor","Öğrenci","Müzisyen")
)

Birlestirilmis_VC_2 =  merge(VC_4,VC_5)
Birlestirilmis_VC_2

Veri çerçevelerinde satır ve sütun silme işlemi aşağıdaki gibi gerçekleştirilir.

Silinecek_VC_1 = VC_1 #VC_1 isimli veri çerçevesinin içeriğini Silinecek_VC_1 isimli veri çerçevesine aktardık.

#veri çerçevesinin ilk hali
Silinecek_VC_1
#Sütun silme işlemi için aşağıdaki yöntemleri kullanılabilir.
Silinecek_VC_1[,-3] #Yöntem 1, 3.sütun siliniyor.
Silinecek_VC_1[,2] = NULL #Yöntem 2, 2. sütun siliniyor.
Silinecek_VC_1
# birden fazla sütunu aynı anda silmek için aşağidaki kod parçacığı kullanilabilir...
Silinecek_VC_1[,-c(2,3)] # 2. ve 3. sütun siliniyor.
#Veri çerçevesindeki bir sütunu adini kullanarak da silebiliriz.
Silinecek_VC_2 = VC_1 
Silinecek_VC_2$isim = NULL

#veri çerçevesinin ilk hali
Silinecek_VC_2
#satır silme işleminde de sütunlarda olduðu gibi index kullanılarak silme işlemi gerçekleştirilebilir.
Silinecek_VC_2[-2,] #2. satır siliniyor.
DİZİLER

Diziler vektörleri ve matrisleri kapsar niteliktedir. Tek boyutlu diziler vektör, iki boyutlu diziler matris olarak adlandırılır. 3 veya daha fazla boyutlu olanları ise Dizi olarak adlandırılır. Örneğin 3x4x5 botutlarında 60 elemanlı bir dizi düşünelim. Eğer elemanların değerleri baştan belli ise bunları bir vektöre aktarıp ardından da dizi yapısına dönüştebiliriz. Tek yapmamız gereken array komutu ile değişken tipinin dizi olduğunu belirtip dim komutu ile de dizinin boyutunu tanımlamaktır.

degerler=seq(1,60)
Dizi_1=array(degerler,dim=c(3,4,5)) #1. boyut indisi x 2. boyut indisi x 3. boyut indisi
Dizi_1
## , , 1
## 
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4]
## [1,]   13   16   19   22
## [2,]   14   17   20   23
## [3,]   15   18   21   24
## 
## , , 3
## 
##      [,1] [,2] [,3] [,4]
## [1,]   25   28   31   34
## [2,]   26   29   32   35
## [3,]   27   30   33   36
## 
## , , 4
## 
##      [,1] [,2] [,3] [,4]
## [1,]   37   40   43   46
## [2,]   38   41   44   47
## [3,]   39   42   45   48
## 
## , , 5
## 
##      [,1] [,2] [,3] [,4]
## [1,]   49   52   55   58
## [2,]   50   53   56   59
## [3,]   51   54   57   60

Dilersek dimnames komutu ile de boyutların isimlerini tanımlayabiliriz.

Boyut_1_isimleri = c ("Boyut_1_1","Boyut_1_2","Boyut_1_3")
Boyut_2_isimleri = c ("Boyut_2_1","Boyut_2_2","Boyut_2_3","Boyut_2_4")
Boyut_3_isimleri = c ("Boyut_3_1","Boyut_3_2","Boyut_3_3","Boyut_3_4","Boyut_3_5")
Dizi_1=array(degerler,dim=c(3,4,5),dimnames = list(Boyut_1_isimleri,Boyut_2_isimleri,Boyut_3_isimleri))
Dizi_1
## , , Boyut_3_1
## 
##           Boyut_2_1 Boyut_2_2 Boyut_2_3 Boyut_2_4
## Boyut_1_1         1         4         7        10
## Boyut_1_2         2         5         8        11
## Boyut_1_3         3         6         9        12
## 
## , , Boyut_3_2
## 
##           Boyut_2_1 Boyut_2_2 Boyut_2_3 Boyut_2_4
## Boyut_1_1        13        16        19        22
## Boyut_1_2        14        17        20        23
## Boyut_1_3        15        18        21        24
## 
## , , Boyut_3_3
## 
##           Boyut_2_1 Boyut_2_2 Boyut_2_3 Boyut_2_4
## Boyut_1_1        25        28        31        34
## Boyut_1_2        26        29        32        35
## Boyut_1_3        27        30        33        36
## 
## , , Boyut_3_4
## 
##           Boyut_2_1 Boyut_2_2 Boyut_2_3 Boyut_2_4
## Boyut_1_1        37        40        43        46
## Boyut_1_2        38        41        44        47
## Boyut_1_3        39        42        45        48
## 
## , , Boyut_3_5
## 
##           Boyut_2_1 Boyut_2_2 Boyut_2_3 Boyut_2_4
## Boyut_1_1        49        52        55        58
## Boyut_1_2        50        53        56        59
## Boyut_1_3        51        54        57        60

Dört boyutlu bir dizi tanımlamak istersek sadece dim komutu ile tanımladığımız boyut içeriğine 4. bir indis eklememiz gerekir.

degerler2=seq(1,120)
Dizi_2=array(degerler,dim=c(2,3,4,5)) #1. boyut indisi x 2. boyut indisi x 3. boyut indisi x 4. boyut indisi
Dizi_2
## , , 1, 1
## 
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
## 
## , , 2, 1
## 
##      [,1] [,2] [,3]
## [1,]    7    9   11
## [2,]    8   10   12
## 
## , , 3, 1
## 
##      [,1] [,2] [,3]
## [1,]   13   15   17
## [2,]   14   16   18
## 
## , , 4, 1
## 
##      [,1] [,2] [,3]
## [1,]   19   21   23
## [2,]   20   22   24
## 
## , , 1, 2
## 
##      [,1] [,2] [,3]
## [1,]   25   27   29
## [2,]   26   28   30
## 
## , , 2, 2
## 
##      [,1] [,2] [,3]
## [1,]   31   33   35
## [2,]   32   34   36
## 
## , , 3, 2
## 
##      [,1] [,2] [,3]
## [1,]   37   39   41
## [2,]   38   40   42
## 
## , , 4, 2
## 
##      [,1] [,2] [,3]
## [1,]   43   45   47
## [2,]   44   46   48
## 
## , , 1, 3
## 
##      [,1] [,2] [,3]
## [1,]   49   51   53
## [2,]   50   52   54
## 
## , , 2, 3
## 
##      [,1] [,2] [,3]
## [1,]   55   57   59
## [2,]   56   58   60
## 
## , , 3, 3
## 
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
## 
## , , 4, 3
## 
##      [,1] [,2] [,3]
## [1,]    7    9   11
## [2,]    8   10   12
## 
## , , 1, 4
## 
##      [,1] [,2] [,3]
## [1,]   13   15   17
## [2,]   14   16   18
## 
## , , 2, 4
## 
##      [,1] [,2] [,3]
## [1,]   19   21   23
## [2,]   20   22   24
## 
## , , 3, 4
## 
##      [,1] [,2] [,3]
## [1,]   25   27   29
## [2,]   26   28   30
## 
## , , 4, 4
## 
##      [,1] [,2] [,3]
## [1,]   31   33   35
## [2,]   32   34   36
## 
## , , 1, 5
## 
##      [,1] [,2] [,3]
## [1,]   37   39   41
## [2,]   38   40   42
## 
## , , 2, 5
## 
##      [,1] [,2] [,3]
## [1,]   43   45   47
## [2,]   44   46   48
## 
## , , 3, 5
## 
##      [,1] [,2] [,3]
## [1,]   49   51   53
## [2,]   50   52   54
## 
## , , 4, 5
## 
##      [,1] [,2] [,3]
## [1,]   55   57   59
## [2,]   56   58   60

Dizi elemanlarına erişmek için tıpkı veri çerçevelerinde olduğu gibi indisler kullanırız fakat bu indis sayısı 2’den fazladır.

Dizi_1[2,3,4] #Dizi_1 isimli dizi tipli değişkenin (2,3,4) indizli elemanının değeri
## [1] 44
Dizi_2[2,3,1,4] #Dizi_1 isimli dizi tipli değişkenin (2,3,1,4) indizli elemanının değeri
## [1] 18

Veri çerçevelerindeki kullanılan diğer yöntemleri dizilerdeki herhangi bir elemana ulaşmak için de kullanabiliriz. Aşağıda çeşitli örnekler yer almaktadır.

Dizi_1[, , 1]
##           Boyut_2_1 Boyut_2_2 Boyut_2_3 Boyut_2_4
## Boyut_1_1         1         4         7        10
## Boyut_1_2         2         5         8        11
## Boyut_1_3         3         6         9        12
Dizi_1[2, ,]
##           Boyut_3_1 Boyut_3_2 Boyut_3_3 Boyut_3_4 Boyut_3_5
## Boyut_2_1         2        14        26        38        50
## Boyut_2_2         5        17        29        41        53
## Boyut_2_3         8        20        32        44        56
## Boyut_2_4        11        23        35        47        59
Dizi_2[, , 3, 1]
##      [,1] [,2] [,3]
## [1,]   13   15   17
## [2,]   14   16   18


DOSYA İŞLEMLERİ

Dizin Ayarlama İşlemleri Hangi R IDE’sini kullanırsak kullanalım üzerinde çalıştığımız dosyalar için tanımlı olan geçerli bir dizin vardır. Bu tanımlamayı biz yapmadıysak varsayılan olarak tanımlanmış dizini kullanıyoruz demektir.

Peki bu dizin neden önemlidir? Çünkü içeri ve dışarı aktardığımız dosyalar biz harici bir yol belirtmediğimiz sürece bu dizinde aranız ya da bu dizine kaydolur. Yani “abc.txt” diye bir dosya belirttiğimizde tam yol yazmadığımız sürece bu dosya aktif çalışma dizininde aranır ya da “abc.txt” isimli bir dosyaya kaydet dediğimizde yine yol belirtmediğimiz sürece bu dosya aktif çalışma dizinine kaydolur.

Peki varsayılan dizini nasıl görebiliriz ya da değiştirebiliriz? Bunun için iki farklı komuttan yararlanacağız. Birincisi aktif çalışma dizini görmek, ikincisi ise bu dizini değiştirmek için kullanılır.

Getwd() komutu bize o an için aktif olan çalışma dizinini gösterir.

setwd() komutu ise aktif çalışma dizinini değiştirmek için kullanılır. Tek yapmamız gereken çift tırnak içerisinde belirlemek istediğimiz dizinin tam yolunu yazmaktır.

getwd() # Dizin bilgisi almak için kullanılır...
## [1] "E:/Drive'ım/Selçuk Üniversitesi/2021-2022/Bahar Yarıyılı/Dersler/Programlama/Ders Uygulamaları"
setwd("C:/R_Ders_Notları/") # Aktif dizini değiştirmek için kullanılır.
dir() #Aktif dizindeki dosyaları listeler...
## [1] "deneme.txt"
file.info("Çalışma1.R") #Belirtilen dosyaya ait bilgileri verir.

Dosyaya Yazma İşlemleri Tüm programlama dillerinde olduğu gibi R programlama dilinde de çeşitli amaçlar ile dosyalara veri yazdırma işlemi gerçekleştirilebilir. Dosya içerisine yazılacak ya da bir başka deyişle dosyalara kaydedilecek olan verinin içeriği değişkenlik gösterebilir. Kimi zaman konsol çıktısını doğrudan bir dosyaya kaydedebileceğimiz gibi kimi zamanda belli hesaplamalar sonucunda elde edilmiş bazı değerleri yada oluşturulmuş veri setlerini dosyalara yazabiliriz. Dosya türleri de değişkenlik gösterebilir. R programlama dilinin base paketinde sıkça kullanılan “.txt” ve “.csv” gibi formatlara doğrudan veri yazmamızı sağlayan komutlar mevcut olup yeri geldiği zaman farklı paketlerden de yararlanarak dilediğimiz pek çok türdeki dosyaya veri yazabiliriz.


Konsol Verilerini Dosyaya Yazmak Yazdığımız komutların çıktıları konsolda görünmektedir. Dilersek bu çıktıları belirleyeceğimzi konumdaki bir dosyaya yazdırabiliriz. Bu işlem için sink(“dosyaadi.uzantisi”) komutunu kullanırız. Parantezler arasına konsol çıktılarını yazdıracağımız dosyanın adını bulunduğu dizin ve uzantısı ile birlikte yazarız. Çıktıları genelde .txt formatındaki dosyalara yazdırırız. sink() komutu ile bir dosya

sink("deneme.txt") #Konsola yazılacak olan çıktıları belirtilen dosya içerisine aktarır.
#ya da

sink("C:/R_Ders_Notları/deneme.txt")

sink(“dosyaadi.uzantisi”) komutu içerisinde bir dosya belirtilirse çıktılar o dosyaya yazılmaya başlar ve tekrar boş olarak sink() komutu yazılıncaya kadar bu şekilde devam eder. Şayet çıktıların tekrar konsolda belirmesini istersek sink() komutunu yazarız.

sink() #çıktılar artık konsola yazılacak.

BURADAN AŞAĞISI GÜNCELLENMEYE DEVAM EDİYOR