R基础

基本操作

1

清屏 ctrl+L

1
2
3
4
5
6


getwd() #获取当前环境储存位置
setwd() #更改位置
#eg.setwd("C:/Users/30521/Desktop/R_script")

list.files() #查看文件，默认为储存文件夹
dir() #与list.files() 用法一致

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


# 变量赋值
x<-3
x<<-3 #强制赋值给一个全局变量

#查看环境中的变量
ls()

#详细查看
ls.str() # str()是列出某一个变量的信息

# 查看所有文件，包括“.”开头的隐藏文件
ls(all.names=TRUE)

# 列出历史记录
history()

# 删除环境中的对象
rm() # rm(x);rm(x,y)
rm(list=ls()) # 删除环境中的所有对象

# 保存工作空间
save.image()

# 返回对象前面或后面的部分
head()
head(mtcars,2) # 返回mtcars数据集的前两行

R包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


# R包的安装
install.packages() #eg. install.packages("vcd")
.libPaths() # 显示库所在的位置
library() # 显示库里的安装包
installed.packages() # 显示环境中已安装的包

# 一次安装多个包可使用c向量
install.packages(c("",""))

# 更新安装包
update.packages()

# 卸载安装包
remove.packages()

# 环境中移除包
detach("package:包名")

#载入包
library("包名")
require("包名")

# 查看一个包
help(package="包名")
library(help="包名")

# 列出包中所有包含的函数
ls("package:包名")

# 查看包中包含的数据集
data(package="包名")

获取帮助

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


help.start() # 获取帮助

help(函数名)
?名称

args(名称) # 快速查阅

example() # 可以查看示例

demo(graphics) # 查看R的案例图
heatmap(矩阵) # 绘制热图

help(package="包名")

vignette(package="包名") # 查看一个包更完整的案例等教程
vignette("教程名") # 具体查看某一个包里的某一个教程

??函数名 # 不加载包可以直接搜索函数，本地搜索

help.search("函数名") # 模糊搜索，本地搜索函数。可用“??函数名”简写

apropos("关键字") # 搜索关键字的内容
apropos("关键字"，mod="类型") # 含关键词指定类型的搜索

RSiteSearch("关键词") # 在线搜索

内置数据集

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 存在于datasets包中
help(package="datasets")

data() # 列出数据集
data(package="包名") # R包中的数据集
data(package = .packages(all.available = TRUE)) # 查看所有可用数据集
data(数据集名,package="R包名") # 不加载R包使用其中的数据集
# 直接输入数据集名字，即可查看使用

data.frame(名称,名称，……) # 构成数据框

数据结构

向量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


# 字母c连接
x<-c(1,2,3,4)
y<-c("one","two","three") # 字符串一定要加引号，单双都可以

# 逻辑型向量
z<-c(T,F)

# 快捷构建向量——生成等差数列
c(1:100) # 构建1到100的等差数列
seq(from=1,to=100)
seq(from=1,to=100,by=2) # by控制步长
seq(from=1,to=100,length.out=10) # length.out控制输出个数

# 快捷构建向量——生成重复序列
rep(x, times = 1, length.out = NA, each = 1)
rep(1,5) #结果为1 1 1 1 1

x<-c(1,2,3,4)
rep(x,3) # 结果为1 2 3 4 1 2 3 4 1 2 3 4
rep(x,each=3) # 结果为1 1 1 2 2 2 3 3 3 4 4 4
rep(x,each=3,times=2) 
# 结果为1 1 1 2 2 2 3 3 3 4 4 4 1 1 1 2 2 2 3 3 3 4 4 4

# 一个向量中元素类型必须为同一类型
x<-c(1,2,"3") # 结果最后全部转换为字符类型是"1" "2" "3"

# 查看类型
mode(x)

# R为向量化编程
x<-c(1,5,6,4)
y<-c(2,8,9,6)
x+y # 结果为3 13 15 10向量
x[x>3] #避免循环的使用，结果为5,6,4向量

