2.1 R語言

R提供了一種完善的編程語言。類似計算機的高級語言，R用戶只需要熟悉其命令、語句及簡單的語法規則，就可以做數據管理和分析處理工作。因此，掌握R編程技術是學習R的關鍵環節。在R中，把大部分常用的復雜數據計算的算法作為標準函數調用，用戶僅需要指出函數名及其必要的參數即可。這一特點使得R編程十分簡單。

R是一種解釋性語言，輸入后可直接給出結果。R功能靠函數實現。函數形式如下：

函數(輸入數據，參數=)

如果沒有指定，則參數以默認值為準。

例如：平均值mean(x, trim=0, na.rm=FALSE, ...)，線性模型lm(y~x, data=test)。

每一個函數執行特定的功能，后面緊跟括號，例如：平均值mean()、求和sum()、繪圖plot()、排序sort()。

除了基本的運算之外，R的函數又分為“高級”和“低級”函數，高級函數可調用低級函數，這里的“高級”函數習慣上稱為泛型函數。如plot()就是泛型函數，可以根據數據的類型，調用底層的函數，應用相應的方法繪制相應的圖形。這就是面向對象編程的思想。

2.1.1 數據集的概念

創建含有研究信息的數據集，這是任何數據分析的第一步。在R中，這個任務包括以下兩步。

·選擇一種數據結構來存儲數據。

·將數據輸入或導入這個數據結構中。

數據集通常是由數據構成的一個矩形數組，行表示觀測，列表示變量。不同的行業對于數據集的行和列叫法不同，包括觀測和變量、記錄和字段、示例和屬性。

R可以處理的數據類型包括數值型、字符型、邏輯型（TRUE/FALSE）、復數型（虛數）和因子型，實例如下。

·數值型：如100，0，?4.335。

·字符型：如“China”。

·邏輯型：如TRUE，FALSE。

·復數型：如2+3i。

·因子型：表示不同類別。因子是名義型變量或有序型變量，它們在R中被特殊地存儲和處理。

R中有許多用于存儲數據的結構，包括標量、向量、數組、數據框和列表。多樣化的數據結構賦予了R極其靈活的數據處理能力，各種類型的數據是由各元素組成的。

（1）向量。

向量為一系列元素的組合，用于存儲數值型、字符型或邏輯型數據的一維數組。執行組合功能的函數c()可用來創建向量，各類向量如下所示：

      a <- c(1, 2, 3, 4, 10, -9, 20)
      b <- c("one", "two", "three")
      c <- c(TURE, FALSE, TRUE, TRUE, FALSE, FALSE)
      d <- c("a", "a", "b", "b", "c")

其中，a是數值型向量，b和d是字符型向量，而c是邏輯型向量。

通過在方括號中給定元素所處位置的數值訪問向量中的元素。例如，a[c(1, 4)]用于訪問向量a中的第1個和第4個元素。更多示例如下：

      > d <- c(1, 3, 5, 9,7, 10, 23, 21, 17)
      > d[2]
      [1] 3
      > d[2:5]
      [1] 3 5 9 7
      > d[c(1,2,6,7)]
      [1]  1  3 10 23

第2個語句中使用的冒號用于生成一個數值序列，d[2:5]相當于d[c(2, 3, 4, 5)]。

（2）矩陣。

矩陣是一個二維數組，只是每個元素都擁有相同的模式（數值型、字符型或邏輯型），可通過函數matrix創建矩陣。一般使用格式如下：

      mymatrix  <-  matrix (vector, nrow=, ncol=, byrow=, dimnames=list() )

其中，vector包含了矩陣的元素，nrow和ncol用以指定行和列的維數，dimnames包含了可選的、以字符型向量表示的行名和列名。選項byrow則表明矩陣應當按行填充（byrow=TRUE）還是按列填充（byrow=FALSE），默認情況下按列填充。

      > x <-  matrix(21:40, nrow=4, ncol=5, byrow=FALSE)
      > x
            [,1]    [,2]  [,3]  [,4]  [,5]
      [1,]    21    25    29    33    37
      [2,]    22    26    30    34    38
      [3,]    23    27    31    35    39
      [4,]    24    28    32    36    40
      > fourcell <- c(1,2,3,10,20,30)
      > rnames <- c("R1", "R2")
      > cnames <- c("C1", "C2", "C3")
      > mymatrix  <-  matrix (fourcell, nrow=2, ncol=3, byrow=TRUE, dimnames=list(rnames,
        cnames))
      > mymatrix
          C1 C2 C3
      R1  1  2  3
      R2 10 20 30
      > mymatrix1  <-  matrix (fourcell, nrow=2, ncol=3, byrow=FALSE, dimnames=list(rname
      s, cnames))
      > mymatrix1
          C1 C2 C3
      R1  1  3 20
      R2  2 10 30

