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数据集的前两行

 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函数进行从小到大排序