# 在重复中也有好处
x<-c(1,2,3,4)
rep(x,c(2,4,6,8)) # 结果为1 1 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4 4 4向量

向量索引

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


x<-c(1:100) # 创建1到100的连续向量
length(x) # 向量长度100
x[1] # 访问第一个元素（与C++不同，R元素是从1开始）
x[-19] # 表示输出除了19以外的所有元素！！

# 向量化索引
x[c(3:10)] # 结果为3  4  5  6  7  8  9 10向量
x[c(1,56,82,98)] # 结果为1 56 82 98向量
x[c(-2,5,6)] # 有正有负时，逻辑矛盾

#逻辑值索引
y<-c(1:10)
y[c(T,T,F)] # 输出1  2  4  5  7  8 10
y[c(T,F,T,T)] # 输出1 3 4 5 7 8 9
y[c(T,T,T,T,T,F,F,T,T,T,T)] # 输出1  2  3  4  5  8  9 10 NA
y[y>5] # 输出6  7  8  9 10
y[y>5&y<9] # 输出6  7  8

# 字符串向量的逻辑型判断
z<-c("one","two","three","four","five")
"one" %in% z # 输出为TRUE
z["one" %in% z] # 输出为"one"   "two"   "three" "four"  "five" 
z %in% c("one","two") # 输出为TRUE  TRUE FALSE FALSE FALSE

# 给对象命名
x<-c(1,2,3,4,5)
names(x)<-c("one","two","three","four","five")
x 
# 结果为one   two  three  four  five 
        1     2     3     4     5 

x["one"] # 由此可访问对应的列
#结果为 one 
        1 

# 添加向量（对多的位数额外赋值即可）
x<-c(1:100)
x[101]<-101 # 结果即为c(1:101)
v<-c(1:3)
v[c(4:5)]<-c(4,5)
v # 结果为1 2 3 4 5
# 也可以跨位赋值，中间的即为NA
w<-c(1:5)
w[c(8:10)]<-c(11,12,13)
w # 结果为1  2  3  4  5 NA NA 11 12 13

#插入数据
append(x, values, after = length(x))
m<-c(1:8)
append(m,16,after=3) # 结果为1  2  3 16  4  5  6  7  8

# 删除向量中某个元素(负整数索引)
x<-c(1:10)
x[-c(1:3)] # 结果为4  5  6  7  8  9 10

向量运算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


# 向量运算作用于每一个元素
x<-c(1:10)
x+1 # 即为c(2:11)
x-3 # 即为c(-2:7)

# 向量间运算则一一对应运算
x<-c(1:10)
y<-seq(1,100,length.out=10)
x+y # 结果为2  14  26  38  50  62  74  86  98 110
x*y # 结果为 1   24   69  136  225  336  469  624  801 1000
x**y # 此时为乘幂运算
x%%y # 求余运算
y%/%x # 整除运算

# 向量中元素个数不对等时，循环使用（仅限于一个是另一个的倍数）
x<-c(1:10)
z<-c(1,2)
x+z # 结果为 2  4  4  6  6  8  8 10 10 12
z1<-c(1,2,3)
x+z1 # Warning：In x + z1 : 长的对象长度不是短的对象长度的整倍数

# 向量逻辑运算（向量中元素比较返回逻辑值）
x<-c(1:10)
x>5 # 返回FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE
which(x>5) # 返回>5的位数
x[x>5]==x[which(x>5)]
y<-c(2:11)
x<y # 返回全是TRUE
# 注意：向量中元素不对等时，依旧只有整数倍能循环比较，否则无法进行
x==y # 返回逻辑型判断是否相等

