实验一 R语言的基本操作和数据组织

【实验目的】

• 熟悉R语言的安装过程和步骤，熟悉Rstudio环境的配置，了解Rstudio操作的基本菜单和命令，掌握R语言数据的主要类型和基本操作。

【实验内容】

• 从官方网站下载R安装包在本地电脑上进行安装。

• 安装配置好Rstudio环境。

• R 语言的基本数据对象和操作

【实验所使用的仪器设备及软件平台】

   计算机 R   RStudio

【实验方法与步骤】

安装R

• 登录R的官方下载界面

  

• 点击链接Download R 3.5.1 for Windows，开始下载4.0.1版本的R，约84MB

  

• 下载完成后安装，双击.exe文件

  

• 确定

  

• 一直点击下一步

• 根据自己的爱好设置下一信息

• 下一步，及完成安装

配置R的环境变量

• 检验环境变量

  

• 复制 R的bin文件路径

• 右击桌面电脑图标 > 选择属性 > 选择左上角的高级系统设置 > 点击环境变量 > 在系统变量中找到path > 点击进去粘贴（若是如下图粘贴即可，末尾记得加上英文分号；若是列表型，点击新建，粘贴）> 按原路径确定

  

• 再次检验 （成功出现如下图示）

  

安装配置好Rstudio

安装Rstudio

• step1：打开RStudio官方网站 https://www.rstudio.com/products/rstudio/download/ 点击Free下的Download

  

• step2：随后自动跳转到下载链接处。在"Installers for Supported Platforms"中，对应自己的系统，选择合适的版本。

• step3：我选择下载的是“RStudio 1.1.456 - Windows Vista/7/8/10”

• step4：下载后打开程序进入安装向导，点击下一步

• step5：设置安装路径

• step6：下一步进行安装

• step7：根据自身电脑操作系统的位数选择，但64位系统可全选，因为64位向下兼容32位系统。

• step8：启动选项，默认选择No

• step9：正在安装

!

• step10：安装完成并生成桌面快捷方式

测试安装是否成功

• step1：双击RStudio打开IDE

• step2：输入1+1 按Enter+Ctrl运行

• step3：得到结果2，运算正确，安装成功。

RStudio界面介绍

• 打开RStudio之后，会出现上图所示的窗口，其中有三个独立的面板。最大的面板是控制台窗口，这是运行R代码和查看输出结果的地方。也就是运行原生R时看到的控制台窗口。其他面板则是RStudio所独有的。隐藏在这些面板中的包括一个文本编辑器、一个画图界面、一个代码调试窗口、一个文件管理窗口等。

R语言的基本数据对象及操作

类型	辨别函数	转换函数
numeric	is.numeric()	as.numeric()
logical	is.logical()	as.logical()
charcter	is.charcter()	as.charcter()
NA	is.na()	as.na()
double	is.double()	as.double()
complex	is.complex()	as.complex()
integer	is.integer()	as.integer()

注意：

is.integer(x) does not test if x contains integer numbers!

> is.integer(100)
[1] FALSE
> is.integer(3)
[1] FALSE

is.wholenumber <-
function(x, tol = .Machine$double.eps^0.5) abs(x - round(x)) < tol
is.wholenumber(1) # is TRUE
(x <- seq(1, 5, by = 0.5) )
is.wholenumber( x ) #–> TRUE FALSE TRUE …

从结构角度划分R对象

• 上图已详细介绍了向量

矩阵

dim()

  > x<-c(1:12)
  > x
   [1]  1  2  3  4  5  6  7  8  9 10 11 12
  > dim(x) <- c(3,4)
  > x
       [,1] [,2] [,3] [,4]
  [1,]    1    4    7   10
  [2,]    2    5    8   11
  [3,]    3    6    9   12

matrix()

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

矩阵转换为向量：

> as.vector(matrix.y)
 [1]  1  6 11 16  2  7 12 17  3  8 13 18  4
[14]  9 14 19  5 10 15 20

• matrix() 函数常用参数

参数	描述
data	矩阵的元素
nrow	行的维数
ncol	列的维数
byrow	矩阵元素是否按行填充。默认为 FALSE（F）
dimnames	以字符型向量表示的行名和列名

