1.R语言入门操作
1.R语言入门操作
1.1、目的
- 掌握R语言的基本操作
- 掌握R语言的基本运算
- 掌握R语言存取数据的办法
1.2、使用
如果是虚拟机环境：首先打开终端：输入R进入R环境
如果是windows环境：点击对应的客户端软件即可
cd ~
R
1.2.1 赋值操作
1.2.1.1 数值赋值
a <- 100
a
结果为：[1] 100
或者
b = 100
b
结果为：[1] 100
还可以
100 -> c
c
结果为：[1] 100
以上语句的作用是将100赋值给a变量，其中“<-”、“->”、“=”都是R中的赋值的符号。除此之外，在R中，还可以作用函数assign()来给变量赋值，例如：
(assign("x",100))
结果为：[1] 100
其中，最外层的括号的作用是为了显示变量x的值；命令中的双引号必须在英文状态下输入；在R中，是区分大小写的。
我们可以用函数ls()来查看当前工作空间中的变量：
ls()
结果为：[1] “a” “b” “c” “x”
1.2.1.2 向量赋值
在R语言中，生成向量的方法很多，最简单的方法就是使用连接函数c()来生成。例如：把数据 12.1 11.9 12.0 12.3 11.8 赋值给变量x，可以输入命令：
x <- c(12.1,11.9,12.0,12.3,11.8)
x
[1] 12.1 11.9 12.0 12.3 11.8
函数c()不但可以连接数值，还可以连接已有的向量，例如，当输入命令：
y <- c(x,1,x)
y
结果为： [1] 12.1 11.9 12.0 12.3 11.8 1.0 12.1 11.9 12.0 12.3 11.8
如果要生成有一定规律的向量，则要用到R中的相应函数。
（1）步长为1的等差数列构成的向量
用符号“:”可以产生步为1的等差数列，其使用格式为：a:b，表示起始值为a，步长为1，终止值为b的等差数列，若b不在首项为a步长1的数列里，则产生的数列的末项为小于b的最大值，比较以下命令:
(a <- 1:10)
结果为： [1] 1 2 3 4 5 6 7 8 9 10
(b <- 1.1:10)
结果为：[1] 1.1 2.1 3.1 4.1 5.1 6.1 7.1 8.1 9.1
(c <- 10:1)
结果为： [1] 10 9 8 7 6 5 4 3 2 1
在这里，符号“:”的作用与matlab中的作用相同，但要注意的是，该符号并不能指定数列的步长，如果要产生指定步长的等差数列，则要用函数seq()。
（2）任意步长的等差数列构成的向量
如果要生成任意步长的等差数列，可以用函数seq(),其基本语法如下：
seq(from = 1, to = 1, by = ((to - from)/(length - 1)),length.out = NULL, along.with = NULL, ...)
参数说明：
from： 数值，表示数列的起始值，默认值为1
to： 数值，表示数列的终止值，默认值为1
by： 数值，指定数列的步长
length.out： 数值，指定数列的长度
along.with： 向量，表示产生的数列与该向量具有相同的长度
注1.参数by，length.out，along.with这三个参数只能选一项
注2.当参数to指定的终止值不在以from为起始值，以by指定的步长的数列中的值时，所产生的数列终止值为不超过to的最大值。在R中输入以下命令，观察其结果。
seq(1,10)#默认的步长是1
结果为： [1] 1 2 3 4 5 6 7 8 9 10
seq(10)#默认的起始值为1，步长为1
结果为： [1] 1 2 3 4 5 6 7 8 9 10
seq(2,10,by = 2)
结果为： [1] 2 4 6 8 10
seq(1,10,length.out = 5)#向量的维数指定为5
结果为： [1] 1.00 3.25 5.50 7.75 10.00
seq(1,10,along.with = c(1,3,5))#向量的维数与向量(1,3,5)的维数相同
结果为： [1] 1.0 5.5 10.0
（3）使用重复函数
重复函数rep()的作用是将变量或是向量复制若干次，函数的调用格式：
rep(x,...)
x： 数值、向量或是数据对象，是要复制的对象
… 是可选的一些参数，包括
times： 表示x被复制的次数
length.out： 表示复制后输出的向量长度
each： 表示x中每个分量被复制的次数
正整数构成的向量：长度与x一致，其分量表示x的对应分量被复制的次数
在R中输入以下命令，观察其效果。
x = 1:4
rep(x,times = 2)
结果为：[1] 1 2 3 4 1 2 3 4
rep(x,length.out = 10)
结果为： [1] 1 2 3 4 1 2 3 4 1 2
rep(x,each = 2)
结果为：[1] 1 1 2 2 3 3 4 4
rep(x,c(1:4))
结果为： [1] 1 2 2 3 3 3 4 4 4 4
对于已构建的向量x，如果想要查看向量x中的元素，可以输入x[i]，其中的索引i可以是数字，也可以是向量，输入以下命令，观察其效果。
x <-1:10
x[1]
结果为：[1] 1
x[1:3]
结果为：[1] 1 2 3
x[c(1,4,7)]
结果为：[1] 1 4 7
注1.在R中引用向量时，用的是[]，而matlab等编程语言中用的是()，不要混淆。
注2.在R 中向量的下标是从1开始的，而C等编程语言是从0开始的，不要混淆。
1.2.1.3 删除和修改元素
如果要删除向量x中的元素，可以输入x[-i]，其中索引i可以是数字，也可以是向量，输入以下命令，观察其效果。
x<-1:10
x[-3]
结果为：[1] 1 2 4 5 6 7 8 9 10
x[-(1:4)]
结果为：[1] 5 6 7 8 9 10
x[-c(3,6,9)]
结果为：[1] 1 2 4 5 7 8 10
注意，以上操作并未真正从变量x中删除掉相应的元素，要达到删除的目的，可以把以上操作的结果赋值给其他变量。如果要修改向量中的某些元素，可以直接给相应的分量赋值，输入以下命令，观察其结果。
x[3] <- 18
x
结果为： [1] 1 2 18 4 5 6 7 8 9 10
x[1:3]<-c(10,20,30)
x
结果为： [1] 10 20 30 4 5 6 7 8 9 10**
**
x[c(3,6,9)]<-c(12,24,36)
x
结果为： [1] 10 20 12 4 5 24 7 8 36 10
1.2.2 算术操作
R语言提供了方便的算术运算的操作，包括+、-、*、/等，这些与matlab的运算含义完全一样，都可以对向量进行运算。下面是一些R中特有的运算：
（1）求余：%%
如：
9%%4
结果为：[1] 1
(1:10)%%2
结果为： [1] 1 0 1 0 1 0 1 0 1 0
（2）求商：%/%
如：
9%/%4
结果为：[1] 2
(1:10)%/%2
结果为： [1] 0 1 1 2 2 3 3 4 4 5
（3）乘方：^
如：
2^3
结果为：[1] 8
(1:10)^3
结果为： [1] 1 8 27 64 125 216 343 512 729 1000
（4）开方：sqrt()
如：
sqrt(9)
结果为：[1] 3
sqrt(1:10)
结果为： [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427
[9] 3.000000 3.162278
注：函数sqrt()只能是在实数范围内开平方，如果输入的参数是负数，则会输出NaN（NaN是Not a Number 的缩写，表示不确定），并提示警告信息。输入以下命令，观察其结果。
sqrt(-9)
结果为：NaN
Warning message:
In sqrt(-9) : NaNs produced
（5）对数及以e为底的指数：log()；log2()；log10()；exp()；
①log()有两个参数，一个为x，一个是base，即底数。如果要求以2为底数，16的对数，可以如下操作：
log(16,2)
结果为：[1] 4
或者
log(x = 16,base = 2)
结果为：[1] 4
log(x = c(2,4,8,16),base = 2)
结果为：[1] 1 2 3 4
②log2()和log10()均只有一个参数，即x，他们分别是以2为底和以10为底取对数。
③exp()是计算以e为底的指数，只有一个参数x，其作用是计算e^x如：
exp(1)
结果为：[1] 2.718282
exp(1:3)
结果为：[1] 2.718282 7.389056 20.085537
在R语言中，可以完成各种初等函数的运算，如对数、指数、三角函数和反三角函数以及其他的运算，表1.1列出了R语言中常用的函数。
表1.1 R语言中的数学函数
| sqrt | 开平方函数 |
|---|---|
| abs | 绝对值函数 |
| exp | 2.71828… |
| expm1 | 当x的绝对值比1小很多的时候，能更加正确的计算exp(x)-1 |
| log | 对数函数 |
| log10 | 对数（底为10）函数 |
| log2 | 对数（底为2）函数 |
| sin | 正弦函数 |
| cos | 余弦函数 |
| tan | 正切函数 |
| asin | 反正弦函数 |
| acos | 反余弦函数 |
| atan | 反正切函数 |
| sinh | 双曲正弦函数 |
| cosh | 双曲余弦函数 |
| tanh | 双曲正切函数 |
| asinh | 反双曲正弦函数 |
| acosh | 反双曲余弦函数 |
| atanh | 反双曲正切函数 |
| logb | 和log函数一样 |
| log1px | 当x的绝对值比1小很多的时候，能更加正确的计算log(1+x) |
| gamma | r函数（伽马函数） |
| lgamma | 等同于log(gamma(x)) |
| ceiling | 返回大于或等于所给数字表达式的最小整数 |
| floor | 返回小于或等于所给数字表达式的最大整数 |
| trunc | 截取整数部分 |
| round | 四舍五入 |
| signif(x,a) | 数据截取函数，x:有效为，a:到a位为止 |
1.2.3 比较运算符及逻辑操作
除了以上的四则运算和函数运算之外，各向量之间还可以进行比较运算，其返回值为真(TRUE)或假(FALSE)，比较运算符包括：
> 大于；>= 大于等于； < 小于； <= 小于等于； == 等于； != 不等于。
如：
3 == 5
结果为：FALSE
需要注意的是，当进行比较运算的两个向量的长度不一样长时，R会将向量补齐，然后再进行比较，输入以下命令，观察其运行结果。
a<-1:10
b=c(1,3,5)
a==b
结果为： [1] TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
Warning message:
In a == b : longer object length is not a multiple of shorter object length
其补齐的方式是：较短的向量自我复制，直到与较长的向量的长度一致；当较长向量的长度不是较短向量长度的整数倍时，会返回警告信息，但这不会影响运算的结果。在上例中，向量b自我复制的结果是：
b<-c(1,3,5,1,3,5,1,3,5,1)
逻辑操作的对象是逻辑值，在R语言的逻辑操作包括以下几项：
（1）！
感叹号表示“取非”。
x<-TRUE
!x
结果为：[1] FALSE
又如：
x<-c(T,T,F,T,F)
!x
结果为：[1] FALSE FALSE TRUE FALSE TRUE
（2）&和&&
这两者都是逻辑“与”，操作都是x&y和x&&y。
如：
x<-c(T,T,F)
y<-c(F,T,F)
x&&y
结果为：[1] FALSE
x&y
结果为：[1] FALSE TRUE FALSE
可以看到，&是对每一个元素一一求与，而&&是所有元素求与操作。
（3）|和||
这两者的使用与前者类似：
x<-c(T,T,F)
y<-c(F,T,F)
x|y
结果为：[1] TRUE TRUE FALSE
x||y
结果为：[1] TRUE
（4）异或操作xor()
xor()为异或操作函数，当两个数值相等时，结果为假；当两个数值不等时，结果为真，如：
xor(0,1)
结果为：[1] TRUE
x<-c(T,T,F)
y<-c(F,T,F)
xor(x,y)
结果为：[1] TRUE FALSE FALSE
（5）all()和any()
判断数据中是否存在TRUE值，其中all()是在全部为TRUE时返回TRUE，any()是在存在任何一个TRUE时返回TRUE，他们都还有另外一个参数，即是否删除NA值，即 not available 值：na.rm,其调用格式为：
all(x,na.rm = F)
any(x,na.rm = F)
当na.rm = F时，在逻辑操作过程中不考虑x中的NA值；否则，在进行逻辑操作过程中考虑x中的NA值。在R中输入以下命令，观察其运行的效果。
x <- c(1,3,5,7,9,NA)
all(x>5,na.rm=T)
结果为：[1] FALSE
any(x>5,na.rm=F)
结果为：[1] TRUE
另外，如果想判断一个逻辑向量中哪些元素为真，可以用函数which()，如
which(x>5)
结果为：[1] 4 5
若要构造一个初始逻辑向量，可以用函数logical()，如
logical(5)
结果为：[1] FALSE FALSE FALSE FALSE FALSE
1.2.4 R语言的数据结构
1.2.4.1 数组（向量和矩阵）
数组是带有多个下标的且类型相同的元素构成的集合，可以看成是向量和矩阵的推广，可用来储存数值型（numeric）、逻辑型（logical）和字符型（character）三种类型的数据。可以使用函数array()来生成一个数组，其调用格式为：
array(data = NA,dim = length(data),dimnames = NULL)
其中：
data： 保存到数组的数据，可以是控制
dim： 指定数组的维数
dimnames： 指定数组个维度的名称，默认为整数
(x<-array(1:12,dim=c(3,4)))#数值型
结果为： [,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
x=array(rep(T,6),dim=c(2,3))#逻辑型
x
结果为： [,1] [,2] [,3]
[1,] TRUE TRUE TRUE
[2,] TRUE TRUE TRUE
x=array(rep("a",6),dim=c(2,3))#字符型
x
结果为： [,1] [,2] [,3]
[1,] “a” “a” “a”
[2,] “a” “a” “a”
以下的例子展示了如何修改各维度的名称，输入以下命令，观察其运行的效果。
x = array(rpois(6,10),dim=c(2,3),dimnames=list(c("male","female"),c("apple","banana","pear")));x
结果为： apple banana pear
male 11 13 9
female 8 2 11
这里，我们使用了rpois()来产生了6个符合泊松分布的数字。
当然，我们的数组不局限于二维，可以是三维或者更多维。
x = array(rpois(24,10),dim=c(2,3,4),dimnames=list(c("male","female"),c("apple","banana","pear"),c("Mon","Tue","Wed","Thu")));x
结果为：
, , Mon
apple banana pear
male 10 11 9
female 8 9 9
, , Tue
apple banana pear
male 7 12 9
female 7 15 7
, , Wed
apple banana pear
male 14 13 13
female 9 6 10
, , Thu
apple banana pear
male 9 11 7
female 13 15 6
上面的例子是一个三维的数组。我们继续来看这个dimnames。
dimnames这个参数是用来指定有关的每一个维度的名字的，其中第一个维度的两行分别为male和female，第二个维度的两个分别为apple，banana，pear。
需要注意的是，一维数组跟向量很相近，二维数组就是矩阵。但是一维数组跟向量在某些函数的处理过程中会有区别的对待，如str()函数：
x = array(rpois(2,10),dim=c(1,2),dimnames=list(c("apple"),c("male","female")))
str(x)
结果为： int [1, 1:2] 8 10
- attr(*, “dimnames”)=List of 2
…$ : chr “apple”
…$ : chr [1:2] “male” “female”
在这里我们用到了函数list()，其作用是生成一个列表，在后面我们会做详细的介绍。对于数组的引用，可用A[i,j,…]，输入以下命令，观察其运行效果。
A<-array(data=1:36,dim=c(3,3,4))#产生3*3*4维的数组
A[1,2,3]#引用第3层的第1行第2列的元素
结果为：[1] 22
A[1,c(1,2),3]
结果为[1] 19 22
A[1,,3]
结果为：[1] 19 22 25
A[1,,]
结果为： [,1] [,2] [,3] [,4]
[1,] 1 10 19 28
[2,] 4 13 22 31
[3,] 7 16 25 34
下面来看看如何定义向量和矩阵。
（1）向量
在前面我们已经介绍了生成向量的一些方法，而在R中可以用函数vector()来生成一个空向量，其调用格式为：
vector(mode = "logical", length = 0)
其中
mode：表示的是该向量储存数据的类型，可取的值有：“logicl”，“integer”，“numeric”，“complex”,“character”及“raw”，默认值是“logicl”
length：表示该向量的长度，默认值为0
(x<-vector(mode="numeric",length=5))
结果为：[1] 0 0 0 0 0
与向量相关的函数还有：
as.vector()：将其它类型的对象强制转换成向量
is.vector()：判断对象是否为向量
（1）矩阵
矩阵是一个二维的特殊数组，在R中可以用函数matrix()来生成矩阵，其调用格式为：
matrix(data=NA, nrow=1, ncol=1, byrow=FALSE, dimnames=NULL)
其中：
data： 表示该向量要储存的数据
nrow和ncol： 表示矩阵的行数和列数，注意data的个数等于nrow乘以ncol
byrow： 表示数据是否以行的方式进行排列
dimnames： 指定矩阵各维度的名称，默认为整数
x = matrix(data=1:6,nrow=2,ncol=3,byrow=T);x
结果为： [,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
x = matrix(data=1:6,nrow=2,ncol=3,byrow=F);x
结果为： [,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
对于矩阵的四则运算(+，-，，/)，是对其中对应元素的四则运算，如果要实现线性代数中的矩阵的乘法，则要用%%，输入以下命令，比较其运算结果：
B<-A<-matrix(data=1:9,nrow=3,ncol=3)
A*B
结果为： [,1] [,2] [,3]
[1,] 1 16 49
[2,] 4 25 64
[3,] 9 36 81
A%*%B
结果为： [,1] [,2] [,3]
[1,] 30 66 102
[2,] 36 81 126
[3,] 42 96 150
如果要求矩阵的转置，可以使用函数t(),如：
t(A)
结果为： [,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
如果要求矩阵的逆矩阵，可以使用函数solve(),如：
A<-matrix(data=1:4,nrow=2,ncol=2)
solve(A)
结果为： [,1] [,2]
[1,] -2 1.5
[2,] 1 -0.5
如果要求矩阵的特征值和特征向量，可以使用函数eigen(),如：
eigen(A)
结果为：
eigen() decomposition
$values
[1] 5.3722813 -0.3722813
$vectors
[,1] [,2]
[1,] -0.5657675 -0.9093767
[2,] -0.8245648 0.4159736
当然，对于矩阵的运算还有很多，但大多都是与线性代数和数值分析有关，不在此讨论。
1.2.4.2 列表
数组（向量或矩阵）所存储的数据必须属于同一类型。当数据对象包含有不同的数据类型，则可以采用列表(list)。列表是R语言中使用非常广泛的一种结构，构成列表的对象有可称为它的分量，分量可以是不用的模式或类型，如一个列表可以包括数值向量、逻辑向量、矩阵、字符和数组，甚至可以是列表。列表可以用list()函数进行创建，其调用格式如下：
list(var1=componet1,var2=componet12,...)
例如：
x<-list(fruit=c("apple","banana","pear"),price=c(1,1,1.5),market=c("newabest"));x
结果为：
$fruit
[1] “apple” “banana” “pear”
$price
[1] 1.0 1.0 1.5
$market
[1] “newabest”
在这个列表中，包含了3个分量，第一个是fruit，它储存的是字符型，长度为3。第二个是price，储存的是数值型，长度为3，第三个是market，储存的是字符型，长度为1.亦即，我们可以在一个列表中储存不同的类型数据，还可以储存不同的长度数据，每一个分量中都是一个向量（vector）。
列表的引用格式为“列表名[[下标]]”，如
x[[1]]
结果为：[1] “apple” “banana” “pear”
x[[1]][2]
结果为：[1] “banana”
x[[1]][1:3]
结果为：[1] “apple” “banana” “pear”
注意：“列表名[[下标]]”的引用方式，不支持向量格式的下标，如
x[[1:3]]
结果为：Error in x[[1:3]] : recursive indexing failed at level 2
如果定义列表的时候指定了各分量的名称（如x中的“fruit”，“price”，“market”），则在引用的时候可以用分量的名称作为下标，引用格式为“列表名[[分量名称]]”，如
x[["fruit"]]
结果为：[1] “apple” “banana” “pear”
还有一种调用格式是“列表名$分量名称”，如
x$fruit
结果为：[1] “apple” “banana” “pear”
x$fruit[2]
结果为：[1] “banana”
如果要修改列表，可以直接对相应的引用赋值就可以了，例如，apple的价格改为1.2，可以输入命令：
x$price[1]<-1.2
如果要删除表中的某些项，则只需将空值（NULL）赋值给相应的引用即可。
1.2.4.3 数据框
数据框（data frame）是R中特有的、非常实用的数据结构。数据框是矩阵形式的数据，但矩阵的各列可以储存不同类型数据。数据框是矩阵的推广，也是一种特殊的列表。数据框进行统计分析的最为有用的数据类型，每列为一个变量，每行为一个观测样本。
在R语言中，可以用函数data.frame()生成数据框，其调用格式如下：
data.frame(..., row.names = NULL, check.rows = FALSE,...)
其用法与列表的相同，输入以下命令，观察其运行效果。
fruit=c("apple","banana","pear")
price=c(1,1,1.5)
buy=c(TRUE,FALSE,FALSE)
x=data.frame(fruit,price,buy)
x
结果为： fruit price buy
1 apple 1.0 TRUE
2 banana 1.0 FALSE
3 pear 1.5 FALSE
数据框的列名默认为变量名，也可以重新对列名进行命名，如
(x=data.frame(shuiguo=fruit,jiage=price,goumai=buy))
结果为： shuiguo jiage goumai
1 apple 1.0 TRUE
2 banana 1.0 FALSE
3 pear 1.5 FALSE
也可以对行名进行重新命名，如
row.names(x)<-c("item1","item2","item3")
x
结果为： shuiguo jiage goumai
item1 apple 1.0 TRUE
item2 banana 1.0 FALSE
item3 pear 1.5 FALSE
数据框的引用与矩阵及列表的引用一样，输入以下命令，观察其运行效果。
x[1,]
结果为： shuiguo jiage goumai
item1 apple 1 TRUE
x[[1]]
结果为：[1] apple banana pear
Levels: apple banana pear
x$jiage
结果为：[1] 1.0 1.0 1.5
1.2.5 R语言的数据导入与导出
1.2.5.1 保存和加载R的数据
在R语言中save()函数用于将数据保存为R数据文件.Rdata，load()函数用于加载R的数据。
a<-1:10
save(a,file="dumData.Rdata")#data文件为当前目录下文件，必须存在
注：可以用getwd()查看R当前的工作目录，进入当前目录下的文夹，可以看到已保存的dumData.Rdata文件。一般我们会把数据放在固定的地方以便于查找，这时，可以在保存数据的命令中指定目录，如
save(a,file="/home/ubuntu/dumData.Rdata")
rm(a)#删除向量a
load("/home/ubuntu/dumData.Rdata")#加载目录中的.RData
print(a)#打印
结果为： [1] 1 2 3 4 5 6 7 8 9 10
1.2.5.2 导入和加载文本文件
（1）从文本文件读取数据
把文本文件中的数据导入到R中，可以使用read.table()，其调用格式是：
read.table(file, header = FALSE, sep = "", quote = "\"'",
dec = ".", numerals = c("allow.loss", "warn.loss", "no.loss"),
row.names, col.names, as.is = !stringsAsFactors,
na.strings = "NA", colClasses = NA, nrows = -1,
skip = 0, check.names = TRUE, fill = !blank.lines.skip,
strip.white = FALSE, blank.lines.skip = TRUE,
comment.char = "#",
allowEscapes = FALSE, flush = FALSE,
stringsAsFactors = default.stringsAsFactors(),
fileEncoding = "", encoding = "unknown", text, skipNul = FALSE)
其中主要参数意义：
file： 表示要读取的数据所在文件的文件名
header： 逻辑比那里，取值为TRUE时，表示数据文件第一行为表头；取值为FALSE（默认值）时，表示数据包含表头且第一列为序号
sep： 分隔数据的字符，通常是空格
row.names： 向量，表示行名，即样本名
col.names： 向量，表示列名，即变量名。如果数据文件无表头，则变量名为“v1”，“v2”的形式
skip： 非负整数，表示读取数据时跳过的行数
例如：“score.txt”保存的是某班的成绩，其中变量包括：姓名、学号、数学、英语、历史，共5位同学的成绩
新打开一个终端，创建表score.txt。wq保存
cd ~
vim score.txt
name no math english history
zhangsan 0001 90 87 97
lisi 0002 85 78 88
wangwu 0003 95 90 93
dingliu 0004 100 98 99
zhouqi 0005 79 60 71
回到打开R语言的终端
读取数据的代码及运行效果：
score1<-read.table("score.txt")
score1
结果为： V1 V2 V3 V4 V5
1 name no math english history
2 zhangsan 0001 90 87 97
3 lisi 0002 85 78 80
4 wangwu 0003 95 90 93
5 dingliu 0004 100 98 99
6 zhouqi 0005 79 60 71
score2<-read.table("score.txt",header=T)
score2
结果为： name no math english history
1 zhangsan 1 90 87 97
2 lisi 2 85 78 80
3 wangwu 3 95 90 93
4 dingliu 4 100 98 99
5 zhouqi 5 79 60 71
如果文本文件中的数据不是以表格的形式保存，则可以用scan()函数读取，其调用格式为：
scan(file = "", what = double(0), nmax = -1, n = -1, sep = "",
quote = if(identical(sep, "\n")) "" else "'\"", dec = ".", skip = 0,
nlines = 0, na.strings = "NA", flush = FALSE, fill = FALSE,
strip.white = FALSE, quiet = FALSE, blank.lines.skip = TRUE,
multi.line = TRUE, comment.char = "", allowEscapes = FALSE,
fileEncoding = "", encoding = "unknown",text, skipNul = FALSE)
其中主要参数意义：
file： 表示要读取的数据所在文件的文件名
what： 表示函数返回值的类型，包括numeric，logical，character，list等，其中数值型的初始值为0，字符型的初始值为“”
sep： 表示分隔符的类型
skip： 非负整数，表示读取数据时跳过的行数
开启终端，创建表：weight.txt。wq保存
cd ~
vim weight.txt
75.0 64.0 47.4 66.9 62.2 62.2 58.7 63.5 66.6 64.0 57.0 69.0 56.9 50.0 72.0
回到打开R语言的终端
例如：weight.txt 保存的是15名学生的体重数据，用san()读取其中数据，输入以下命令：
weight<-scan("weight.txt")
结果为：Read 15 items
weight
结果为： [1] 75.0 64.0 47.4 66.9 62.2 62.2 58.7 63.5 66.6 64.0 57.0 69.0 56.9 50.0 72.0
is.vector(weight)
结果为：[1] TRUE
如果在调用scan()函数时，没有指定参数file，则直接从屏幕上读取数据，输入以下命令并观察运行效果
x<-scan()
结果为：1: 2 3 5 7 11 13 17
8:
Read 7 items
x
结果为：[1] 2 3 5 7 11 13 17
（2）把数据保存到文本文件
把工作空间中的变量保存到纯文本文件中，可以使用write()函数，其调用格式为：
其中：
write.table(x, file = "data",
ncolums=if(is.character(x) 1 else 5,
append = FLASE,sep=" ")
x： 矩阵或向量，表示需要保存的数据
file： 表示文件名，默认值为data
ncolumns： 正整数，表示保存到文件中数据的列数，若是字符型数据，默认值为1；若是数值型数据，默认值为5
append： 逻辑变量，取值为TRUE时，表示在已有文件上添加数据；取值为FALSE（默认值）时，写入一个新文件
例如：在R中输入以下命令，观察其运行效果：
A<-matrix(1:25,ncol =5)
A
结果为： [,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 16 21
[2,] 2 7 12 17 22
[3,] 3 8 13 18 23
[4,] 4 9 14 19 24
[5,] 5 10 15 20 25
write(A,file="write_a_data.txt",ncolumns = 6)
这表明在保存的时候，是按列（ncolumns = 6）写入文件的。
如果需要将数据以表格格式存入文本文件，可以使用write.table()函数，其调用格式为：
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 = "")
其中：
x： 矩阵或数据框，表示需要保存的数据
file： 表示文件名
append： 逻辑变量，取值为TRUE时，表示在已有文件上添加数据；取值为FALSE（默认值）时，写入一个新文件
sep： 表示分隔数据的字符，默认值为空格
例如：在R中输入以下命令，观察其运行效果：
Name=c("Alice","Becka","James","Jeffrey","John")
Sex=c("F","F","M","M","M")
Age=c(13,13,12,13,12)
Height=c(56.5,65.3,57.3,62.5,59.0)
Weight=c(84.0,98.0,83.0,84.0,99.5)
tijian<-data.frame(Name,Sex,Age,Height,Weight)
write.table(tijian,file="tijian.txt")
1.2.5.3 导入和加载csv文件
csv文件是一种通用的、相对简单的文本格式，其文件以纯文本形式保存表格数据，大部分的程序都支持这种数据格式。在R语言中，可以用write.csv()函数导出R中的数据成.csv格式的数据，其调用格式为：
write.csv(x, file = "", append = FALSE, quote = TRUE, sep = " ",
eol = "\n", na = "NA", dec = ".", row.names = TRUE,
col.names = TRUE, qmethod = c("escape", "double"),
fileEncoding = "")
主要的参数说明：
x： 要写入文件的数据，通常是一个数据框
file： 指定文件名
append： 逻辑变量，取值为TRUE时，在文件后面添加数据；否则，将数据写入一个新文件，默认值是FALSE
sep： 表示分隔数据的字符，默认值为空格
例如：在R中输入以下命令，观察其运行效果：
var1<-1:5
var2<-(1:5)/10
var3<-c("R","and","DataMining","Examples","Case Studies")
a<-data.frame(var1,var2,var3)#把三个变量放在数据框中赋值给a
names(a)<-c("VariableInt","VariableReal","VariableChar")#对a中的三个变量重命名
write.csv(a,"/home/ubuntu/data_1_01.csv",row.names=FALSE)#导出数据
要从csv文件中读取数据到R的工作空间中，可以用函数read.csv()，其调用格式为：
read.csv(file,header=TRUE,SEP=",",...)
其中：
file： 要导入的文件
header： 逻辑变量，表示是否含有列名
sep： 表示csv文件的分隔方式，默认值是逗号分隔符
…： 是进一步的参数
例如：要导入/home/ubuntu/目录下的data_1_01.csv文件，可输入以下命令：
b<-read.csv(file="/home/ubuntu/data_1_01.csv")
b
结果为： VariableInt VariableReal VariableChar
1 1 0.1 R
2 2 0.2 and
3 3 0.3 DataMining
4 4 0.4 Examples
5 5 0.5 Case Studies