创建数据集

R可以处理的数据类型（模式），包括数值型、字符型、逻辑型（TRUE/FALSE）、复数型（虚数）和原生型（字节）

数据结构

R用于存储数据的对象类型，包括标量、向量、矩阵、数组、数据框和列表：

向量

y <- c(8, 3, 5, 7, 6, 2, 8, 9)
any(y < 10)          #任意元素满足条件返回真值
#输出 TRUE
all(y < 10)          #所有元素满足条件返回真值
#输出 TRUE
which(y < 10)        #取数组中小于10值的下标
#输出 1 2 3 4 5 6 7 8

可以使用c ( )函数直接连接2个向量：

z <- c(x, y)

连续数构造的向量可以使用“:”来构造：

z <- c(1:100)
#或者
z <- 1:100

seq(from, to, by, length.out, …) 可以产生等间隔数列的函数
其中，from 表示开始的数，to表示结束的数，by表示间隔，length.out表示数列长度
例如：

seq(0,1,length.out = 11)	  #生成[0,1]之间等间隔的11个数
#输出 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
seq(0,9, by = 2)             #生成[0,9]之间间隔为2的个数
#输出 0 2 4 6 8

rep(x, times, length.out, …)可以产生重复的若干个数字
其中，x 表示重复的数，tims表示重复次数，length.out表示数列长度
例如：

rep(1:4, times = 2)	            # 输出1 2 3 4 1 2 3 4
rep(1:4, length.out = 10)	    # 输出1 2 3 4 1 2 3 4 1 2
rep(c("a","b","c","d"), times=c(1,2,3,4))
#输出 "a" "b" "b" "c" "c" "c" "d" "d" "d" "d"
rep(c("a","b","c"), times=c(3,3,3))
#输出 "a" "a" "a" "b" "b" "b" "c" "c" "c"

矩阵

mymatrix <- matrix ( ① vector,② nrow=number_of_rows,③ ncol=number_of_columns,④ byrow=logical_value,⑤ dimnames=list(char_vector_rownames, char_vector_colnames))
① 矩阵的元素
② 矩阵的行数
③ 矩阵的列数
④ 是否按行填充 (默认“按列填充”)
⑤ 行名和列名

#与矩阵有关的函数：
dim()           #可以查看矩阵的维数
ncol()          #返回矩阵的列数 
nrow()          #返回矩阵的行数
as.vector()     #将矩阵强制转换为向量

创建矩阵举例：

x <- matrix(1:20,5,4,T)    #创建一个5X4矩阵
#输出
x
     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    5    6    7    8
[3,]    9   10   11   12
[4,]   13   14   15   16
[5,]   17   18   19   20
cells <- c(1,26,24,68)    
rnames <- c('R1','R2')
cnames <- c('C1','C2')
a <- matrix(cells,2,2,T,list(rnames,cnames))    #按行填充的2X2矩阵
#输出
a
   C1 C2
R1  1 26
R2 24 68

数组

数组是矩阵的推广，维度可以大于2，但各元素也只能有一种模式
myarray <- array ( ① vector, ② dimensions, ③ dimnames)
① 数组的元素
② 各维度的元素数
③ 各维度的名称
创建数组举例：

dim1 <- c('A1','A2')
dim2 <- c('B1','B2','B3')
dim3 <- c('C1','C2','C3','C4')
z <- array(1:24,c(2,3,4),list(dim1,dim2,dim3))
#输出
z
, , C1

   B1 B2 B3
A1  1  3  5
A2  2  4  6

, , C2

   B1 B2 B3
A1  7  9 11
A2  8 10 12

, , C3

   B1 B2 B3
A1 13 15 17
A2 14 16 18

, , C4

   B1 B2 B3
A1 19 21 23
A2 20 22 24

数据框

数据框不同列的元素可以是不同模式，使用比矩阵更加普遍，是R中最常处理的数据结构
mydata <- data.frame ( col1, col2, col3, … )

patientID <- c(1, 2, 3, 4)
age <- c(25, 34, 28, 52)
diabetes <- c("Type1", "Type2", "Type1", "Type1")
status <- c("Poor", "Improved", "Excellent", "Poor")
patientdata <- data.frame(patientID, age, diabetes, status)
#输出
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

选取数据框元素的几种方法：