• 矩阵的索引、合并、删除

  • 索引

    > x <- c(1:20)
    > a <- matrix(x,nrow=5,ncol=4,byrow=T,dimnames=list(c("a1","a2","a3","a4","a5"),c("b1","b2","b3","b4")))
    > a
       b1 b2 b3 b4
    a1  1  2  3  4
    a2  5  6  7  8
    a3  9 10 11 12
    a4 13 14 15 16
    a5 17 18 19 20
    > a[2,2]
    [1] 6
    > a["a4","b3"] 
    [1] 15
    > a[2,] # 第2行
    b1 b2 b3 b4 
     5  6  7  8 
    > a[,3] #第3列
    a1 a2 a3 a4 a5 
     3  7 11 15 19 
    > a[c(1:3),] # 第一至三行
       b1 b2 b3 b4
    a1  1  2  3  4
    a2  5  6  7  8
    a3  9 10 11 12
    > a[c(2:3),c(1:3)] # 第2至3行的第1至3列
       b1 b2 b3
    a2  5  6  7
    a3  9 10 11
    

  • cbind、rbind 分别是按行、按列将向量“粘”在一起

    > cbind(a=1:4,b=5:8,c=9:12)
         a b  c
    [1,] 1 5  9
    [2,] 2 6 10
    [3,] 3 7 11
    [4,] 4 8 12
    
    > rbind(a=1:3,b=4:6,c=7:10) #我们发现  数字不足时：循环填充
      [,1] [,2] [,3] [,4]
    a    1    2    3    1
    b    4    5    6    4
    c    7    8    9   10
    Warning message:
    In rbind(a = 1:3, b = 4:6, c = 7:10) :
      number of columns of result is not a multiple of vector length (arg 1)
    
    > rbind(a=1:3,b=4:6,c=7:9)
      [,1] [,2] [,3]
    a    1    2    3
    b    4    5    6
    c    7    8    9
    

