Advanced R by Hadley Wickham: Data Structures

1.Veri Yapıları

1.1. Giriş

Giriş Notu: Bu kısım Advanced R kitabınının ilk baskısında “Veri Yapıları” ; ikinci baskısında ise “Vektörler” olarak geçen bölümlere ilişkin alınan notları içermektedir.

R’ın temel veri yapıları, boyutlarına(1d, 2d veya nd) ve homojen olmalarına (tüm veriler aynı türden olmalıdır) veya heterojen olmalarına (veriler farklı türlerde olabilir) göre düzenlenebilir. Bu sınıflama, veri analizinde en sık kullanılan beş veri yapısını ortaya çıkarır:

	Homojen	Heterojen
1 boyutlu	Atomik Vektör	Liste
2 boyutlu	Matris	Data Frame
n boyutlu	Array(Dizi)

Hemen hemen tüm diğer nesneler bu temeller üzerine inşa edilmiştir. R’nin 0 boyutlu veya skaler tiplere sahip olmadığına dikkat edilmelidir. Skaler olduğu düşünülen sayılar veya stringler aslında bir birim uzunluktaki vektörlerdir.

• Bir nesne verildiğinde, hangi veri yapılarından oluştuğunu anlamanın en iyi yolu str() kullanmaktır.

  ---

1.2. Vektörler

R’daki temel veri yapısı vektördür. Vektörlerin iki çeşidi vardır: atomik vektörler ve listeler. İçerebildikleri veri türleri açısından farklılık gösterirler. Atomik vektörler için tüm verilerin aynı türde olma şartı var iken; listeler farklı türde veriler barındırabilmektedir.

Not: is.vector(), bir nesnenin vektör olup olmadığını test etmez. Bunun yerine, yalnızca nesne, adlardan başka özniteliği olmayan bir vektörse TRUE değerini verir. is.atomic(x) || is.list(x) bir nesnenin gerçekten bir vektör olup olmadığını test etmek için kullanılabilir.

---

1.2.1. Atomik Vektörler

Dört temel atomik vektör türü vardır: mantıksal (logical), tamsayı (integer), ondalık (double) ve karakter (character). Tamsayı ve ondalık vektörlerin ikisi de sayısal (numeric) vektörler olarak bilinir. Bunlar dışında sık kullanılmayan iki tür daha vardır: karmaşık (complex) ve ham (raw).

Atomik vektörler genellikle c() fonksiyonu ile (combine’nın kısaltmasıdır) ile oluşturulur.

lgl_var <- c(TRUE, FALSE)
int_var <- c(1L, 6L, 10L)
dbl_var <- c(1, 2.5, 4.5)
chr_var <- c("these are", "some strings")

Bir vektörün türünü typeof() ile ve uzunluğunu length() ile belirleyebiliriz.

---

Bir atomik vektörün tüm elemanları aynı tip olmalıdır, bu yüzden farklı türleri birleştirmeye çalıştığımızda en esnek tipe zorlanacaklartır. En az esnekten en çok esneğe doğru türler şunlardır: mantıksal, tamsayı, ondalık ve karakter.

Örneğin, bir karakter ve bir tamsayıyı birleştirmek, bir karakter verir:

str(c("a", 1))

 chr [1:2] "a" "1"

---

Rutin olarak korunan iki nitelik vardır:

names: her elemana bir isim veren bir karakter vektörü.

dim: boyutların kısaltması, vektörleri matrislere veya dizilere dönüştürmek için kullanılan bir tamsayı vektörü.

İsimler

Bir vektör üç şekilde adlandırılabilir:

# When creating it: 
x <- c(a = 1, b = 2, c = 3)

# By assigning a character vector to names()
x <- 1:3
names(x) <- c("a", "b", "c")

# Inline, with setNames():
x <- setNames(1:3, c("a", "b", "c"))

Boyutlar

Bir vektöre dim özelliği eklemek, vektörün 2 boyutlu bir matris veya çok boyutlu bir dizi gibi davranmasını sağlar. Matrisler ve diziler, programlama araçları değil, öncelikle matematiksel ve istatistiksel araçlardır.

