R数据分析：方法与案例详解--自学笔记

@[TOC] (目录）

第二章 数据结构与基本运算

2.1 数据类型

数值型（numeric）

整数
小数
科学数

字符型（character）

== 夹杂单引号或者双引号之间==“MR”

逻辑型

==只能读取T （TRUE）或 F (FALSE)值

复数型

a+bi

原始型（raw）

以二进制形式保存数据

默认值（missing value）

不可得到（not available）或 缺失值（missing value）时，相关位置可能会被保留并且赋予一个特定的NA
任何NA的运算结果都是NA
is.na()函数用来检测数据是否缺失

2.2 数据对象

向量（vector）

向量赋值

由有相同基本类型元素组成的序列，相当于一维数组
单个向量中的数据要求必须是相同类型，同一向量中无法混杂不同类型的数据

赋值方法：<-;=;->;assign

assign(“w”,c(1,2,3,4,5))
w
[1] 1 2 3 4 5

用c( )构建向量

v<-paste(“x”,1:5,sep="")
v
[1] “x1” “x2” “x3” “x4” “x5”
paste("today is ",date())
[1] “today is Sun Nov 21 10:14:20 2021”
对于字符向量，一个很重要的函数paste（）可以把自变量对应元素连成一个字符串，长度不想相同时，较短的向量会被重复使用

向量运算

对应向量的每个分量做乘法、除法和乘方运算

x<-c(1,3,5,7,9)
c(1,3,5,7,9)->y
x*y
[1] 1 9 25 49 81
x/y
[1] 1 1 1 1 1
x^2
[1] 1 9 25 49 81
y^x
[1] 1 27 3125 823543 387420489

整数除法

5%/%3
[1] 1

求余数

5%%3
[1] 2

向量运算会对该向量的每一个元素进行同样的运算出现在同一个表达式的向量最好统一长度。如果长度不一，则表达式中短的向量会被循环使用，表达式的值将是一个和最长的向量等长的向量。

c(1,3,5)+c(2,4,6,7,10)
[1] 3 7 11 8 13
Warning message:
In c(1, 3, 5) + c(2, 4, 6, 7, 10) : 长的对象长度不是短的对象长度的整倍数

生成有规则序列

R可以产生正规则序列，最简单的是用“：”符号，就可以产生有规律的正规则序列。

(t<-1:10)
[1] 1 2 3 4 5 6 7 8 9 10
(r<-5:1)
[1] 5 4 3 2 1
2*1:5
[1] 2 4 6 8 10
在表达式运算中，：的运算级别最高
在表达式外面套（）的意思是把结果直接打印出来，不套括号则运算结果保存在t对象里
t<-1:10
t
[1] 1 2 3 4 5 6 7 8 9 10

可以用seq（）产生有规律的各种序列seq（from，to，by）

seq(1,10,2)
[1] 1 3 5 7 9
seq(1,10)
[1] 1 2 3 4 5 6 7 8 9 10
seq(10,1,-1)
[1] 10 9 8 7 6 5 4 3 2 1

关注序列的长度

seq(1,2,length=10)
[1] 1.000000 1.111111 1.222222 1.333333 1.444444 1.555556
[7] 1.666667 1.777778 1.888889 2.000000
seq(1,by=2,length=10)
[1] 1 3 5 7 9 11 13 15 17 19

用各种复杂的方式重复一个对象rep（x，times，…）

rep(c(1,3),4)
[1] 1 3 1 3 1 3 1 3
rep(c(1,3),each=4)
[1] 1 1 1 1 3 3 3 3
rep(1:3,rep(2,3)) rep()的嵌套使用里层的rep（1,3）等价于向量（2，2，2）
[1] 1 1 2 2 3 3

向量的常见函数

向量里元素的个数称为向量的长度（length）。长度为1的向量就是常数（或标量）。函数length（）可以返回向量的长度，mode（）可以返回向量的数据类型，min（）返回向量的最小值，range（）返回向量的范围，which.min(）、which.max（）返回在第几个分量求到最小值和最大值。

x<-c(1,2,3,4,5)
length(x)
[1] 5
mode(x)
[1] “numeric”
min(x)
[1] 1
range(x)
[1] 1 5
which.min(x)
[1] 1

内置函数可以直接对向量进行运算：mean（）求均值，median（）求中位数，var（）求方差，sd（）求标准差。

t<-1:10
mean(t)
[1] 5.5
sd(t)
[1] 3.02765
sort（）对向量排序，rev（）将向量按原方向的反方向排列，rank（）给出向量的秩，prod（）求向量的连乘积，append（）为向量添加元素。
y<-c(2,6,7,3,5)
sort(y)
[1] 2 3 5 6 7
rev(y)
[1] 5 3 7 6 2
rank(y)
[1] 1 4 5 2 3
prod(y)
[1] 1260
append(y,10:15,after = 3)
[1] 2 6 7 10 11 12 13 14 15 3 5

向量索引

向量下标运算：取出向量的某一个元素既可以用x[i]得出，也可以通过赋值语句来改变一个或多个元素的值。

x<-c(1,3,5)
x[2]
[1] 3
(c(1,2,3)+4)[2]
[1] 6
x[2]<-10
x
[1] 1 10 5
x[c(1,3)]<-c(9,11)
x
[1] 9 10 11

对向量进行逻辑运算

x<-c(1,3,5)
x<4
[1] TRUE TRUE FALSE
x[x<4]
[1] 1 3
z<-c(-1,1:3,NA)
z
[1] -1 1 2 3 NA
z[is.na(z)]<-0
z
[1] -1 1 2 3 0
z<-c(-1,1:3,NA)
y<-z[!is.na(z)]
y
[1] -1 1 2 3

对分段函数的定义上

x<-c(-3,-2,-1,0,5,7)
y<-numeric(length(x)) #生成与x向量长度相同的数值型向量
y
[1] 0 0 0 0 0 0
y[x<0]<-1-x[x<0]
y
[1] 4 3 2 0 0 0
y[x>=0]<-1+x[x>=0]
y
[1] 4 3 2 1 6 8

如果下标取的是负整数，则表示删除相应位置的元素

x<-1:10
x[-(1:5)]
[1] 6 7 8 9 10

矩阵

将数据用行和列排列的长方形表格，是二维数组，其单元必须是相同的数据类型。通常用列来表示通的变量，用行表示各个对象。
matrix（data=NA,nrow=1,ncol=1,byrow=FALSE, dimnames=NULL）

matrix(1:12,nrow=4,ncol=3)
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
matrix(1:12,nrow=4,ncol=3,byrow=T)
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
[4,] 10 11 12
假定A为一个m*n矩阵，则A的转置可以用函数t（）来计算。
类似的若将函数t（）作用于一个向量x，则当做x为列向量，返回结果为一个行向量；若想得到一个列向量，可用t（t（x））
(A<-matrix(1:12,nrow=4,ncol=3))
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
t(A)
[,1] [,2] [,3] [,4]
[1,] 1 2 3 4
[2,] 5 6 7 8
[3,] 9 10 11 12

矩阵计算

A<-B<-matrix(1:12,nrow=3)
A+B
[,1] [,2] [,3] [,4]
[1,] 2 8 14 20
[2,] 4 10 16 22
[3,] 6 12 18 24
3*A
[,1] [,2] [,3] [,4]
[1,] 3 12 21 30
[2,] 6 15 24 33
[3,] 9 18 27 36

B<-t(A)
A%*%B
[,1] [,2] [,3]
[1,] 166 188 210
[2,] 188 214 240
[3,] 210 240 270

取一个方阵的对角元素

A<-matrix(1:16,nrow=4)
diag(A)
[1] 1 6 11 16
diag(diag(A)) 对向量应用
[,1] [,2] [,3] [,4]
[1,] 1 0 0 0
[2,] 0 6 0 0
[3,] 0 0 11 0
[4,] 0 0 0 16
diag(3)
[,1] [,2] [,3]
[1,] 1 0 0
[2,] 0 1 0
[3,] 0 0 1

求逆

(A<-matrix(rnorm(16),4,4))
[,1] [,2] [,3] [,4]
[1,] 0.6301784 2.4225384 0.5726452 -0.03666071
[2,] -0.5308961 -0.1890815 0.8882178 0.25320483
[3,] -0.3427778 0.1166931 0.1330065 -2.33152019
[4,] 1.0215506 1.0354465 -1.2353513 2.08501209
solve(A)
[,1] [,2] [,3] [,4]
[1,] 1.04091346 -4.1951340 -3.02955246 -2.8599709
[2,] -0.01396465 1.3982578 1.15670814 1.1234135
[3,] 0.65240603 -1.2592565 -1.56038581 -1.5804721
[4,] -0.11651514 0.6149107 -0.01462486 0.3865359

数组

既可以看做是带有多个下标的且类型相同的元素的集合，也可以看做是向量和矩阵的推广，一维数组就是向量，二维数组就是矩阵。
array（data=NA,dim=length(data）,dimnames=NULL)

(xx<-array(1:24,c(3,4,2)))
, , 1

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

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

, , 2

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

[1,] 13 16 19 22
[2,] 14 17 20 23
[3,] 15 18 21 24

xx[2,3,2]
[1] 20
xx[2,1:3,2]
[1] 14 17 20
xx[,2,]
[,1] [,2]
[1,] 4 16
[2,] 5 17
[3,] 6 18
dim(xx)
[1] 3 4 2

dim()可以用来将向量换成数组或矩阵

zz=c(2,5,6,8,1,4,6,9,10,7,3,5)
dim(zz)=c(2,2,3)
zz
, , 1

 [,1] [,2]

[1,] 2 6
[2,] 5 8

, , 2

 [,1] [,2]

[1,] 1 6
[2,] 4 9

, , 3

 [,1] [,2]

[1,] 10 3
[2,] 7 5

因子

分类型数据经常要把数据分成不同的水平或因子，如学生的性别包含男和女两个因子。因子代表变量的不同可能水平（即使在数据中不出现），在统计分析中十分有用。
factor（x=character（），levels，labels=levels，exclude=NA，ordered=is.ordered（x））

y<-c(“女”,“男”,“男”,“女”,“女”,“女”,“男”)
(f<-factor(y))
[1] \u5973 \u7537 \u7537 \u5973 \u5973 \u5973 \u7537
Levels: \u7537 \u5973

score<-c(“B”,“C”,“D”,“B”,“A”,“D”,“A”)
(score_o<-ordered(score,levels=c(“D”,“C”,“B”,“A”)))
[1] B C D B A D A
Levels: D < C < B < A

列表

如果一个数据对象需要含有不同的数据类型，则可以采用列表。列表中包含的对象又称为它的分量，分量可以是不同的模式或类型，如一个列表可以包含数值向量、逻辑向量、矩阵、字符和数组等。
list（变量1=分量1，变量2=分量2，…）

x<-c(1,1,2,2,3,3,3)
y<-c(“女”,“男”,“男”,“女”,“女”,“女”,“男”)
z<-c(80,85,92,76,61,95,83)
(LST<-list(class=x,sex=y,score=z))
$class
[1] 1 1 2 2 3 3 3

$sex
[1] “\u5973” “\u7537” “\u7537” “\u5973” “\u5973” “\u5973”
[7] “\u7537”

$score
[1] 80 85 92 76 61 95 83
==注意LST[[]]和LST[]的差别

LST[[3]]
[1] 80 85 92 76 61 95 83
LST[[2]][1:3]
[1] “\u5973” “\u7537” “\u7537”

LST$score[1]80859276619583LST$sc
[1] 80 85 92 76 61 95 83

函数length（）、mode（）、names（）可以返回列表的长度（分量的书目）、数据类型和列表里成分的名字。

数据框

数据库是一种矩阵形式的数据，但数据框中各列可以是不同类型的数据。数据框每列是一个变量，每行是一个观测。数据框既可以看做是矩阵的推广，也可以看做是一种特殊的列表对象。

data.frame(…, row.names=NULL, check.rows=FALSE,…)

(student<-data.frame(x,y,z))
x y z
1 1 \u5973 80
2 1 \u7537 85
3 2 \u7537 92
4 2 \u5973 76
5 3 \u5973 61
6 3 \u5973 95
7 3 \u7537 83
(student<-data.frame(class=x,sex=y,score=z)) #对列进行重新命名
class sex score
1 1 \u5973 80
2 1 \u7537 85
3 2 \u7537 92
4 2 \u5973 76
5 3 \u5973 61
6 3 \u5973 95
7 3 \u7537 83
row.names(student)<-c(“王”,“张”,“赵”,“刘”,“黄”,“孙”,“李”) #对行进行重新命名
student
class sex score
\u738b 1 \u5973 80
\u5f20 1 \u7537 85
\u8d75 2 \u7537 92
\u5218 2 \u5973 76
\u9ec4 3 \u5973 61
\u5b59 3 \u5973 95
\u674e 3 \u7537 83

以数组形式访问

student[, “score”]
[1] 80 85 92 76 61 95 83
student[,3]
[1] 80 85 92 76 61 95 83
student[1:5,1:3]
class sex score
\u738b 1 \u5973 80
\u5f20 1 \u7537 85
\u8d75 2 \u7537 92
\u5218 2 \u5973 76
\u9ec4 3 \u5973 61

以列表形式访问数据框

student$score[1]80859276619583student[["score"]][1]80859276619583student[[3]][1]80859276619583student[student$score>80,]
class sex score
\u5f20 1 \u7537 85
\u8d75 2 \u7537 92
\u5b59 3 \u5973 95
\u674e 3 \u7537 83

数据框绑定attach（）函数

数据框的主要用途是保存统计建模的数据。在使用数据框的变量时可以使用“数据框名$变量名的记法”。但是这样较为麻烦，attach（）函数可以把数据框中的变量“链接”到内存中，将数据框“绑定”入当前的名字空间，从而可以直接用数据中的变量名访问。

第三章 函数与优化

3.2条件控制语句

if/else语句

if（cond）statement-1
if（cond）statement-1 else statement-2

x<-1.5
if(x>2) y=2x else y=3x
y
[1] 4.5
x<-3
if(x>2) y=2x else y=3x
y
[1] 6

ifelse语句

ifelse（cond，statement1，statement2）

x<-1
ifelse(x>2,y<-2x,y<-3x)
[1] 3

switch语句

switch（statement，list）
如果表达式的返回值在1到length（list）之间，则返回列表相应位置的值

switch(1,23,sd(1:5),runif(3)) #返回23,sd(1:5),runif(3)list中的第一个成分
[1] 6
switch(2,23,sd(1:5),runif(3)) #返回第二个成分
[1] 1.581139
switch(3,23,sd(1:5),runif(3))
[1] 0.7357111 0.8724102 0.2977454
当list是有名定义，statement等于变量名时，返回变量名对应的值；否则返回NULL值。
x<-“meat”
switch(x,meat=“chicken”,fruit=“apple”,vegetable=“potato”)
[1] “chicken”

3.3循环语句

for循环

for （ind in expr-1）expr-2

Fibonacci<-NULL
Fibonacci[1]<-Fibonacci[2]<-1
n=16
for (i in 3:n) Fibonacci[i]<-Fibonacci[i-2]+Fibonacci[i-1]
Fibonacci
[1] 1 1 2 3 5 8 13 21 34 55 89 144 233 377
[15] 610 987

while

while（condition）expr

Fibonacci[1]<-Fibonacci[2]<-1
i<-1
while (Fibonacci[i]+Fibonacci[i+1]<1000) {

•    Fibonacci[i+2]<-Fibonacci[i]+Fibonacci[i+1]
  

•    i<-i+1     }
  

Fibonacci
[1] 1 1 2 3 5 8 13 21 34 55 89 144 233 377
[15] 610 987

repeat语句

repeat expr
repeat循环依赖break语句跳出循环

Fibonacci[1]<-Fibonacci[2]<-1
i<-1
repeat {Fibonacci[i+2]<-Fibonacci[i]+Fibonacci[i+1]

•     i<-i+1
  

•     if (Fibonacci[i]+Fibonacci[i+1]>=1000) break}
  

Fibonacci
[1] 1 1 2 3 5 8 13 21 34 55 89 144 233 377
[15] 610 987

编写自己的函数

函数名=function（参数1，参数2…）
{
stataments
return(object)
}

函数名

函数名可以是任何值，但以前定义过的要小心使用，后来定义的函数会覆盖原先定义的函数。一旦你定义了函数名，就可以像使用R的其他函数一样使用它。

std=function(x) sqrt(var(x))
x=c(1,3,5,7,9)
std(x)
[1] 3.162278
std
function(x) sqrt(var(x))

关键词function

告诉R这个新的数据对象是函数

参数

1无参数：有时编写参数只是为了方便，函数每次返回值都是一样的，其输入不是那么重要。

welcome=function() print(“welcome to use R”)
welcome()
[1] “welcome to use R”

2单参数：假如要使你的函数个性化，则可以使用单参数，函数会根据参数的不同，返回值也不同。

welcome.sb=function(names) print(paste(“welcome”, names,“to use R”))
welcome.sb(“Mr fang”)
[1] “welcome Mr fang to use R”

3默认参数：即不输入任何参数

welcome.sb=function(names=“Mr fang”) print(paste(“welcome”, names,“to use R”))
welcome.sb()
[1] “welcome Mr fang to use R”

sim.t=function(n) {

• mu=10;sigma=5;
• x=rnorm(n,mu,sigma)
• (mean(x)-mu)/(sd(x)/sqrt(n))
• }

sim.t(5)
[1] 0.8751291

sim.t=function(n,mu=10,sigma=5) {

• x=rnorm(n,mu,sigma)
• (mean(x)-mu)/(sd(x)/sqrt(n))
• }

sim.t(5)
[1] 0.4513926
sim.t(5,0,1)
[1] -0.7608016
sim.t(5,4)
[1] -0.5832039
sim.t(5,sigma = 100)
[1] 1.175098
sim.t(5,sigma=100,mu=1)
[1] -0.6865917

R语言允许定义一个变量，然后将变量值传递给R的内置函数。这在作图上非常有用。比如编写一个画图函数，允许先定义一个变量x，再用这个变量生成y变量，然后描出他们的图像。

plot.f=function(f,a,b,…){

• xvals=seq(a,b,length=100)
• plot(xvals,f(xvals),…)
• }

plot.f(sin,0,2pi)
curve(sin,0,2pi)
plot.f(exp,-1,1)
plot.f(log,0,1)

函数体和函数返回值

my.averange=function(x) sum(x)/length(x)
my.averange(c(1,2,3))
[1] 2

当函数体的表达式超过一个时，要用{}封起来
可以用return（）返回函数需要的结果，当需要返回多个结果时，一般建议用list形式返回。

vms=function(x) {

• xx=rev(sort(x))
• xx=xx[1:5]
• mean(xx)
• return(list(xbar=mean(xx),top5=xx))
• }

y=c(5,15,32,25,26,28,65,48,3,37,45,54,23,44)
vms(y)
$xbar
[1] 51.2

$top5
[1] 65 54 48 45 44

程序调试

程序运行时间与效率

用R做优化求解

一元函数优化求解

f=function(x) log(x)-x^2
curve(f,xlim = c(0,2))
optimize(f,c(0.1,10),tol=0.0001,maximum = T)
$maximum
[1] 0.7071232

$objective
[1] -0.8465736

第四章 随机数与抽样模拟

4.1一元随机数的产生

均匀分布随机数

runif（n，min，max=1）

runif(3,1,3)
[1] 1.679771 2.910882 2.381824
runif(5) # 默认生成5个【0,1】上的均匀分布随机数
[1] 0.9988105 0.6044897 0.5033955 0.4804998 0.4007253

检验runif（）生成的随机数的性质，通过直方图和散点图以及自相关系数图来检验独立同分布。

x=runif(Nsim)
x1=x[-Nsim] #因为要求自相关系数，去掉最后一个数
x2=x[-1] #去掉第一个数
par(mfrow=c(1,3))
hist(x,prob=T,col=gray(0.3),main=“uniform on [0,1]”)
curve(dunif(x,0,1),add=T,col=“red”)
plot(x1,x2,col=“red”)
acf(x) #画自相关系数图

正态分布随机数

rnorm（n，mean=0，sd=1）

rnorm(5,10,5)
[1] -4.586236 7.835159 9.310051 16.012151 8.246510
rnorm(5)
[1] 0.3259324 0.9488270 -1.5844309 -0.8577230
[5] -1.4327578

x=rnorm(100)
hist(x,prob=T,main=“nomal mu=0,sigma=1”)
curve(dnorm(x),add=T)

指数分布随机数

rexp（n，lamda=1）

x=rexp(100,1/10)
hist(x,prob=T,col=gray(0.9),main=“均值为10的指数分布随机数”)
curve(dexp(x,1/10),add=T)

离散分布随机数的生成

rbinom(10,size,p)
[1] 0 0 1 1 1 0 1 1 1 1

size=10;p=0.5
rbinom(5,size,p)
[1] 3 4 3 6 6

par(mfrow=c(1,3))
p=0.25
for (n in c(10,20,50))

• {x=rbinom(100,n,p)
• hist(x,prob=T,main=paste(“n=”,n))
• xvals=0:n
• points(xvals,dbinom(xvals,n,p),type=“h”,lwd=3)
• }

par(mfrow=c(1,1))

4.2多元随机数的生成

4.3随机抽样

放回与无放回抽样

R可以进行有放回、无放回抽样。
sample（x，n，replace=F，prob=NULL）
x表示总体向量，可以是数值、字符、逻辑向量，n表示样本容量，replace=F表示无放回的抽样（默认），prob可以设置各个抽样单元不同的入样概率，进行不等概率抽样。

sample(1:6,10,rep=T)
[1] 3 4 5 5 4 4 5 2 4 6
sample(c(“H”,“T”),10,rep=T)
[1] “T” “T” “T” “H” “H” “T” “T” “H” “T” “H”

sample(1:6,10,rep=T)
[1] 5 1 4 3 3 1 5 4 3 6
dice=as.vector(outer(1:6,1:6,paste))
sample(dice,5,replace=T)
[1] “5 4” “4 2” “5 5” “2 1” “2 6”
dice=as.vector(outer(1:6,1:6,paste))
dice
[1] “1 1” “2 1” “3 1” “4 1” “5 1” “6 1” “1 2” “2 2”
[9] “3 2” “4 2” “5 2” “6 2” “1 3” “2 3” “3 3” “4 3”
[17] “5 3” “6 3” “1 4” “2 4” “3 4” “4 4” “5 4” “6 4”
[25] “1 5” “2 5” “3 5” “4 5” “5 5” “6 5” “1 6” “2 6”
[33] “3 6” “4 6” “5 6” “6 6”

bootstrap重抽样

属于重复抽样（Resampling）方法。它是以原始数据为基础的模拟抽样统计推断法，其基本思想是;在原始数据的范围内做有放回的再抽样，样本量仍为n，原始数据中每个观察单位每次被抽到的概率相等，为1/n。

faithful
eruptions waiting
1 3.600 79
2 1.800 54
attach(faithful)
sample(eruptions,10,replace=T)
[1] 2.000 4.000 4.483 1.833 1.750 2.000 1.800 3.850 2.083 2.217

Sample=sample(eruptions,1000,rep=T)
par(mfrow=c(1,2))
hist(eruptions,breaks = 25)
hist(Sample,breaks = 25)
par(mfrow=c(1,1))

4.4统计模拟

几种常见的模拟方法

第五章 数据读写与预处理

5.1数据的读入

直接输入数据

1.c（）函数
把各个值连成一个向量或列表，可以形成数值型向量、字符型向量或者其他类型向量

2.scan（）函数
类似c（）函数，是一种键盘输入数据函数，当输入scan（）并按回车键后，将等待输入数据，数据之间只用空格分开即可（c（）函数要用逗号分开）。输入完成后，再次按回车键，这是数据录入完毕。

x=scan()
1: 1 2 3 4 5 6
7:
Read 6 items

还可以读入外部文本文件
x=scan(file=“dat.txt”)
如果原文件的数据之间有逗号等分隔符，则用scan（）函数读入时应该去掉这些分隔符：
x=scan(file=“dat.txt”, sep=",")

读R包中的数据

在RStudio中，虽然可以直接查看、读取和修改数据，但有一些操作还是需要使用命令来运行。例如，查看当前环境下的数据ls（）、删除数据rm（）、查看所有预先提供的数据data（）、查看某个包所有预先提供的数据data（package=“”）或读入数据data（datasetname）。
如果需要从其他的软件包链接数据，则可以使用参数package。

data(package=“SemiPar”) #查看包的信息
data(copper,package=“SemiPar”) #查看包里的某个数据

从外部文件读入数据

1.读入文本文件
read.table(file,header = logical_value,sep=“delimiter”,row.names = “name”)

2.读入Excel数据
对于一般常用的xls、xlsx数据表，由于该格式较为复杂，因此应尽量避免直接导入。通常的处理办法是将xls数据表转为CSV文件。
read.csv(“file=file.name”,header=TRUE,sep=",",…)

s2=read.csv(file=“student-1.csv”)
s2
class sex score
1 1 女 80
2 1 男 85
3 2 男 92
4 2 女 76
5 3 女 61
6 3 女 95
7 3 男 83

3.读入其他数据格式
library(foreign)
①sas数据
对于sas，R只能读入sas transport format（XPORT）文件。所以，需要把普通的sas数据文件（.ssd和.sas7bdat）转换为transport format（XPORT）文件，再用命令read.xport().
read.xport(“dataname.xpt”)
②spss数据
read.spss()可读入spss数据文件。
==read.spss(“dataname.sav”)==或
install.packages(“Hmmisc”)
library(Hmmisc)
mydataframe<-spss.get(“dataname.sav”,use.value.labels=TRUE)
③Epi info数据
R可读入epi5和6的数据库。
read.epiinfo(“文件名.rec”)
给数据集起一个名称：read.epiinfo(“d:/ttt.rec”)->ttt
④stata数据
R可读入stata5，7和6的数据库。
read.dta(“文件名.dta”)

读入数据文件后，使用数据集名$变量名，既可以使用各个变量。mean（data$age）
便是计算数据集data中变量age的均数。

5.2写出数据

write(x,file=“data”,ncolumns=if(is.character(x)) 1 else 5,append=FALSE,sep=" ")
write.table(x,file=" “,append=FALSE,quote=TRUE,sep=” “,eol=”\n",na=“NA”,dec=".",row.names=TRUE,col.names=TRUE,qmethod=c(“escape”,“double”),fileEncoding=" ")
write.csv()

5.3数据预处理

变量预处理

1创建新变量
var_names=expr
读入数据

cons<-c(5000,5800,6000,10200,8500)
pop<-c(2000,3600,3500,5020,6100)
gnp<-c(6000,7200,7400,11000,9200)

直接进行变换

pgnp<-gnp/pop
psave<-(gnp-cons)/pop

用transform（）函数进行变换。
> data<-data.frame(gnp,cons,pop)

transform(data,pgnp=gnp/pop,psave=(gnp-cons)/pop )
gnp cons pop pgnp psave
1 6000 5000 2000 3.000000 0.5000000
2 7200 5800 3600 2.000000 0.3888889
3 7400 6000 3500 2.114286 0.4000000
4 11000 10200 5020 2.191235 0.1593625
5 9200 8500 6100 1.