我們首先創建了一個4×5的矩陣，接著創建了一個2×3的含列名標簽的矩陣并按行進行填充，最后創建了一個2×3的矩陣并按列進行了填充。

我們可以使用下標和方括號來選擇矩陣中的行、列或元素。X[i,]指矩陣X中的第i行，X[,j]指第j列，X[i, j]指第i行第j個元素。選擇多行或多列時，下標i和j可為數值型向量。

      > aa <-matrix(1:20, nrow=5)
      > aa
            [,1]    [,2]  [,3]  [,4]
      [1,]     1     6    11    16
      [2,]     2     7    12    17
      [3,]     3     8    13    18
      [4,]     4     9    14    19
      [5,]     5    10    15    20
      > aa[3,]
      [1]  3  8 13 18
      > aa[,3]
      [1] 11 12 13 14 15
      > aa[3,3]
      [1] 13
      > aa[3,c(3,4)]
      [1] 13 18
      > aa[,c(3,4)]
            [,1] [,2]
      [1,]    11    16
      [2,]    12    17
      [3,]    13    18
      [4,]    14    19
      [5,]    15    20

首先，我們創建了一個內容為數字1～20的5×4矩陣。默認情況下，矩陣按列填充。然后分別選擇了第3行和第3列的元素。接著，又選擇了第3行第3列的元素。之后選擇了位于第3行第3、第4列的元素。最后選擇了第3列和第4列的元素。

矩陣都是二維的，與向量類似，矩陣中也僅能包含一種數據類型。當維度超過2時，需要使用數組；當有多種模式的數據時，需要使用數據框。

（3）數組。

數組與矩陣類似，但其維度可大于2。數組可通過array函數創建，形式如下：

      setarray  <- array (vector, dimensions, dimnames)

其中，vector包含了數組中的數據；dimensions是一個數值型向量，給出了各個維度下標的最大值；而dimnames是可選的、各維度名稱標簽的列表。

      > dim1 <- c("X1", "X2")
      > dim2 <- c("Y1", "Y2", "Y3")
      > dim3 <- c("Z1", "Z2", "Z3", "Z4")
      > xyz <- array(1:24, c(4,3,2), dimnames=list(dim3, dim2, dim1))
      > xyz
      , , X1
          Y1 Y2 Y3
      Z1  1  5  9
      Z2  2  6 10
      Z3  3  7 11
      Z4  4  8 12

      , , X2
          Y1 Y2 Y3
      Z1 13 17 21
      Z2 14 18 22
      Z3 15 19 23
      Z4 16 20 24

數組是矩陣的一個自然推廣，它們在編寫新的統計方法時可能很有用。像矩陣一樣，數組中的數據也只能擁有一種模式。

從數組中選取元素的方式與矩陣相同。

      > xyz[1,2,]
      X1 X2
        5 17
      > xyz[1,3,]
      X1 X2
        9 21
      > xyz[,2,2]
      Z1 Z2 Z3 Z4
      17 18 19 20
      > xyz[3,2,1]
      [1] 7

（4）數據框。

與通常在SAS、SPSS和STATA中看到的數據集類似，不同的列可以包含不同模式（數值型、字符型等）的數據，也將是R中最常處理的數據結構。如果數據有多種模式，無法將此數據集放入一個矩陣，在這種情況下，使用數據框是最佳選擇。數據框可通過函數data.frame()創建：

      mydata  <- data.frame(col1, col2, col3, …)

其中，列向量col1, col2, col3,…可為任何類型（如字符型、數值型或邏輯型）。

      > IDnumber  <- c(101, 102, 103, 104)
      > age <- c(24, 78, 56, 45)
      > hypertention  <- c("yes", "no", "no","yes")
      > severity  <- c("high", "middle", "low", "middle")
      > patientdata  <- data.frame(IDnumber, age, hypertention, severity)
      > patientdata
        IDnumber age hypertention severity
      1       101  24            yes      high
      2       102  78             no    middle
      3       103  56             no       low
      4       104  45            yes    middle