matrix() ve array() ile veya dim() atama formunu kullanarak matrisler ve diziler oluşturabilirsiniz:

# Two scalar arguments specify row and column sizes
x <- matrix(1:6, nrow = 2, ncol = 3)
x

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

# One vector argument to describe all dimensions
y <- array(1:12, c(2, 3, 2))
y

, , 1

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

, , 2

     [,1] [,2] [,3]
[1,]    7    9   11
[2,]    8   10   12

# You can also modify an object in place by setting dim()
z <- 1:6
dim(z) <- c(3, 2)
z

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

Vektörlerle çalışan fonksiyonların çoğunun matrisler ve diziler için de genellemeleri vardır:

Vektör	Matris	Array
names()	rownames(), colnames()	dimnames()
length()	nrow(), ncol()	dim()
c()	rbind(), cbind()	abind::abind()
—	t()	aperm()
is.null(dim(x))	is.matrix()	is.array()

S3 Atomik Vektörler

En önemli vektör özniteliklerinden biri, S3 nesne sisteminin temelini oluşturan class’tır . Bir sınıf özniteliğine sahip olmak, bir nesneyi bir S3 nesnesine dönüştürür; bu, generic bir fonksiyona geçirildiğinde normal bir vektörden farklı davranacağı anlamına gelir. Her S3 nesnesi bir temel türün üzerine inşa edilmiştir ve genellikle ek bilgileri diğer niteliklerde depolar.

Bu bölümde, R tabanında kullanılan dört önemli S3 vektörü tartışılmıştır:

• Değerlerin faktör vektörlerinde kaydedilen sabit bir seviyeden geldiği kategorik veriler.

• Tarih vektörlerinde kaydedilen tarihler (gün vb.)

• POSIXct vektörlerinde depolanan tarih-saatler (saniye veya saniye altı ).

• difftime vektörlerinde depolanan süreler.

  

---

1.2.2. Listeler

Listeler, atomik vektörlerinden farklıdır çünkü içerikleri listeler de dahil olmak üzere herhangi bir türden olabilir. Listeler c() yerine list() kullanarak oluşturulur:

x <- list(1:3, "a", c(TRUE, FALSE, TRUE), c(2.3, 5.9))
str(x)

List of 4
 $ : int [1:3] 1 2 3
 $ : chr "a"
 $ : logi [1:3] TRUE FALSE TRUE
 $ : num [1:2] 2.3 5.9

Listeler bazen özyinelemeli vektörler olarak adlandırılır, çünkü bir liste başka listeler içerebilir. Bu onları temel olarak atomik vektörlerden farklı kılar.

x <- list(list(list(list())))
str(x)

List of 1
 $ :List of 1
  ..$ :List of 1
  .. ..$ : list()

is.recursive(x)

[1] TRUE

1.3. Faktörler

Faktör, yalnızca önceden tanımlanmış değerleri içerebilen bir vektördür. Kategorik verileri depolamak için kullanılır. Faktörler, iki özelliğe sahip bir tamsayı vektörünün üzerine inşa edilir: normal tamsayı vektörlerinden farklı davranmasını sağlayan bir class, ve izin verilen değerler kümesini tanımlayan levels.

x <- list(list(list(list())))
str(x)

List of 1
 $ :List of 1
  ..$ :List of 1
  .. ..$ : list()

is.recursive(x)

[1] TRUE

Faktörler, tümü belirli bir veri kümesinde mevcut olmayan olası değerler kümesi bilindiği durumlarda yararlıdır. Bir karakter vektörünün aksine, bir faktör tablolaştırıldığında, gözlemlenmemiş olanlar dahil tüm kategorilerin sayıları alınır:

sex_char <- c("m", "m", "m")
sex_factor <- factor(sex_char, levels = c("m", "f"))

table(sex_char)

sex_char
m 
3 

table(sex_factor)

sex_factor
m f 
3 0 

Sıralı(ordered) faktörler, faktörlerin küçük bir değişikliğe uğramış versiyonudur. Genel olarak, normal faktörler gibi davranırlar, ancak seviyelerin sırası anlamlıdır (düşük, orta, yüksek) (bazı modelleme ve görselleştirme işlevleri tarafından otomatik olarak kullanılan bir özelliktir).