• 矩阵的运算

  函数	功能
  ±*/	四则运算，要求矩阵的维数相同，对应位置的各元素进行运算
  colSums()	对矩阵的各列求和
  rowSums()	对矩阵的各行求和
  colMeans()	对矩阵的各列求均值
  rowMeans()	对矩阵的各行求均值
  t()	对矩阵的行列进行转置
  det()	求解方程的行列式
  crossprod()	求解两个矩阵的内积
  outer()	求解矩阵的外积（叉积）
  %*%	矩阵乘法，要求i第一个矩阵的列数和第二个矩阵的行数相同（m*n、n*s）
  diag()	对矩阵取对角元素，若对象为向量，则生成以向量为对角元素的对角矩阵
  solve()	对矩阵求解逆矩阵，要求矩阵可逆
  eigen()	对矩阵求解特征值和特征向量

  > x<-matrix(1:20,nrow = 5)
  > x
       [,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
  > rownames(x)
  NULL
  > rownames(x)<-LETTERS[1:5]
  > x
    [,1] [,2] [,3] [,4]
  A    1    6   11   16
  B    2    7   12   17
  C    3    8   13   18
  D    4    9   14   19
  E    5   10   15   20
  > rownames(x)
  [1] "A" "B" "C" "D" "E"
  
  
  > t(x)
        A  B  C  D  E
  [1,]  1  2  3  4  5
  [2,]  6  7  8  9 10
  [3,] 11 12 13 14 15
  [4,] 16 17 18 19 20

数组

• 数组与矩阵类似，是矩阵的扩展，它把数据 的维度扩展到2维以上，可以认为矩阵是特 殊的数组。数组中的元素类型也是单一的， 可以是数值型、逻辑型及字符型。

• 创建数组

  # 命令格式
  array(向量名，维度说明，dimnames=list(维名称列表)) 
  # 向量名：数据事先存储在指定的向量名中 
  # 维度说明：用于描述各维度的最大值，是一个数值型向量。 
  # dimnames:用于指定各维的名称，是可选的。
  

  > # 创建数组 > x <- c(1:30) 
  > # 定义数组各维度的名称 
  > dim1 <- c("A1", "A2", "A3") 
  > dim2 <- c("B1", "B2", "B3", "B4", "B5") 
  > dim3 <- c("C1", "c2") > 
  # 创建数组，数组维数为3，各维度下标的最大值为3，5，2 
  > (a <- array(x, dim = c(3, 5, 2), dimnames = list(dim1, dim2, dim3)))
  , , C1
  
     B1 B2 B3 B4 B5
  A1  1  4  7 10 13
  A2  2  5  8 11 14
  A3  3  6  9 12 15
  
  , , C2
  
     B1 B2 B3 B4 B5
  A1 16 19 22 25 28
  A2 17 20 23 26 29
  A3 18 21 24 27 30
  
  

  • 数组的索引

    • 与矩阵和向量类似，数组也可以通过下标和方括号来索 引数组中的元素，不同的是数组的维度更高，下标也更 复杂

    • > a[2,4,2]
      [1] 26
      > a["A3","B5",1]
      [1] 15
      > dim(a)
      [1] 3 5 2
      

数据框

• 数据框是仅次于向量的最重要的数据对象类型。由于不 同的列可以包含不同模式（数值型、字符型等）的数据， 数据框的概念较矩阵更为一般。在R语言中，很多数据 分析算法函数的输入对象都是数据框对象，而且在使用 读取Excel/txt等格式数据集的函数时，也是以数据框 为对象输入的。

• 数据框不同的列可以是不同模式的数据，但数据框内每 个列的长度必须相同。

• 在实际操作中，数据的一列代表某一 变量属性的所有 取值，用一行代表某一样本的数据。

• data.frame(vector1,cevtor2,……)
  

• 举例参考上一节

因子

• 变量可归结为名义型、有序型或连续型变量

• 名义型变量是没有顺序之分的类别变量。糖尿病类型Diabetes（ Type1、Type2）是名义型变量的一例。即使在数据中Type1编码 为1而Type2编码为2，这也并不意味着二者是有序的。

• 有序型变量表示一种顺序关系，而非数量 关系。病情Status（ poor, improved, excellent）是顺序型变量的一个上佳示例。我 们明白， 病情为poor（较差）病人的状态不如improved（病情 好转）的病人，但并不知道相差多少。

• 连续型变量可以呈现为某个范围内的任意值，并同时表示了顺序 和数量。年龄Age就是一个连续型变 量，它能够表示像14.5或 22.8这样的值以及其间的其他任意值。很清楚，15岁的人比14岁 的人年 长一岁。

• 类别变量和有序变量（表示一种顺序关系而非 数量关系，病情是顺序型变量的一个示例）在 R中称为因子(factor)。

• 因子提供了一个简单而紧凑的形式来处理分类 （名义型）数据。

• 因子用水平来表示所有可能的取值，如果数据 有取值个数固定的名义变量，因子特别有用。

• 因子在R中非常重要，因为它决定了数据的分 析方式以及如何进行视觉呈现。

• 创建因子

factor(x,levels,labels,exclude,ordered=NA,nmax=NA)

参数	描述
x	表示需要创建为因子的数据，是一个向量
levels	表示所创建因子数据水平，如果不指定的话，就是参数x中不重复的所有值
labels	用来标识这一水平的名字，与水平一一对应，方便识别
exclude	表示哪些水平是不需要的
ordered	一个逻辑值，为TRUE时表示有序因子，FALSE（无序因子）
nmax	表示水平个数的上限

> fpain
[1]     
Levels: A B C D
> pain
[1] 0 3 2 2 1
> fpain<-factor(pain,levels = 0:3)
> levels(fpain)<-c("none","mild","medium","severe")
> fpain
[1] none   severe medium medium mild  
Levels: none mild medium severe
> as.numeric(fpain)
[1] 1 4 3 3 2
> levels(fpain)
[1] "none"   "mild"   "medium" "severe"

> patientID<-c(1,2,3,4)
> age<-c(25,34,28,52)
> diabetes<-c("type1","type2","type1","type1")
> status<-c("poor","improved","excellent","poor")
> diabetes<-factor(diabetes)
> status<-factor(status,ordered =TRUE)
> patientdata<-data.frame(patientID,age,diabetes,status)
> str(patientdata)
'data.frame':	4 obs. of  4 variables:
 $ patientID: num  1 2 3 4
 $ age      : num  25 34 28 52
 $ diabetes : Factor w/ 2 levels "type1","type2": 1 2 1 1
 $ status   : Ord.factor w/ 3 levels "excellent"<"improved"<..: 3 2 1 3
> summary(patientdata)
   patientID         age         diabetes
 Min.   :1.00   Min.   :25.00   type1:3  
 1st Qu.:1.75   1st Qu.:27.25   type2:1  
 Median :2.50   Median :31.00            
 Mean   :2.50   Mean   :34.75            
 3rd Qu.:3.25   3rd Qu.:38.50            
 Max.   :4.00   Max.   :52.00            
       status 
 excellent:1  
 improved :1  
 poor     :2  
              
              
              
> patientdata
  patientID age diabetes    status
1         1  25    type1      poor
2         2  34    type2  improved
3         3  28    type1 excellent
4         4  52    type1      poor

• 因子创建 gl():

  gl(n,k,length=n*k,labels=seq_len(n),ordered=FALSE)
  

  参数	描述
  n	表示因子水平的个数
  k	表示每个水平的重复数
  length	表示生成的序列的长度
  labels	一个n 维向量，表示因子水平
  ordered	一个逻辑值，为true表示有序因子，为false即为无序因子

  > gl(3,3)
  [1] 1 1 1 2 2 2 3 3 3
  Levels: 1 2 3
  > gl(2,3,labels = c("T","F"))
  [1] T T T F F F
  Levels: T F
  > gl(2,1,10)
   [1] 1 2 1 2 1 2 1 2 1 2
  Levels: 1 2
  > gl(2,2,10)
   [1] 1 1 2 2 1 1 2 2 1 1
  Levels: 1 2
  > gl(2,2,10,ordered = T)
   [1] 1 1 2 2 1 1 2 2 1 1
  Levels: 1 < 2
  > gl(2,2,ordered = T)
  [1] 1 1 2 2
  Levels: 1 < 2
  > gl(3,3,ordered = T)
  [1] 1 1 1 2 2 2 3 3 3
  Levels: 1 < 2 < 3
  

• 因子的存储方式

  • 在R语言中，因子是以整数型向量存储的，每个因子水平 对应一个整数型数字。对于字符型向量创建的因子，会按 照字母顺序排序，再对应到整数型向量中

列表

• 列表是R的数列类型中最为复杂的一种。一般来说，列 表就是一些对象（或成分component）的有序组合。 列表允许整合若干个(可能无关的)对象到单个对象名下。 某个列表可能是若干个向量、矩阵、数据框，甚至其他 列表的组合。

• 在R进行数据分析和挖掘过程中，向量和数据框的使用 频率是最高的，列表则是存储较复杂的数据时作为数据 对象类型。

• 由于以上两个原因，列表成为了R中的重要数据结构。 首先，列表允许以一种简单的方式组织和重新调用不相 干的信息。其次，许多R函数的运行结果都是以列表的 形式返回的。

• 列表的创建：

  list(object1,object2,……)
  

  # 建立一个包含不同数据类型向量的列表
  > data<-list(a=c(1,2,3,4),b=c("one","two","three"),c=c(T,F),d=(1+2i))
  > data
  $a
  [1] 1 2 3 4
  
  $b
  [1] "one"   "two"   "three"
  
  $c
  [1]  TRUE FALSE
  
  $d
  [1] 1+2i
  
  > summary(data) 
    Length Class  Mode     
  a 4      -none- numeric  
  b 3      -none- character
  c 2      -none- logical  
  d 1      -none- complex 
  

• 为列表中的对象命名

  > names(data)
  [1] "a" "b" "c" "d"
  > names(data)<-c("vector1","vector2","vector3","vector4")
  > data
  $vector1
  [1] 1 2 3 4
  
  $vector2
  [1] "one"   "two"   "three"
  
  $vector3
  [1]  TRUE FALSE
  
  $vector4
  [1] 1+2i
  > names(data)
  [1] "vector1" "vector2" "vector3" "vector4"
  

• 列表的索引

  • 在双重方括号中指明代表某个成分的数字或名称 来访问列表中的元素；

  • 也可以通过$来按名称索引列。

    > data[[2]]
    [1] "one"   "two"   "three"
    > data$c
    [1]  TRUE FALSE
    

• 列表的编辑

  • c() 函数进行合并，unlist() 把列表转化为向量

    > class(data)
    [1] "list"
    > data_2<-unlist(data)
    > class(data_2)
    [1] "character"
    > data_2
    vector11 vector12 vector13 vector14 vector21 
         "1"      "2"      "3"      "4"    "one" 
    vector22 vector23 vector31 vector32  vector4 
       "two"  "three"   "TRUE"  "FALSE"   "1+2i"
    

1] 1+2i

names(data)
[1] “vector1” “vector2” “vector3” “vector4”

- 列表的索引

- 在双重方括号中指明代表某个成分的数字或名称 来访问列表中的元素；

- 也可以通过$来按名称索引列。

  ```R
  > data[[2]]
  [1] "one"   "two"   "three"
  > data$c
  [1]  TRUE FALSE
  ```

- 列表的编辑

- c() 函数进行合并，unlist() 把列表转化为向量

  ```R
  > class(data)
  [1] "list"
  > data_2<-unlist(data)
  > class(data_2)
  [1] "character"
  > data_2
  vector11 vector12 vector13 vector14 vector21 
       "1"      "2"      "3"      "4"    "one" 
  vector22 vector23 vector31 vector32  vector4 
     "two"  "three"   "TRUE"  "FALSE"   "1+2i"
  ```