文章参考 << R 数据分析 —— 方法与案例详解 >>
R的官方网站是http://www.r-project.org，
在R官方主页点击download R，然后选择对应的镜像后，在右侧下载和安装包栏目里会
出现三种操作系统的R版本（Linux、(Mac) OS X、Windows），选择点击相应的操作系
统后，再选择点击base就会进入R的下载页面，在页面上会出现R的最新版本和安装说明等
不过，要使用RStudio，除了安装R开发环境后，还需要到
http://www.rstudio.org/download/desktop/
上下载适合你电脑的RStudio版本并安装。
R的安装包有几种方法，这里主要介绍其中两种方法：
（1）在线安装。
比如需要安装”class”这个扩展包，输入命令install.packages(“class”)执行即可。
也可以同时安装多个包，比如需同时安装“class”,“cluster”两个包，输入命
令install.packages(c(“class”,”cluster”) )。
（2）利用Rstudio安装。
Rstudio在下一节将会详细介绍。
在Rstudio右下角栏目里点
击“packages”然后再点击 “install
packages”, 会出现如图的对话框，
在packages对话框里输入需要安装的
包名，比如输入 class，就可以安装包
工作路径设置的函数
函数 功能
getwd() 显示当前工作目录
setwd(“mydir”) 修改当前工作目录
ls() 列出当前工作空间的所有对象
rm() 删除一个或多个对象
help(options) 显示可用选项的说明
save.image(“myfile”) 保存工作空间到文件myfile.RData中
load(“myfile”) 读取一个工作空间myfile.RData
q() 退出。并询问是否保存当前工作空间
二.R数据结构和基本运算
R语言的数据类型主要有:包括数值型、逻辑型、字符型、复数型，原型 。此外，也可以
是缺省值。
1、数值型（numeric）
这种数据的形式是实数。可以写成整数（integers），小数（decimal fractions），或
科学记数（scientific notation）的方式。数值型实际上是两种独立模式的混合说法，即整数
型（integers）和双精度型（double－precision）。该种类型数据默认是双精度型数
据（double－precision）。
2、字符型（character）
这种数据的形式是夹在双引号“”或单引号‘ ’之间的字符串，如“MR”。
3、逻辑型（logical）
这种数据只能取T（TRUE）或F（FALSE）值。
4、复数型（complex）
这种数据是形如a+bi形式的复数。
5、原味(原始)型（raw）
这种类型以二进制形式保存数据。
6、缺省值（missing value）
有些统计资料是不完整的。当一个元素或值在统计的时候是“不可得到”（not
available）或“缺失值”（missing value）的时候，相关位置可能会被保留并且赋予一个
特定的NA（not available）值。任何NA的运算结果都是NA。is.na()用来检测数据是否缺失
，如果数据缺失，则返回TRUE，否则，返回FALSE。
例如：
> z<-c(1:5,NA) #生成向量z
> z #返回z向量的结果
[1] 1 2 3 4 5 NA
> is.na(z) #识别z向量的值是否有缺失值
[1] FALSE FALSE FALSE FALSE FALSE TRUE
上面，我们用c()函数首先生成了向量z, c()函数的具体使用方法详见2.2.1。is.na()返回的结果
是前面5个元素都FALSE，最后1个是TRUE，这说明前面5个都不是缺失值，最后1个是缺失值。
数据类型 辨别函数 转换函数
numeric is.numeric() as.numeric()
character is.character() as.character()
complex is.complex() as.complex()
double is.double() as.double()
integer is. integer() as. integer()
logical is. logical() as. logical()
NA is.na() as.na()
常见的辨别和转换对象类型的函数如下表：
表2-1 辨别和转换数据对象类型的函数
R语言里的数据对象主要有六种结构：
l??向量（vector）
l??矩阵（matrix）
l??数组（array）
l??因子（factor）
l??列表（list）
l??数据框（data frames）
不过在这之前，我们先了解一下R在浮点运算中的一些精度问题。
例如：（0.6>0.6？）
> x <- seq(0, 1, by = 0.2) #seq()生成序列的函数，详见2.2.1部分
> y <- seq(0, 1, by = 0.2)
> y[4]
[1] 0.6
> x[3]
[1] 0.4
> 1 - x[3]
[1] 0.6
> y[4] > 1 - x[3]
[1] TRUE
注意：这也是在计算机运算里面经常出现的一个问题（不过表示出来结果这样其实应该
算是R的缺陷，稍微高级的数学运算软件一般都会通过一些方法来克服），简单来说就是浮点
数在计算机中的表达有限制，不能以任意精度存储，所以尤其是微小的数字或巨大的数字在
运算时经常会有些意外情况。
因此有时候在处理R里面的数据的时候，特别是在判断的时候，需要特别注意精度问题。
（1）向量赋值
向量（vector）是由有相同基本类型元素组成的序列，相当于一维数组。
例：> x <-c(1,3,5,7,9) #用c( )构建向量
这是一个用函数c( )完成的赋值语句。这里的函数c( )可以有任意多个参数，而它输出的
值是一个把这些参数首尾相连形成的一个向量。
“#”符号后面跟的是注释，在写程序的时候清楚表明程序工作的注释能大大提高程序的可
读性。
“<-”是赋值符号，表示把<-后面的内容赋值给<-前面的内容，R的赋值符号除了“<-”外,
还有“->”、“=”， ->的用法和<-的用法正好相反。
注意：R也允许“=”赋值，但不是标准语法，有些情况下用“=”有可能会出现问题，因此一
般情况不建议使用“=”。
例如：
> c(1,3,5,7,9) -> y #将c()生成的数值向量赋值给y
> y
[1] 1 3 5 7 9
> z <- c("Male","Female","Female","Male","Male") #将c()生成的字符向量赋值给z
> z
[1] "Male" "Female" "Female" "Male" "Male"
> u=c(TRUE,FALSE,TRUE,FALSE,FALSE) #将c()生成的逻辑向量赋值给u
> u
[1] TRUE FALSE TRUE FALSE FALSE
此处，y是数值向量，z是字符型向量，u是逻辑型向量。
注意：单个向量中的数据要求是相同类型，同一向量中无法混杂不同类型的数据。
对于字符向量，一个很重要的函数paste（）可以把自变量对应元素连成一个字符串，长
度不相同时，较短的向量被重复使用。
例如：
> v<-paste("x",1:5,sep="")
> v
[1] "x1" "x2" "x3" "x4" "x5“
此外，也可以用assign（）函数对向量进行赋值。例如：
> assign("w",c(1,3,5,7,9))
> w
[1] 1 3 5 7 9
（2）向量运算
对于向量的乘法，除法，乘方运算，其方法是对应向量的每个分量做乘法、除法和乘方运算。
例如：>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
（2）向量运算
此外，”%/%”表示整数除法(5%/%3为1)，”%%”表示求余数(5%%3为2)。
向量运算会对该向量的每一个元素都进行同样的运算。出现在同一个表达式的向量最好
同一长度。如果长度不一，表达式中短的向量将会被循环使用，表达式的值将是一个和最长
的向量等长的向量。
例如：
> c(1,3,5)+c(2,4,6,8,10)
[1] 3 7 11 9 13
第一个向量的长度小于第二个向量，循环补齐第一向量的长度，即为c(1,3,5,1,3)
（3）生成有规则序列
l??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
其中，5:1表示逆向序列, 并且在表达式运算中，“：”的运算级别最高，即上面的2*1:5
，R是先生成1-5的向量，然后再乘上2。这里在表达式外面套()的意思把结果直接打印出来，
比如>t <- 1:10而不套括号，则R将运算结果保存在t对象里，但是不会把t的结果打印出来。
2.2.1 向量
（3）生成有规则序列
l??可以用函数seq（）产生有规律的各种序列，其句法是：seq(from, to, by)，from表示序列的
起始值，to表示序列的终止值，by表示步长。其中，by参数（参数by）省略时，默认步长为1
。并且函数seq（）也可以产生降序数列。例如：
> seq(1,10,2) #生成从1开始，10结束，步长为2的序列
[1] 1 3 5 7 9
> seq(1,10) #默认步长为1
[1] 1 2 3 4 5 6 7 8 9 10
> seq(10,1,-1) #步长为-1
[1] 10 9 8 7 6 5 4 3 2 1
2.2.1 向量
（3）生成有规则序列
有时候我们需要关注的是数列的长度，这时我们可以操作如下：
> seq(1,by=2,length=10)
[1] 1 3 5 7 9 11 13 15 17 19
（3）生成有规则序列
l??rep()函数可以用各种复杂的方式重复一个对象。其命令是：rep(x, times, ...)，其中x表示要
重复的对象，times表示重复的次数。
> rep(c(1,3),4) #将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))
[1] 1 1 2 2 3 3
第一个是向量c(1,3)重复4次的情况，也可以用第二个对每个元素进行重复，第三个是函
数rep( )的嵌套使用，里层的rep(2,3)实际就等价于向量c(2,2,2)。
2.2.1 向量
（4）向量的常见函数
向量里元素的个数称为向量的长度（length）。长度为1的向量就是常数（或标量）。函
数length()可以返回向量的长度，mode()可以返回向量的数据类型，min()返回向量的最小值
，max()返回向量的最大值，range()返回向量的范围，which.min()、which.max()返回在第几
个分量求到最小、最大值。例如：
>x <-c(1,3,5,7,9)
> length(x)
[1] 5
> min(x)
[1] 1
> range(x)
[1] 1 9
（4）向量的常见函数
R提供了很多的函数可以对向量进行运算，这里不一 一列举，下面列出几个常用函数表。
函数 用途 函数 用途
sum（） 求和 rev（） 反排序
max（） 求最大值 rank（） 求秩
min（） 求最小值 append（） 添加
range（） 求极差（全矩） replace（） 替换
mean（） 求均值 match（） 匹配
median （） 求中位数 pmatch（） 部分匹配
var（） 求方差 all（） 判断所有
sd（） 求标准差 any（） 判断部分
sort（） 排序 prod（） 积
表2-2 对向量运算常见函数表
（5）向量的索引
l??在R中提供了灵活的向量下标运算。取出向量的某一个元素可以用x[i]。也可以通过赋值语
句来改变一个或多个元素的值。例如：
> x <- c(1,3,5)
> x[2] #返回x向量的第2元素
[1] 3
>(c(1,2,3)+4)[2]
#先进行向量运算c(1,2,3)+4，再返回该
向量的第2个元素
[1] 6
> x[2] <- 10 #将10赋值给x向量的第2个
元素，,即替换掉原来的值
> x
[1] 1 10 5
> x[c(1,3)] <- c(9,11) #将9和11赋值给x
向量的第1和第3个元素
> x
[1] 9 10 11
2.2.1 向量
?> x <- c(1,3,5)
?> x < 4
?#返回逻辑结果，即x向量的元素是否小于4
?[1] TRUE TRUE FALSE
?> x[x<4] #返回x向量里小于4的元素
?[1] 1 3
?> z <- c(-1,1:3,NA)
?> z
?[1] -1 1 2 3 NA
> z[is.na(z)] <- 0 #将0赋值给z向量里的N
A值
> z
[1] -1 1 2 3 0
> z <- c(-1,1:3,NA)
y <- z[!is.na(z)]
#将z里的非缺失值赋值给y
> y
[1] -1 1 2 3
l?? 把i换成逻辑语句也可以对向量进行逻辑运算。例如：
2.2.1 向量
?> 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]
?#求出x中小于0元素对应位置，y对应位
置的值用1-x[x<0]替代
> y
[1] 4 3 2 0 0 0
>y[x>=0] <- 1+x[x>=0]
#求出x中大等于0元素对应位置，y对应位
置的元素用1-x[x<0]赋值
> y
[1] 4 3 2 1 6 8
第二章 数据结构与基本运算
l?? 这种方法可以用在对分段函数的定义上。例如：
l?? 如果x[i]，i取值是小于0的负整数，则表示删除相应位置的元素。
矩阵（matrix）是将数据用行和列排列的长方形表格，它是二维的数组，其单元必须是
相同的数据类型。通常用列来表示不同的变量，用行表示各个对象。R语言生成矩阵的函数
是matrix ( )，其句法是：
matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)
其中，data 项为必要的矩阵元素,nrow 为行数,ncol 为列数,注意 nrow 与 ncol 的乘积应为
矩阵元素个数, dimnames 给定行和列的名称，byrow 项控制排列元素时是否按行进行,默
认byrow=FALSE，即按列顺序排列。
例如：> 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
矩阵的运算种类多，方法多，此处作简要介绍。
l??矩阵的转置可以用函数t()来计算，类似的，若将函数 t()作用于一个向量x,则当做x为列向量,
返回结果为一个行向量。若想得到一个列向量,可用 t(t(x))。
> (A <- matrix(1:12,nrow=3,ncol=4))
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> t(A)
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
[4,] 10 11 12
矩阵的运算种类多，方法多，此处作简要介绍。
l??矩阵的加减法
>A <- B <- matrix(1:12,nrow=3)
#将生成的矩阵赋给B，同时又赋给A
> A+B
[,1] [,2] [,3] [,4]
[1,] 2 8 14 20
[2,] 4 10 16 22
[3,] 6 12 18 24
l??矩阵的数乘
> 3*A
[,1] [,2] [,3] [,4]
[1,] 3 12 21 30
[2,] 6 15 24 33
[3,] 9 18 27 36
矩阵的运算种类多，方法多，此处作简要介绍。
l??矩阵的乘法，除了矩阵需要满足可以相乘的要求之外，在R中需要用运算符“%*%”来进行
计算。“*”运算只是对应的元素相乘。如果要计算t(A)%*%B还可以用函数crossprod(A,B),
这种计算的效率更高。
> B <- t(A)
> A%*%B
[,1] [,2] [,3]
[1,] 166 188 210
[2,] 188 214 240
[3,] 210 240 270
l??R中还可以对矩阵的对角元素进行计算，例如要取一个方阵的对角元素:
> (A <- matrix(1:16,nrow=4))
[,1] [,2] [,3] [,4]
[1,] 1 5 9 13
[2,] 2 6 10 14
[3,] 3 7 11 15
[4,] 4 8 12 16
> diag(A)
[1] 1 6 11 16
另外，对一个向量应用diag()函数可以产生以这样向量的元素为对角元的对角矩阵
> 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()函数将会生成一个对应维数的单位阵。
> diag(3)
[,1] [,2] [,3]
[1,] 1 0 0
[2,] 0 1 0
[3,] 0 0 1
l??求逆，在R中使用solve()函数可以计算，如果是solve(a,b)的话是解线性方程组ax=b，b默
认为单位矩阵。
> (A <- matrix(rnorm(16),4,4)) #rnorm()是生成16个标准正态分布随机数
[,1] [,2] [,3] [,4]
[1,] 0.44576927 -0.9841294 -0.1291554 0.18165406
[2,] 1.04034856 1.3658480 -0.6905046 0.06254394
[3,] -0.02689138 -0.5389127 -0.1356344 1.71923910
[4,] -0.05693438 1.4905866 -0.2479709 0.03399939
> solve(A)
[,1] [,2] [,3] [,4]
[1,] -4.538443 2.6321129 0.4872459 -5.232100
[2,] -1.936148 0.7670728 0.2011416 -1.237585
[3,] -10.806250 4.0894901 1.1996337 -10.448150
[4,] -1.530421 0.6042453 0.7469654 -1.294048
l??求特征值和特征向量的运算，在R中可以通过函数eigen()来得到。
> (A <- diag(4)+1)
[,1] [,2] [,3] [,4]
[1,] 2 1 1 1
[2,] 1 2 1 1
[3,] 1 1 2 1
[4,] 1 1 1 2
> (A.eigen <- eigen(A,symmetric=T))
$values #此处返回的结果是列表格式，具体详见2.2.5
[1] 5 1 1 1
$vectors
[,1] [,2] [,3] [,4]
[1,] -0.5 0.8660254 0.0000000 0.0000000
[2,] -0.5 -0.2886751 -0.5773503 -0.5773503
[3,] -0.5 -0.2886751 -0.2113249 0.7886751
[4,] -0.5 -0.2886751 0.7886751 -0.2113249
l??对于正定矩阵A，可以对其进行Choleskey分解，即A=P T P，其中P为上三角矩阵，在R中
可以用函数chol()进行Choleskey分解。
> chol(A)
[,1] [,2] [,3] [,4]
[1,] 1.414214 0.7071068 0.7071068 0.7071068
[2,] 0.000000 1.2247449 0.4082483 0.4082483
[3,] 0.000000 0.0000000 1.1547005 0.2886751
[4,] 0.000000 0.0000000 0.0000000 1.1180340
若矩阵为对称正定阵，则可以利用Choleskey分解来求行列式的值以及矩阵的逆，并且这
种用法更有效。
> prod(diag(chol(A))^2)#求出A矩阵的对角元素，然后求平方，再求连乘积
[1] 5
> det(A) #求A矩阵行列式
[1] 5
> chol2inv(chol(A)) 求Choleskey分解后的逆
[,1] [,2] [,3] [,4]
[1,] 0.8 -0.2 -0.2 -0.2
[2,] -0.2 0.8 -0.2 -0.2
[3,] -0.2 -0.2 0.8 -0.2
[4,] -0.2 -0.2 -0.2 0.8
l??奇异值分解：
若A为m行n列矩阵，秩为r，则矩阵可以进行奇异值分解得到A=UDV T 。在R中可以通过svd(
)函数进行计算。 $u
[,1] [,2] [,3]
[1,] -0.5290354 0.74394551 0.4082483
[2,] -0.5760715 0.03840487 -0.8164966
[3,] -0.6231077 -0.66713577 0.4082483
$v
[,1] [,2] [,3]
[1,] -0.07736219 -0.71960032 -0.4076688
[2,] -0.19033085 -0.50893247 0.5745647
[3,] -0.30329950 -0.29826463 -0.0280114
[4,] -0.41626816 -0.08759679 0.2226621
[5,] -0.52923682 0.12307105 -0.6212052
[6,] -0.64220548 0.33373889 0.2596585
> (A <- matrix(1:18,3,6))
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 4 7 10 13 16
[2,] 2 5 8 11 14 17
[3,] 3 6 9 12 15 18
>(A.svd <- svd(A))
#求矩阵A的svd分解，并将结果赋值给A.svd
$d
[1] 4.589453e+01 1.640705e+00 1.366522e-15
l?? QR分解：
实数矩阵A的QR分解是把A分为A=QR，这里的Q是正交矩阵，而R是上三角矩阵。QR分
解在R中可以用函数qr()计算.其中，rank项返回矩阵的秩，qr项包含了矩阵Q和R的信息，
要得到对应矩阵，可以用函数qr.R()，qr.Q()计算。
2.2.2 矩阵
第二章 数据结构与基本运算
l?? QR分解。例如：
> B <- matrix(1:16,4,4)
> qr(B)
$qr
[,1] [,2] [,3] [,4]
[1,] -5.4772256 -12.7801930 -2.008316e+01 -2.738613e+01
[2,] 0.3651484 -3.2659863 -6.531973e+00 -9.797959e+00
[3,] 0.5477226 -0.3781696 1.601186e-15 2.217027e-15
[4,] 0.7302967 -0.9124744 -5.547002e-01 -1.478018e-15
$rank #矩阵的秩
[1] 2
$qraux #Q中的额外信息
[1] 1.182574e+00 1.156135e+00 1.832050e+00 1.478018e-15
$pivot #分解过程中的旋转信息
[1] 1 2 3 4
attr(,"class") #返回属性
[1] "qr"
l?? QR分解。
例如：
> qr.R(qr(B)) #提取R矩阵
[,1] [,2] [,3] [,4]
[1,] -5.477226 -12.780193 -2.008316e+01 -2.738613e+01
[2,] 0.000000 -3.265986 -6.531973e+00 -9.797959e+00
[3,] 0.000000 0.000000 1.601186e-15 2.217027e-15
[4,] 0.000000 0.000000 0.000000e+00 -1.478018e-15
> qr.Q(qr(B)) #提取Q矩阵
[,1] [,2] [,3] [,4]
[1,] -0.1825742 -8.164966e-01 -0.4000874 -0.37407225
[2,] -0.3651484 -4.082483e-01 0.2546329 0.79697056
[3,] -0.5477226 -1.665335e-16 0.6909965 -0.47172438
[4,] -0.7302967 4.082483e-01 -0.5455419 0.04882607
l??可用kronecker()来计算矩阵的Kronecker积。
m×n
> (A <- matrix(1:4,2,2))
[,1] [,2]
[1,] 1 3
[2,] 2 4
> kronecker(A,B)
[,1] [,2] [,3] [,4]
[1,] 1 1 3 3
[2,] 1 1 3 3
[3,] 2 2 4 4
[4,] 2 2 4 4
> (B <- matrix(rep(1,4),2,2))
[,1] [,2]
[1,] 1 1
[2,] 1 1
l??在R中可使用dim()得到矩阵的维数，nrow()求行数，ncol()求列数； rowSums()求各行和，
rowMeans()求行均值， colSums()求各列和， colMeans()求列均值。
l??计算X T X这样的矩阵逆，例如OLS中的系数矩阵。在R的strucchange包里面有函
数solveCrossprod()函数可以很方便的计算。其具体形式如下：
solveCrossprod(X, method = c("qr", "chol", "solve"))
对于method中的求逆方法，qr效率最高，chol精度最高，而solve与solve(crossprod(x,x)
)的效果相同。例如：
> A <- matrix(rnorm(16),4)
> solveCrossprod(A,method="qr") #利用qr分解方法求逆矩阵
[,1] [,2] [,3] [,4]
[1,] 1.5752935 0.3617794 -1.269400 1.5530569
[2,] 0.3617794 0.2996626 -0.139547 0.4616545
[3,] -1.2694003 -0.1395470 1.741550 -1.1275450
[4,] 1.5530569 0.4616545 -1.127545 2.1345205
l?? 计算X T X这样的矩阵逆 ，在R的strucchange包里面有函数solveCrossprod()函数可以很
方便的计算。
续例：
> solveCrossprod(A,method="chol") #利用Choleskey分解方法求逆矩阵
[,1] [,2] [,3] [,4]
[1,] 1.5752935 0.3617794 -1.269400 1.5530569
[2,] 0.3617794 0.2996626 -0.139547 0.4616545
[3,] -1.2694003 -0.1395470 1.741550 -1.1275450
[4,] 1.5530569 0.4616545 -1.127545 2.1345205
l?? 计算X T X这样的矩阵逆 ，在R的strucchange包里面有函数solveCrossprod()函数可以很
方便的计算。
续例：
> solveCrossprod(A,method="solve")
[,1] [,2] [,3] [,4]
[1,] 1.5752935 0.3617794 -1.269400 1.5530569
[2,] 0.3617794 0.2996626 -0.139547 0.4616545
[3,] -1.2694003 -0.1395470 1.741550 -1.1275450
[4,] 1.5530569 0.4616545 -1.127545 2.1345205
> solve(crossprod(A,A))
[,1] [,2] [,3] [,4]
[1,] 1.5752935 0.3617794 -1.269400 1.5530569
[2,] 0.3617794 0.2996626 -0.139547 0.4616545
[3,] -1.2694003 -0.1395470 1.741550 -1.1275450
[4,] 1.5530569 0.4616545 -1.127545 2.1345205
l??可使用lower.tri()，upper.tri()提取到矩阵的上三角和下三角矩阵。结果返回为逻辑矩阵，
其中diag为T时包含对角元，默认不含对角元。
lower.tri(x, diag = FALSE)
upper.tri(x, diag = FALSE)
例如：
> lower.tri(A,diag=T)
[,1] [,2] [,3] [,4]
[1,] TRUE FALSE FALSE FALSE
[2,] TRUE TRUE FALSE FALSE
[3,] TRUE TRUE TRUE FALSE
[4,] TRUE TRUE TRUE TRUE
> A[lower.tri(A)]=0
> A
[,1] [,2] [,3] [,4]
[1,] 1 5 9 13
[2,] 0 6 10 14
[3,] 0 0 11 15
[4,] 0 0 0 16
> A <- matrix(1:16,4)
> lower.tri(A)
[,1] [,2] [,3] [,4]
[1,] FALSE FALSE FALSE FALSE
[2,] TRUE FALSE FALSE FALSE
[3,] TRUE TRUE FALSE FALSE
[4,] TRUE TRUE TRUE FALSE
l??在R中定义了row()和col()函数用来返回矩阵的行列下标。另外，也可以通过使
用x[row(x)<col(x)]=0等语句来得到矩阵的上下三角矩阵。
例如：
> col(A)
[,1] [,2] [,3] [,4]
[1,] 1 2 3 4
[2,] 1 2 3 4
[3,] 1 2 3 4
[4,] 1 2 3 4
> A[row(A)<col(A)]=0
> A
[,1] [,2] [,3] [,4]
[1,] 1 0 0 0
[2,] 2 6 0 0
[3,] 3 7 11 0
[4,] 4 8 12 16
> A <- matrix(1:16,4)
> row(A)
[,1] [,2] [,3] [,4]
[1,] 1 1 1 1
[2,] 2 2 2 2
[3,] 3 3 3 3
[4,] 4 4 4 4
l??矩阵中计算行列式的值可以使用函数det()来计算,例如对上面的下三角矩阵求行列式：
> det(A)
[1] 1056
l??在R的使用过程中，经常需要将矩阵转化为向量化算子，编写一个小函数即可实现。
例如：
> vec(A)
[,1]
[1,] 1
[2,] 2
[3,] 3
[4,] 4
[5,] 5
[6,] 6
> vec <- function(x){
+ t(t(as.vector(x)))
+ }
#函数编写详细请见3.4
> (A <- matrix(1:6,2,3))
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
l??在时间序列分析中，常常需要用到滞后序列，R中的fMultivar包中的函数tslag()可以实现
。首先，我们需要安装fMultivar，然后再载入该包。 tslag的用法为
tslag(x, k = 1, trim = FALSE)
其中，x为一个向量，k为滞后期数，trim默认返回序列与原序列长度相同，但包含NA值，
若trim=T，则返回不含NA值。例如：
> tslag(x,1:4,trim=T)
[,1] [,2] [,3] [,4]
[1,] 4 3 2 1
[2,] 5 4 3 2
> x <- 1:6
> tslag(x,1:4,trim=F)
[,1] [,2] [,3] [,4]
[1,] NA NA NA NA
[2,] 1 NA NA NA
[3,] 2 1 NA NA
[4,] 3 2 1 NA
[5,] 4 3 2 1
[6,] 5 4 3 2
l??对于矩阵的运算，我们还可以使用apply()函数来进行各种计算，其用法为
apply(X, MARGIN, FUN, ...) 。其中，X表示需要处理的数据，MARGIN表示函数的作用
范围，1为对行运算，2为对列运算。FUN为需要运用的函数。例如：
A <- matrix(1:12,3,4)
> apply(A,2,sum) #矩阵的列求和
[1] 6 15 24 33
> apply(A,2,mean) #矩阵的列求均值
[1] 2 5 8 11
> apply(A,2,var) #矩阵的列求方差
[1] 1 1 1 1
> apply(A,2,sd) #矩阵的列求标准差
[1] 1 1 1 1
l??矩阵合并可以使用rbind()和cbind()函数来对矩阵按照行和列进行合并。例如：
> B=matrix(c(1,1,1,1),2,2) #生成2×2的矩阵
> rbind(B,B) #将B和B矩阵按行合并
[,1] [,2]
[1,] 1 1
[2,] 1 1
[3,] 1 1
[4,] 1 1
> cbind(B,B) #将B和B矩阵按列合并
[,1] [,2] [,3] [,4]
[1,] 1 1 1 1
[2,] 1 1 1 1
l??对于得到的矩阵，可以使用A[i,j]得到A矩阵第i行第j列的元素，A[i,]和A[,j]分别表示返回第i
行和第j列的所有元素。也可以使用A[i:k,j:l]的形式来获得多行多列的子矩阵。
例如：
> A=matrix(1:12,3,4)
> A[2,3] #返回矩阵第2行第3列元素
[1] 8
> A[2,] #返回矩阵第2行所有元素
[1] 2 5 8 11
> A[,3] #返回矩阵第3列所有元素
[1] 7 8 9
> A[1:3,2] #返回矩阵第1到3行，且是第2列的元素
[1] 4 5 6
l??使用as.matrix()把非矩阵格式的转换成矩阵格式，函数is.matrix()可以辨别是否矩阵。
数组（array）可以看作是带有多个下标的类型相同的元素的集合。也可以看作是向量和
矩阵的推广，一维数组就是向量，二维数组就是矩阵。数组的生成函数是array()，其句法是：
array(data = NA, dim = length(data), dimnames = NULL)
其中data表示数据，可以为空，dim表示维数，dimnames可以更改数组的维度的名称。例如:
> (xx <- array(1:24,c(3,4,2))) # 产生维数为(3,4,2)的3维数组
, , 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
索引数组类似于索引矩阵，索引向量可以利用下标位置来定义；其中dim()函数可以返回
数组的维数，dim()还可以用来将向量转化成数组或矩阵(见下例)。数组也可以
用“+”、“-”、“*”、“/”以及函数等进行运算，其方法和矩阵相类似，这里不再详述。
> 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
>zz=c(2,5,6,8,1,4,6,9,10,7,3,5)
>dim(zz)=c(2,2,3)
#将向量转成维度为（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
分类型数据（category data）经常要把数据分成不同的水平或因子（factor）。比如，
学生的性别包含男和女两个因子。因子代表变量的不同可能的水平（即使在数据中不出现）
。在统计模型统计分析中十分有用，例如将0，1转换为’yes’,’no’就很方便，在R里可以
使用factor函数来创建因子，函数形式如下：
factor(x = character(), levels, labels = levels, exclude = NA, ordered = is.ordered(x))
其中，levels用来指定因子的水平；labels用来指定水平的名字；exclude表示在x中需要
排除的水平；ordered用来决定因子的水平是否有次序。
例如一组学生数据：
> y <- c("女","男","男","女","女","女","男")
> (f <- factor(y)) #生成因子
[1] 女 男 男 女 女 女 男
Levels: 女 男
> levels(f) #提取因子的水平
[1] "女" "男"
倘若要表示因子之间有大小顺序（考虑因子之间的顺序），则可以利用ordered（）函数产生。
> 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）这种数据对象的形式（数据对象形式）。列表是一个对
象的有序集合构成的对象，列表中包含的对象又称为它的分量（components），分量可以
是不同的模式或类型，如一个列表可以包括数值向量、逻辑向量、矩阵、字符、数组等。创
建列表的函数是list()，其句法是：list（变量1=分量1，变量2=分量2，….）。
例如：下面是某校部分学生的情况，其中，x、y、z分别表示班级、性别和成绩。
>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] "女" "男" "男" "女" "女" "女" "男"
$score
[1] 80 85 92 76 61 95 83
l??若要访问列表的某一成分，可以用LST[[1]],LST[[2]]的形式访问，要访问第二个分量的前三
个元素可以用LST[[2]][1:3]：
> LST[[3]] #返回列表的第三个成分的值
[1] 80 85 92 76 61 95 83
> LST[[2]][1:3] #返回列表第二个成分的第1到3元素
[1] "女" "男" "男“
由于分量可以被命名，这时，我们可以在列表名称后加$符号，再写上成分名称来访问列
表分量。其中成分名可以简写到可以与其它成分能够区分的最短程度，如LST$sc与LS
T$score表示同样的分量。例如：
> LST$score #返回socre值
[1] 80 85 92 76 61 95 83
> LST$sc #返回socre值
[1] 80 85 92 76 61 95 83
l??函数length（）、mode（）、names（）可以分别返回列表的长度（分量的数目）、数
据类型、列表里成分的名字。
l??在这里要注意LST[[1]]和LST[1]的差别，[[…]]是选择单个元素的操作符，而[…]是一个一般
通用的下标操作符。因此前者得到的是LST中的第一个对象，并且包含分量名字的命名列
表中的分量名字会被排除在外的1；而后者得到的则是LST中仅仅由第一个元素构成的子
列表。
1、数据框的生成
数据框（data frame）是一种矩阵形式的数据，但数据框中各列可以是不同类型的数据
。数据框每列是一个变量，每行是一个观测。数据框可以看成是矩阵（matrix）的推广，也
可以看作是一种特殊的列表对象（list）。数据框是R语言特有的数据类型，也是进行统计分
析最为有用的数据类型。不过对于可能列入数据框中的列表有如下一些限制：
l??分量必须是向量（数值，字符，逻辑），因子，数值矩阵，列表或者其他数据框。
l??矩阵，列表和数据框为新的数据框提供了尽可能多的变量，因为它们各自拥有列、元素或者
变量。
l??数值向量、逻辑值、因子保持原有格式，而字符向量会被强制转换成因子并且它的水平就是
向量中出现的独立值。
l??在数据框中以变量形式出现的向量结构必须长度一致，矩阵结构必须有一样的行数。
R语言中用函数data.frame ( )生成数据框，其句法是：
data.frame(..., row.names = NULL, check.rows = FALSE, ...)
数据框的列名默认为变量名，也可以对列名、行名进行重新命名。例如：
> (student <- data.frame(class=x,sex=y,score=z))
class sex score
1 1 女 80
2 1 男 85
3 2 男 92
4 2 女 76
5 3 女 61
6 3 女 95
7 3 男 83
> (student <- data.frame(x,y,z))
x y z
1 1 女 80
2 1 男 85
3 2 男 92
4 2 女 76
5 3 女 61
6 3 女 95
7 3 男 83
当然，我们也可以对数据框的行名进行修改，例如：
> row.names(student) <- c("王x","张x","赵x","刘x","黄x","孙x","李x")
> student
class sex score
王x 1 女 80
张x 1 男 85
赵x 2 男 92
刘x 2 女 76
黄x 3 女 61
孙x 3 女 95
李x 3 男 83
2、数据框的引用
l??以数组形式访问。数据框可以看作是特殊的数组。数组是储存数据的有效方法，可以按行或
列访问，就像电子表格一样，但输入的数据必须是同一类型。数据框可以看作数组是因为数
据框的列表示变量、行表示样本观察数，因此我们可以访问指定的行或列。
例如：
> student[,"score"] #返回y变量的所有样本观察数
[1] 80 85 92 76 61 95 83
> student[,3]
[1] 80 85 92 76 61 95 83
> student[1:5,1:3] #返回第1至第5行，第1至第3列的观察数
> student[,] #返回所有行所有列数据
2、数据框的引用
l??以列表形式访问数据框。列表比数据框更为一般、更为广泛。列表是对象的集合，而且这些
对象可以是不同类型的。数据框是特殊的列表，数据框的列看作向量，而且要求是同一类型
对象。以列表形式访问数据框，只要在列表名称后面加$符号，再写上变量名即可。例如：
> student$score
[1] 80 85 92 76 61 95 83
除了用$形式访问外，还可以用列表名[[变量名(号)]]形式访问：
> student[["score"]]
[1] 80 85 92 76 61 95 83
> student[[3]]
[1] 80 85 92 76 61 95 83
2、数据框的引用
还可以筛选出符合我们条件的数据，比如对上面的数据要得到成绩大于80分的学生，可
以按如下的方法得到。例如：
> student[student$score>80,]
class sex score
张x 1 男 85
赵x 2 男 92
孙x 3 女 95
李x 3 男 83
3、数据框绑定Attach()函数
数据框的主要用途是保存统计建模的数据。R软件的统计建模功能都需要以数据框为输入
数据。可把数据框当成一种矩阵来处理。在使用数据框的变量时可以用“数据框名$变量名”
的记法。但这样使用较麻烦，R软件提供了attach()函数可以把数据框中的变量“链接”到内
存中，将数据框“连接（绑定）”入当前的名字空间，从而可以直接用数据框中的变量名访
问而不必用“数据框名$变量名”这种格式。要取消连接，用函数detach（）即可。
3、数据框绑定Attach()函数
例如上面student数据框有三个变量，对于数据框里的变量我们不能直接引用，可以用“
数据框名$变量名”的格式，或是利用attach( )把数据框“连接（绑定）”入当前的名字空间。
> score
错误: 找不到对象‘score‘
> student$score
[1] 80 85 92 76 61 95 83
> attach(student)
> score
[1] 80 85 92 76 61 95 83
要取消连接，用函数detach（）即可。