grade <- ordered(c("b", "b", "a", "c"), levels = c("c", "b", "a"))
grade

[1] b b a c
Levels: c < b < a

Temel R’da faktörlerle çok sık karşılaşılır çünkü birçok temel R fonksiyonu (read.csv() ve data.frame() gibi) karakter vektörleri otomatik olarak faktörlere dönüştürür. Bu, optimal bir durum değildir, çünkü bu fonksiyonların tüm olası düzeyler kümesini veya bunların doğru sırasını bilmelerinin imkanı yoktur (düzeyler, verilerin değil, teorinin veya deneysel tasarımın bir özelliğidir). Bunu önlemek için stringsAsFactors = FALSE argümanı kullanılır ve ardından “teorik” veriler hakkındaki bilgiler kullanılarak karakter vektörler manuel olarak faktörlere dönüştürülür.

Faktörler karakter vektörleri gibi görünse de (ve genellikle böyle davranırlar), tam sayıların üzerine inşa edilirler. Bu yüzden onlara string gibi davranırken dikkatli olunmalıdır. Bazı string yöntemleri (gsub() ve grepl() gibi) faktörleri otomatik olarak stringe zorlar ve bazı fonksiyonların (nchar() gibi) hata vermesine neden olur. Yine de diğerleri (c() gibi) temel tamsayı değerlerini kullanır. Bu nedenle, string benzeri bir türe ihtiyaç olduğu durumlarda, faktörleri karakter vektörlerine dönüştürmek genellikle en iyisidir.

1.4. Matrisler ve Arrays

Bir atomik vektöre dim özelliği eklemek, çok boyutlu bir array gibi davranmasını sağlar. Dizinin (array) özel bir durumu, iki boyutu olan matristir. Matrisler, yaygın olarak istatistik matematiksel mekanizmasının bir parçası olarak kullanılır. Diziler çok daha nadirdir.

Matrisler ve diziler matrix() ve array() ile veya dim() atama biçimi kullanılarak oluşturulur:

######### Bu kısım boyutlar başlığı altında anlatıldı. #########

length() ve names() yüksek boyutlu genellemelere sahiptir:

• length(), matrisler için nrow() ve ncol()’a ve diziler için dim()’e genelleme yapar.

• names(), matrisler için rownames() ve colnames()’e ve diziler için karakter vektörlerinin bir listesi olan dimnames()’e genelleme yapar.

```r
a <- matrix(1:6, ncol = 3, nrow = 2)
length(a)
```

```
[1] 6
```

```r
nrow(a)
```

```
[1] 2
```

```r
ncol(a)
```

```
[1] 3
```

```r
rownames(a) <- c("A", "B")
colnames(a) <- c("a", "b", "c")
a
```

```
  a b c
A 1 3 5
B 2 4 6
```

```r
b <- array(1:12, c(2, 3, 2))
length(b)
```

```
[1] 12
```

```r
dim(b)
```

```
[1] 2 3 2
```

```r
dimnames(b) <- list(c("one", "two"), c("a", "b", "c"), c("A", "B"))
b
```

```
, , A

    a b c
one 1 3 5
two 2 4 6

, , B

    a  b  c
one 7  9 11
two 8 10 12
```

c(), matrisler için cbind() ve rbind()’e ve diziler için abind()’e (abindpaketi tarafından sağlanır) genelleştirir. Bir matrisi t(); ile transpoze edebilirsiniz; diziler için genelleştirilmiş eşdeğer aperm()’dir.

Bir nesnenin matris mi yoksa dizi mi olduğunu is.matrix() ve is.array()kullanarak veya dim() uzunluğuna bakarak test edebilirsiniz. as.matrix()ve as.array(), mevcut bir vektörü bir matris veya diziye dönüştürür.

str(1:3)                   # 1d vector

 int [1:3] 1 2 3

str(matrix(1:3, ncol = 1)) # column vector

 int [1:3, 1] 1 2 3