#读取patientdata中第3个病人的status信息： 
patientdata$age[3]
#输出
 28
patientdata[[2]][3]
#输出
 28
patientdata[3,2]
#输出
 28

两种绑定数据框的方式：

attach() + detach()
attach()：将数据框添加到R的搜索路径中
detach()：将数据框从R的搜索路径移除

例如：读取diabetes=Type1的病人的status信息：

patientdata$status[which(patientdata$diabetes=="Type1")]
#输出
Poor      Excellent Poor     
Levels: Excellent Improved Poor

可改写为：

attach(patientdata)
status[which(patientdata$diabetes=="Type1")]
#输出
"Poor"      "Excellent" "Poor"     
> detach(patientdata)

注意：
如果数据框被绑定之前，global environment已中有与数据框中的变量同名的其它变量（原始对象）时，R会让原始对象获得优先权，而屏蔽（mask）数据框变量

with(dataframe, {statement})
其中，{statement}是针对数据框dataframe执行的语句
如果statement仅有一条语句，可以省略{ }

还是上面的例子：

with(patientdata, {
+     c<- which(diabetes=="Type1")
+     status [c]
+ })
#输出
Poor      Excellent Poor     
Levels: Excellent Improved Poor

注意：
with()函数的赋值仅在{ }内生效

因子

类别（名义型）变量和有序类别（有序型）变量在R中称为因子

factor(①x, ②levels, ③labels=levels, ④exclude, ⑤ordered)
①数据向量，也就是被转换成因子的向量
②因子水平
③指定各水平的名称
④从x中剔除某个水平值
⑤次序

x <- c(1,1,2,1,2,3,2,2,3,3,3,1,1,1,2)
f<-factor(x)
f
#输出
1 1 2 1 2 3 2 2 3 3 3 1 1 1 2
Levels: 1 2 3

x <- rep(1:5, 1:5)
f<-factor(x)
f
#输出
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
Levels: 1 2 3 4 5

x <- c("Hello","World","This","Is","R")
f<-factor(x)
f
#输出
Hello World This  Is    R    
Levels: Hello Is R This World

次序问题：

1.
status <- factor(status)
status
#输出
Poor      Improved  Excellent Poor     
Levels: Excellent < Improved < Poor

2.
status <-	factor(status, order=TRUE)  #按照字母顺序进行排序
status
#输出
Poor      Improved  Excellent Poor     
Levels: Excellent < Improved < Poor

3.
status <-	factor(status, ordered=TRUE,levels=c("Poor", "Improved", "Excellent"))
> status
#输出
Poor      Improved  Excellent Poor     
Levels: Poor < Improved < Excellent

因子的使用：

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,order = 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       status 
 Min.   :1.00   Min.   :25.00   Type1:3   Excellent:1  
 1st Qu.:1.75   1st Qu.:27.25   Type2:1   Improved :1  
 Median :2.50   Median :31.00             Poor     :2  
 Mean   :2.50   Mean   :34.75                          
 3rd Qu.:3.25   3rd Qu.:38.50                          
 Max.   :4.00   Max.   :52.00

另一种定义因子的函数：
gl(①n, ②k, ③length, ④labels, ⑤ordered)
①水平数
②重复的次数
③生成因子向量的长度
④因子水平的名称
⑤因子水平的次序

gl(3,5,labels=paste0("A",1:3))
#输出
A1 A1 A1 A1 A1 A2 A2 A2 A2 A2 A3 A3 A3 A3 A3
Levels: A1 A2 A3

列表

列表是R数据类型中最复杂的一种，可以将若干无关的对象整合到列表下，例如，某个列表可能是若干向量、矩阵、数据框、其它列表的组合

list ( object1, object2, … )
object1, object2, …：可以是R的任何数据类型

g <- "My First List"
h <- c(25,26,18,39)
j <- matrix(1:10,nrow = 5)
k <- c("One","Two","Three")
mylist <- list(title = g,ages = h,j,k)
mylist
#输出
$title
[1] "My First List"

$ages
[1] 25 26 18 39

[[3]]
     [,1] [,2]
[1,]    1    6
[2,]    2    7
[3,]    3    8
[4,]    4    9
[5,]    5   10

[[4]]
[1] "One"   "Two"   "Three"


mylist[[2]]
#输出
25 26 18 39
> mylist[["ages"]]
#输出
25 26 18 39