選取數據框中元素的方式有若干種，既可以使用前述下標記號，也可以直接指定列名。

      > patientdata[1]
        IDnumber
      1       101
      2       102
      3       103
      4       104
      > patientdata[1:2]
        IDnumber age
      1       101  24
      2       102  78
      3       103  56
      4       104  45
      > patientdata["age"]
        age
      1  24
      2  78
      3  56
      4  45
      > patientdata[c("age", "severity")]
        age severity
      1  24      high
      2  78    middle
      3  56       low
      4  45    middle
      > patientdata$age
      [1] 24 78 56 45

記號$是新出現的使用方法，它被用來選取一個給定數據框中的某個特定變量。在每個變量名前都輸入一次數據框名可能會讓人生厭，所以不妨走一些捷徑，可以聯合使用函數attach()和detach()，或單獨使用函數with()來簡化代碼。

函數attach()可將數據框添加到R的搜索路徑中。R在遇到一個變量名以后，將檢查搜索路徑中的數據框，以定位到這個變量。使用以下代碼獲取年齡（age）變量的描述性統計量，并分別繪制此變量與收縮壓（hypertension）的散點圖。

      > systolic <- c(120, 130, 140, 150, 160)
      > age <- c(20, 30, 40, 50, 55)
      > hypertension  <- data.frame(systolic, age)
      >  hypertension
            systolic age
      1       120  20
      2       130  30
      3       140  40
      4       150  50
      5       160  55

      > summary(hypertension$age)
      > summary(hypertension$systolic)
      > plot(hypertension$systolic, hypertension$age)

上述代碼也可以改寫成：

      > attach(hypertension)
      > summary(age)
      > summary(systolic)
      > plot(systolic, age)
      > detach(hypertension)

函數detach()將數據框從搜索路徑中移除。detach()并不會對數據框本身做任何處理，這句是可以省略的。

當名稱相同的對象不止一個時，這種方法的局限性就很明顯了，原始對象將進行優先運算。函數attach()和detach()最好在分析一個單獨的數據框，并且不太可能有多個同名對象時使用。

除此之外，另一種方式是使用函數with()。可以這樣重寫上例：

      >  with(hypertension,{
      summary(age)
        summary(systolic)
      plot(systolic, age)
      })

大括號{}之間的語句都針對數據框hypertension執行，這樣就不用擔心名稱沖突了。如果僅有一條語句，那么大括號{}可以省略。函數with()的局限性在于賦值僅在此函數的括號內生效。如下代碼所示：

      > with (hypertension, {stat <-summary(age)
    +stat})
          Min. 1st Qu.  Median     Mean 3rd Qu.     Max.
            20       30       40       39       50       55
      > stat
      錯誤：找不到對象'stat'

以下代碼較好地闡述了這個原因：

      > with (hypertension, {nonstat <-summary(systolic)
        stat <<-summary(systolic)
      })
      > nonstat
      錯誤: 找不到對象'nonstat'
      > stat
          Min. 1st Qu.  Median     Mean 3rd Qu.     Max.
          120      130      140      140      150      160

（5）因子。

變量可分為名義型、有序型或連續型變量。名義型變量是沒有順序之分的類別變量；有序型變量表示一種順序關系，而非數量關系；連續型變量可以呈現為某個范圍內的任意值并同時表示了順序和數量。年齡就是一個連續型變量。類別（名義型）變量和有序類別（有序型）變量在R中稱為因子。因子在R中非常重要，因為它決定了數據的分析方式以及如何進行結果展示。因子在R語言中具有許多強大運算的基礎，包括許多針對表格數據的運算。因子的設計思想來源于統計學中的名義變量或分類變量，這些變量本質上不是數字，而是對應分類。例如血型，盡管可以用數字對它們進行編碼。

函數factor()以一個整數向量的形式存儲類別值，將一個由字符串（原始值）組成的內部向量映射到這些整數上。

      > hypertention  <- c("yes", "no", "no","yes")
      > hypertention <- factor(hypertention )
      > hypertention
      [1] yes no  no  yes
      Levels: no yes
      > str(hypertention)
        Factor w/ 2 levels "no","yes": 2 1 1 2