str(matrix(1:3, nrow = 1)) # row vector

 int [1, 1:3] 1 2 3

str(array(1:3, 3))         # "array" vector

 int [1:3(1d)] 1 2 3

1.5. Data Frames

Data frame , R’de veri depolamanın en yaygın yoludur ve sistematik olarak kullanılırsa veri analizini kolaylaştırır. Gerçekte bir data frame, eşit uzunluktaki vektörlerin bir listesidir. Bu onu 2 boyutlu bir yapı haline getirir, böylece hem matrisin hem de listenin özelliklerini paylaşır. Bu, bir data frame’in names(), colnames() ve rownames()’e sahip olduğu anlamına gelir, ancak names() ve colnames() aynı şeydir. Bir data frame’in length()’i, aslında içerdiği listenin uzunluğudur ve dolayısıyla ncol() ile aynıdır; nrow() ise satır sayısını verir.

• 1d yapısı (bir liste gibi davranır) veya 2d yapısı (matris gibi davranır) gibi bir data frame alt kümelere ayrılabilir.

Girdi olarak adlandırılmış vektörleri alan data.frame() kullanılarak bir veri seti oluşturulur:

df <- data.frame(x = 1:3, y = c("a", "b", "c"))
str(df)

'data.frame':   3 obs. of  2 variables:
 $ x: int  1 2 3
 $ y: chr  "a" "b" "c"

as.data.frame() ile bir nesne data frame dönüşürülebilir:

• Bir vektör, tek sütunlu bir data frame oluşturacaktır.

• Bir liste, her öğe için bir sütun oluşturur; hepsi aynı uzunlukta değilse bu bir hatadır.

• Bir matris, matrisle aynı sayıda sütun ve satır içeren bir data frame oluşturur.

1.5.1. Data Frame Birleştirme

Sütun bazında birleştirirken, satır sayısı eşleşmelidir, ancak satır adları yok sayılır. Satır bazında birleştirirken, sütunların hem sayısı hem de adları eşleşmelidir. Aynı sütunlara sahip olmayan data frameleri birleştirmek için plyr::rbind.fill() kullanın.

Vektörleri cbind() birleştirerek bir data frame oluşturmaya çalışmak yaygın bir hatadır. Bu çalışmaz çünkü argümanlardan biri zaten bir data frame olmadıkça cbind() bir matris oluşturacaktır. Bunun yerine doğrudan data.frame()kullanın:

bad <- data.frame(cbind(a = 1:2, b = c("a", "b")))
str(bad)

'data.frame':   2 obs. of  2 variables:
 $ a: chr  "1" "2"
 $ b: chr  "a" "b"

good <- data.frame(a = 1:2, b = c("a", "b"),
  stringsAsFactors = FALSE)
str(good)

'data.frame':   2 obs. of  2 variables:
 $ a: int  1 2
 $ b: chr  "a" "b"

1.5.2. Özel sütunlar

Bir data frame bir vektör listesi olduğundan, bir data frame’in liste olan bir sütuna sahip olması mümkündür:

df <- data.frame(x = 1:3)
df$y <- list(1:2, 1:3, 1:4)
df

Ancak, data.frame() öğesine bir liste verildiğinde, listenin her bir öğesini kendi sütununa koymaya çalışır, bu nedenle bu başarısız olur:

data.frame(x = 1:3, y = list(1:2, 1:3, 1:4))

Error in (function (..., row.names = NULL, check.rows = FALSE, check.names = TRUE,  : 
  arguments imply differing number of rows: 2, 3, 4

Bir geçici çözüm, I() öğesini kullanmaktır; bu, data.frame() öğesinin listeyi tek bir birim olarak ele almasına neden olur:

I()girdisine AsIs sınıfını ekler, ancak bu genellikle güvenli bir şekilde yoksayılabilir.

Benzer şekilde, satır sayısı data frame ile eşleştiği sürece, matris veya dizi olan bir data frame’in bir sütununa sahip olmak da mümkündür:

Liste ve dizi sütunları dikkatli kullanılmalıdır: data frame ile çalışan birçok fonksiyon, tüm sütunların atomik vektörler olduğunu varsayar.