# 向量运算函数
abs() # 绝对值
sqrt() # 平方根计算
sum() #求和
mean() #均值
log(#真数,base=#底数) log(16,base=2)=4
log(#数) #默认是自然对数
exp() # 计算某个数的指数值
ceiling() # 向上取整 
floor() # 向下取整
trunc() # 返回整数部分
round() # 四舍五入 round(x, digits = 保留小数点后的位数)
signif() # 四舍五入，但位数是从最高位开始计 signif(x, digits = 保留位数)
sin() # 三角函数
cos() # 三角函数
max() # 最大值
min() # 最小值
range() # 返回最大与最小值
var() # 方差
sd() # 标准差
prod() # 连乘的积
median() # 中位数
quantile() # 分位数计算
quantile(x, probs = c(0.1, 0.5, 0.9)) # 确定想要的分位数
which.  () # 返回位置
which.min(x) # 返回x中最小值在第几位
which(x==3) # 返回等于3在第几位

矩阵与数组

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114


# R内置数据集中的矩阵
iris3
state.x77

# 创建矩阵
x<-c(1:20)
matrix(x,nrow=4,ncol=5)
matrix(1:20,4,5)# 先是“行”，后是“列”
#     [,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
# 默认是按列排列，可以增添byrow=T来按行排列
matrix(c(1:20),4,byrow=T)
     [,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

# 行列命名
m<-matrix(1:20,4,5)
rnames<-c("R1","R2","R3","R4")
cnames<-c("C1","C2","C3","C4","C5")
dimnames(m)<-list(rnames,cnames)
m
   C1 C2 C3 C4 C5
R1  1  5  9 13 17
R2  2  6 10 14 18
R3  3  7 11 15 19
R4  4  8 12 16 20

# dim()表示向量维数，也可来创造矩阵
x<-1:10
dim(x)<-c(2,5)
x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    3    5    7    9
[2,]    2    4    6    8   10

# R中的数组是多维矩阵
x<-1:20
dim(x)<-c(2,5,2)
x
, , 1

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

, , 2

     [,1] [,2] [,3] [,4] [,5]
[1,]   11   13   15   17   19
[2,]   12   14   16   18   20

# 数组创建
dim1<-c("A1","A2")
dim2<-c("B1","B2","B3")
dim3<-c("C1","C2","C3","C4")
z<-array(1:24,c(2,3,4),dimnames=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

# 查找元素
x<-matrix(1:20,4,5,byrow=T) 
x[1,2] # 查找为2
x[1,c(2,3,4)] # 访问多个元素
x[c(2,3),c(2,3)] # 访问子集
x[2,] # 访问第二行
x[,2] # 访问第二列
x[-1,2] # 负数索引，去除第一行后输出第二列

# 也可以通过名称访问
state.x77
state.x77["Alabama",]

# 矩阵的运算就是每个元素的运算
colSums() # 分别计算矩阵每一列和
rowSums() # 分别计算矩阵每一行和
colMeans() # 列平均
rowMeans() # 行平均

#矩阵乘法
m<-matrix(1:9,3,3)
n<-matrix(2:10,3,3)
m*n # 内积，对应位置元素相乘即可
m%*%n # 外积，线代中的矩阵乘法运算

diag(n) # 返回对角矩阵的值2  6 10
t(n) # 矩阵转置，行列互换

列表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


# 向量只能储存一种数据类型，列表中的对象则可以是任何数据结构，内置的state.center数据集就是一个列表
list() # 创建列表
a<-c("A","B","C")
b<-c(1,2,3,4)
c<-head(mtcars,3)
d<-"Test list"
m<-list(a,b,c,d)
#结果如下：
[[1]]
[1] "A" "B" "C"

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

[[3]]
               mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4     21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
Datsun 710    22.8   4  108  93 3.85 2.320 18.61  1  1    4    1

[[4]]
[1] "Test list"

# 添加名称
list(A=a,B=b,C=c,D=d)
# 结果如下：
$A
[1] "A" "B" "C"

$B
[1] 1 2 3 4

$C
               mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4     21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
Datsun 710    22.8   4  108  93 3.85 2.320 18.61  1  1    4    1

$D
[1] "Test list"

# 列表的访问
m<-list(……)
m[1] # 访问第一个列表元素
m[c(1,3)] # 访问第一个与第三个列表元素

# 也可以通过名称访问列表元素
state.center[c("x","y")]
state.center$x

state.center[1]=state.center["x"] # 一个中括号是输出的列表子集，依旧为列表格式，即包含$开头的标题部分
state.center[[1]] # 则是去除了列表格式，表示第一个原本的内容与格式
#同样的，给列表赋值也要到两个中括号的格式开始
mlist<-state.center
mlist[[3]]<-c(1:10)
names(mlist)[3]<-"z" # 给新加入的列表内容命名
mlist[-3] # 负索引的方式去除列表内容
mlist[[3]]<-NULL # 用NULL赋值删除列表中的元素

数据框

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


# 表格式数据结构，实质上是一个列表，元素是向量，这些向量构成数据框的列，每列长度相等。因此数据框是矩形结构，且数据框的列必须命名
# 内置的数据框如iris,mtcars,rock，women

# 合成数据框
state<-data.frame(state.name,state.abb,state.region,state.x77)
# 访问
state[1] # 第一列内容数据框
state[1,2] # 第一行第二列的元素
state[c(1,2)] # 第一列与第二列
state[,"state.abb"] # 第二列内容向量
state$state.abb # 快速取出第二列内容向量

# 如访问women数据框并绘图
plot(women$height,women$weight)
lmplot<-lm(weight~height,data=women) # 线性拟合
summary(lmplot) # 可以查看详细的报告

# 访问数据框的内容时每次使用数据框名+$+名称较为繁琐，选用attach函数，此类方法同样适用于列表
attach(mtcars)
mpy # 即可直接输出这一列
rownames(mtcars) # 查看行名
colnames(mtcars) # 查看列名
detach(mtcars) # 解除使用

# 还可以选用with函数
with(mtcars,{mpg}) # 直接查看mtcars里面的mpg列

因子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


# 因子是R中对分类变量的特殊编码形式，它会把分类数据的字符/数值标签和底层整数编码绑定在一起，R中自带的因子数据有state.region,state.division
mtcars$cyl # 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4 4 8 8 8 8 4 4 4 8 6 8 4
table(mtcars$cyl) # table函数进行频数统计
# 4  6  8 
11  7 14 

f<-factor(c("red","red","green","blue","green","red","blue"))
f
# [1] red   red   green blue  green red   blue 
Levels: blue green red

factor(c("red","red","green","blue","green","red","blue"),ordered=T,levels=c("red","blue","green")) # 输出有序
#[1] red   red   green blue  green red   blue 
Levels: red < blue < green

as.integer(f) # 即可查看因子的底层整数编码3 3 2 1 2 3 1

plot(mtcars$cyl) # 向量绘图是散点图
plot(factor(mtcars$cyl)) # 因子绘图是柱状图

# 分割连续型向量
cut(x, breaks, labels = NULL, include.lowest = FALSE, right = TRUE, dig.lab = 3, ordered_result = FALSE, ...)

num<-c(1:100)
cut(num,breaks=c(seq(0,100,by=10)))

缺失数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


# NA代表缺失值，不代表值为0！！
# 带有NA的数据计算结果都为NA

a<-c(NA,1:50)
sum(a,na.rm=T) # 添加na.rm=T后就会跳过NA来计算
mean(a,na.rm=T) # 个数也算移除NA后的个数

is.na(a) # 查看a数据集中是否含有NA,返回内容是逻辑型

# 下载的VIM库里面的数据集如sleep含有较多NA，可以求和看是否包含NA
colSums(sleep)
rowSums(sleep) 

# 清除带有的NA值
a<-c(NA,1:20,NA,NA)
na.omit(a)
# [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
attr(,"na.action")
[1]  1 22 23
attr(,"class")
[1] "omit"

na.omit(sleep) # 对含有NA的数据框处理，会清除含有NA的所有行内容

1/0 # Inf表示无穷值
0/0 # NaN表示不可能的值

字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


# R中的month.name也是一个字符串向量
nchar("Hello world!") # 输出为12，用于统计字符串长度
nchar(month.name) # 7 8 5 5 3 4 4 6 9 7 8 8
# 注意length()函数返回的是向量中元素的个数，nchar()返回的是字符串的长度

paste("Hello","world","!") # 将字符向量合并成字符串  "Hello world !"，默认空格分隔，可以选用sep确定分割方式
paste("Hello","world","!",sep="-") # "Hello-world-!"

# 含有向量是分别连接处理
paste(c("I","You","We"),"love","China","!") # "I love China !"   "You love China !" "We love China !" 

# 分割选取字符串
substr("ABCDEFG",start=1,stop=3) # 输出ABC
substr(month.name,1,3) # 输出"Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

toupper(substr(month.name,1,3)) # 大写转化字符串的每一个字母
tolower(substr(month.name,1,3)) # 小写转化字符串的每一个字母
gsub() # 使用正则表达式来更换某个位置字母的大小写
s1<-tolower(substr(month.name,1,3))
gsub("^(\\w)","\\U\\1",tolower(s1),perl=T) # 首字母大写

grep() # 正则函数表达式的匹配
x<-c("b","A+","AD","B+")
grep("A+",x) # 输出结果为2 3
grep("A+",x,fixed=T) # 输出结果为2。类似于which(x=="A+")

 dna_seqs <- c("ATGCGTACG", "CGTATGCCC", "GCTAGCTAA", "ATGGCTAGC", "GCCCGTATA", "atgcgtacg")
grep("ATG",dna_seqs,value=T) # 由此则会返回字符串 "ATGCGTACG" "CGTATGCCC" "ATGGCTAGC"

# match函数同样也能匹配，不过不如grep能支持正则表达式
match("A+",x) # 输出结果为2

# strsplit用于字符串分割
path<-"/user/local/bin/R"
strsplit(path,"/") # 结果按照‘/’分割为 ""      "user"  "local" "bin"   "R"  ，注意结果是列表形式

# outer函数对两个向量的所有元素两两做指定运算，返回一个矩阵
x<-c(1:3)
y<-c("A","B","C")
outer(y,x,FUN=paste)
#   [,1]  [,2]  [,3] 
[1,] "A 1" "A 2" "A 3"
[2,] "B 1" "B 2" "B 3"
[3,] "C 1" "C 2" "C 3"

outer(y,x,FUN=paste,sep="-")
#     [,1]  [,2]  [,3] 
[1,] "A-1" "A-2" "A-3"
[2,] "B-1" "B-2" "B-3"
[3,] "C-1" "C-2" "C-3"

时间序列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# R中的时间序列sunspots，presidents，airmiles
Sys.Date() # 查看当前日期，其类型属于Date
a<-"2026-01-01" # character
as.Date(a,format="%Y-%m-%d") # 转换为Date类型

seq(as.Date("2026-01-01"),as.Date("2026-05-05"),by=8) # 创建系列时间
#[1] "2026-01-01" "2026-01-09" "2026-01-17" "2026-01-25" "2026-02-02" "2026-02-10" "2026-02-18"
#[8] "2026-02-26" "2026-03-06" "2026-03-14" "2026-03-22" "2026-03-30" "2026-04-07" "2026-04-15"
#[15] "2026-04-23" "2026-05-01"

runif(48,min=50,max=100) # runif()函数生成随机数
sales<-round(runif(48,min=50,max=100))
ts(sales,start=c(2025,5),end=c(2026,8),frequency=1) # frequency=1表示按年来算，开始于25年来算的第5个年头，结束于26来算的第8个年头，因此是2029到2033
#Time Series:
Start = 2029 
End = 2033 
Frequency = 1 
[1] 92 62 62 54 62

ts(sales,start=c(2025,5),end=c(2026,8),frequency=4) # frequency=4表示按季度来算，开始于26年第一季度，结束于27年第四季度
#     Qtr1 Qtr2 Qtr3 Qtr4
2026   92   62   62   54
2027   62   87   92   75

ts(sales,start=c(2025,5),end=c(2026,8),frequency=12) # frequency=12表示按月来算，开始于25年5月，结束于26年8月
#     Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
2025                  92  62  62  54  62  87  92  75
2026  69  62  56  69  79  61  72  61  

数据获取

基础数据获取

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 手动输入数据
patientID<-c(1,2,3,4)
admdate<-c("10/15/2009","11/01/2009","10/21/2009","10/28/2009")
age<-c(25,34,28,52)
diabetes<-c("Type1","Type2","Type1","Type1")
status<-c("Poor","Improved","Excellent","Poor")
data<-data.frame(patientID,admdate,age,diabetes,status)
# 构造一个病人信息的数据框

# 文本编辑器输入edit函数
data<-data.frame(patientID=character(),admdate=character(),age=numeric(),diabetes=character(),status=character())
data<-edit(data) # 形成一个可输入编辑框

# 访问数据库读取：RODBC包

读入数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


read.table("table.txt")
# 不在当前工作目录下要使用文件的全路径，如C:/Users/……
read.table("iris.data",sep=",") # 以逗号分割
read.table("iris.data",sep=",",skip=50,nrows=100) # 读取的50到100行的数据
read.table("网址",header=T) # 网址获取文件

# foreign包内有很多读取文件的函数

read.table(gzfile("名.gz")) # 读取压缩包里面的文件
……

写入文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# write函数进行函数的写入，主要处理向量或矩阵这类简单结构
write(rivers,file="rivers.txt")

# write.table函数将数据框、矩阵等表格型数据写入文本文件
write.table(mtcars,file="mtcars.txt",sep=",",row.names=FALSE) # row.name部分用于不写入行名
write.table(mtcars,file="mtcars.csv",sep=",")
write.csv(mtcars,file="mtcars.csv")
write.table(iris,file="mtcars.txt",append=T) # append用于追加到文件后面
write.csv(mtcars,gzfile("mtcars.csv.gz")) # 创建压缩文件

# 存储与读取RDS文件
saveRDS(iris,file="iris.RDS")
readRDS(iris,file="iris.RDS")

# 存储为R.data文件
save(iris,iris3,file="c:/Users/30521/Desktop/iris.Rdata")

# 如需读写excel文件，选取readxl,writexl,openxlsx包来读写，可以不依赖java

数据转换

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


as.matrix(data.frame(state.region,state.x77)) # 将数据框内容全部转化为矩阵格式
x<-state.abb
dim(x)<-c(5,10)
as.factor(x) # 转换为向量类型
as.list(x) # 转换为列表类型

y<-mtcars["Valiant",]
y # 输出 mpg cyl disp  hp drat   wt  qsec vs am gear carb
Valiant 18.1   6  225 105 2.76 3.46 20.22  1  0    3    1
unname(y) # 去除列名，输出Valiant 18.1 6 225 105 2.76 3.46 20.22 1 0 3 1
unlist(y) # 去除行名，输出  
mpg    cyl   disp     hp   drat     wt   qsec     vs     am   gear   carb 18.10  6.00 225.00 105.00  2.76   3.46  20.22   1.00   0.00   3.00   1.00 

cars<-mtcars
cars[c(1:10),c(2:5)] # 数据框取值，取1到10行，2到5列的内容，输出数据框

# sample函数用于无返回抽样
sample(1:100,60) # 抽60个，默认不放回
sample(1:100,60,replace=T) # 抽60个，有放回
# sort函数进行从小到大排序