語句hypertention <?factor(hypertention )將此向量存儲為（2, 1, 1, 2），并在內部將其關聯為1=no和2=yes（具體賦值根據字母順序而定）。針對向量hypertention進行的任何分析都會將其作為名義型變量對待并自動選擇合適的統計方法。

在R中，因子可以簡單地看作一個附加更多信息的向量（盡管它們內部機理是不同的）。這額外的信息包括向量中不同值的記錄，稱為“水平”。

      > x <-c(5,12,13,12)
      > x <-factor(x)
      > x
      [1] 5  12 13 12
      Levels: 5 12 13
      > str(x)
        Factor w/ 3 levels "5","12","13": 1 2 3 2
      > length(x)
      [1] 4

x中的不同數值（5, 12, 13）就是水平。x的核心是（1,2,3,2），意味著我們的數據是由水平1、水平2和水平3的值構成的。因此數據已經重新編碼為水平，當然水平本身也被記錄。因子的長度定義為數據的長度，而不是水平的個數。

要表示有序型變量，需要為函數factor()指定參數ordered=TRUE。

      > severity  <-  c("high", "middle", "low", "middle")
      > severity <-  factor(severity, order=TRUE)
      > severity
      [1] high    middle low     middle
      Levels: high < low < middle
      > str(severity)
        Ord.factor w/ 3 levels "high"<"low"<"middle": 1 3 2 3

語句severity <? factor(severity, order=TRUE)將向量編碼為（1, 3, 2, 3），并在內部將這些值關聯為1=high、2=low以及3=middle。另外，針對此向量進行的任何分析都會將其作為有序型變量對待，并自動選擇合適的統計分析方法。

對于字符型向量，因子的水平默認依字母順序創建。這對于因子severity是沒有意義的，因為“high”“low”“middle”的排序方式與邏輯順序不一致。按默認的字母順序排序的因子很少能夠讓人滿意。

可以通過指定levels選項來覆蓋默認排序。

      > severity <-  factor(severity, order=TRUE, levels=c("low", "middle", "high"))

以下代碼展現了因子如何影響數據分析結果。

      > IDnumber  <- c(101, 102, 103, 104)
      > age <- c(24, 78, 56, 45)
      > hypertention  <- c("yes", "no", "no","yes")
      >  severity  <- c("high", "middle", "low", "middle")
      > hypertention <- factor(hypertention)
      > severity  <- factor(severity, order=TRUE)
      > patientdata  <- data.frame(IDnumber, age, hypertention, severity)
      > str(patientdata)
      'data.frame':    4 obs. of  4 variables:
        $ IDnumber     : num  101102 103104
        $ age           : num  24 78 56 45
        $ hypertention: Factor w/ 2 levels "no","yes": 2 1 1 2
        $ severity     : Ord.factor w/ 3 levels "high"<"low"<"middle": 1 3 2 3
      > summary(patientdata)
          IDnumber            age          hypertention    severity
        Min.    :101.0    Min.    :24.00    no :2          high  :1
        1st Qu.:101.8    1st Qu.:39.75    yes:2          low    :1
        Median :102.5    Median :50.50                    middle:2
        Mean    :102.5    Mean    :50.75
        3rd Qu.:103.2    3rd Qu.:61.50

Max. :104.0 Max. :78.00

（6）列表。

列表就是一些對象（或成分）的有序集合，是R數據類型中最為復雜的一種。列表允許整合若干（可能無關的）對象到單個對象名下。例如，某個列表中可能是若干向量、矩陣、數據框，甚至其他列表的組合。用戶可以使用函數list()創建列表：

      Mylist <- list(object1, object2, …)

以下為創建列表的一個示例：

      > a  <-  "list example"
      > x  <-  c(1,2,3,4,5)
      > matrix    <- matrix(1:20, nrow=5, byrow=FALSE)
      > k  <- c("one", "two", "four")
      > mylist    <- list(a, x, matrix, k)
      > mylist
      [[1]]
      [1] "list example"

      [[2]]
      [1] 1 2 3 4 5

      [[3]]
            [,1] [,2] [,3] [,4]
      [1,]     1     6    11    16
      [2,]     2     7    12    17
      [3,]     3     8    13    18
      [4,]     4     9    14    19
      [5,]     5    10    15    20

      [[4]]
      [1] "one"  "two"  "four"

本例創建了一個列表，其中有4個成分：1個字符串、1個數值型向量、1個矩陣以及1個字符型向量。用戶可以組合任意多的對象，并將它們保存為一個列表。

用戶也可以通過在雙重方括號中指明代表某個成分的數字或名稱來訪問列表中的元素。

      > mylist[[3]]
            [,1] [,2] [,3] [,4]
      [1,]     1     6    11    16
      [2,]     2     7    12    17
      [3,]     3     8    13    18
      [4,]     4     9    14    19
      [5,]     5    10    15    20

在此例中，mylist[[3]]指矩陣。由于兩個原因，列表成為了R中的重要數據結構。首先，列表允許以一種簡單的方式組織和重新調用不相干的信息。其次，許多R函數的運行結果都是以列表的形式返回的，由分析人員決定需要取出其中哪些成分。

2.1.2 R運算符

R運算符是一些符號，它們要求作比較，進行算術運算、比較運算或邏輯運算等。

1．算術算符

指數學運算中常用的5種運算符號。算術算符的表示方法及其含義如表2-1所示。

2．比較算符

建立兩個量之間的一種關系，并要求R確定這種關系是否成立。如果成立，輸出的運算結果是1；如果不成立，運算結果為0。比較算符的表示方法及其含義如表2-2所示。

如表達式X<Y。如果X為5，Y為2，那么表達式X<Y的值為0（不成立）。如果X為5，Y為9，那么X<Y的值為1（成立）。

3．邏輯算符

通常用來連接一系列比較式。邏輯算符包括：& AND（與）、|OR（或）和！NOT（非）。邏輯算符的表示方法及其含義如表2-3所示。

如果“&”左右兩個量都為真，那么AND運算產生的結果為1，否則為0。例如表達式：X<Y and C>0為真，僅當X<Y為真且C>0為真時，也就是當X<Y且C>0為真時，結果為1。

如果“|”兩邊的量至少有一個為真，那么“|”運算的結果是1，否則是0。例如，表達式X<Y | C>0為真，僅當X<Y為真而不必管C的值，或者C>0為真而不管X<Y是否為真，也就是說，這兩個關系式中有一個或兩個都成立時，這個表達式為真。

“！”也是一個邏輯算符。在一個值為0的量前面放上“！”的結果是1。也就是否定一個假的結果為真。例如，如果A=B為假，那么！（A=B）為真。在一個缺失值的量前面放上“！”結果也為真。相反，否定一個真的結果就是假的。

R語言表面上沒有標量的類型，因為標量可以看作是含有一個元素的向量，但如表2-3所示，邏輯運算符對標量和向量有著不同的形式。下面以一個簡單的例子闡述這種區別的必要性。

      > x <- c(TRUE, FALSE, TRUE)
      > y <-c (TRUE,TRUE,FALSE)
      > x & y
      [1]  TRUE FALSE FALSE
      > x[1 ]&& y[1]
      [1] TRUE
      > x && y
      [1] TRUE
      > if (x[1 ]&& y[1])
    +print("both TURE")
      [1] "both TURE"
      > if (x & y)
    +print("both TURE")
      [1] "both TURE"
      Warning message:

if (x & y) print("both TURE")：條件的長度大于一，因此只能用其第一元素。

if結構條件判斷語句的取值，只能是一個邏輯值，而不是邏輯值的向量，這也是為什么會出現警告提示。因此，“&”和“&&”這兩種運算符的存在是必要的。

      > 1<2
      [1] TRUE
      > (1<2) *(3<4)
      [1] 1
      >  (1<2) *(3<4) *(5<1)
      [1] 0
      >  (1<2) *(3<4) *(5<1)  *(5<1)
      [1] 0
      > (3<4)==TRUE
      [1] TRUE
      > (3<4)==1
      [1] TRUE

4．運算次序

下面給出復雜表達式運算次序的準則。

（1）括號里的表達式先計算。

（2）較高優先級的運算先被執行。優先級的順序如表2-4所示。

（3）對于相同優先級的算符，先做左邊的運算。