R语言笔记

R语言杂七杂八

与R语言有关的应用工具

Shiny

Shiny:制作嵌入网页的交互式R程序的平台。Shiny 是一个开源的 R 包，它为使用 R 构建 Web 应用提供了一个优雅有力的 Web 框架。Shiny 帮助你在不需要前端知识的条件下将数据分析转变为可交互的 Web 应用。

Slidify

Slidify:制作和发布基于R的报告（PPT）

RPubs

RPubs:发布R语言开发项目。

探索性数据分析：

通过做图让我们了解数据的属性和模式。

统计推断：

基于数据得出正式结论的过程。有不确定性和

回归分析：

线性回归分析，用历史数据拟合线性模型来预测未来趋势。预测变量：面积，位置，楼龄。结果变量：房价。考察结果变量和预测变量之间是否有线性关系。

机器学习-分类问题：

训练模型+预测

R与Rstudio的获取与安装：

R:cran.r-project.org
Rstudio:rstudio.com
Powerful IDE for R —> Desktop

包（package）：一种扩展R基本功能的机制/集成了众多函数。

获取包

CRAN/Bioconductor/GitHub
CRAN中：install.packages(“name”)
GitHub中：install_github(name)

导入包：library(name)

R中自带的数据集：data()
输入：?数据集名称 就可以了数据详情了。

获取帮助：

1、?函数名 （调取相关帮助文档）
2、使用Google/Stackoverflow
3、如何提问：说明操作系统，R版本，包版本，报错信息。

R语言特点

1、开源免费
2、行业标准
3、小巧灵活
4、扩展包体系绘图工具
5、绘图功能
6、极简代码

R语言语法基础

R语言中的数据

R语言支持的数据类型：

character 字符型
numeric 数值型
integer 整型不
complex 负数型
boolean 布尔型/逻辑型

基本数据结构：

1、向量（数据必须一样）、因子 （分类变量）
2、数值变量：身高体重
3、分类变量：性别
4、矩阵（数据类型必须一样）、数据框（由向量组成，向量内部数据类型必须一样，向量之间不一定一样。）
5、数组（一般都三维或更高维的数据结构）、列表（类似于python的字典）
6、数据框

一维数据类型

向量

1、创建

1)、c()无条件定义向量
例如：(x =c(10,16,18)) 在R语言中=和<–等效，最外面的()表示直接输出x的内容

2)、冒号操作符：定义以1为步长的等差数列
例如：(x=1:10) 定义了一个1到10的向量。最外面的()表示直接输出x的内容

3)、seq(from, to, by, length, along.with) from起点 to终点 by步长 length向量长度 along.with元素个数
例如：(x=seq(5,by=2,length=8))定义一个从5开始以2为步长有8个元素的向量。
(y=seq(10, by=3, along.with=x))定义一个从10开始的以3为步长的长度等于x长度（也就是8）的向量。along.with后面必须跟上另外一个向量。

2、提取子集

数字下标（正数、负数） 2取出2号元素 -2取出除2以外的说所有元素
which()函数 按条件来筛选
例如：(x([1:5]))
(x[c(1,2,3,4,5)] 将下标为1，2，3，4，5的元素取出来。
(x[seq(1,5,1)])
(y[-5:-1]) 取出除了下标为5,4,3,2,1以外的元素。负号就是扣掉元素。
(y[which(y>5)]) whchi返回的是下标，不是元素。提取向量y中大于5的元素。

在R语言中，利用下标一次可以提取多个元素。下标可以是一个向量。

将鼠标放到一条要执行的语句上，再按contrl+enter就执行了。

因子

PS：每一个元素的数据类型必须一样，因子应用于分类变量，因子中的分类变量的类型叫做因子的水平，是一个文字串。每个分类都有文本标签，所以因子也有文本标签。level是数字或者其他字母代表级别，level对应着labels，labels是具体的文本。

1、创建

1)、利用factor()函数来构造因子
例子：

(x=c("a","b","o","ab","a","ab"))  #先创建一个向量
(x=factor(c("a","b","o","ab","a","ab")))  #将这个向量转化成因子格式
unclass(x)
输出：
[1]a b o ab a ab
Levels：a ab b o
[1]1 3 4 2 1 2
attr(,"levels")
[1] "a" "ab" "b" "o"

从输出可以看出level在内存中实际上是以数字进行存储的。默认label与数字的对应关系是和标签的内容在字典中的位置所决定的。所以’a’ ‘b’ ‘ab’ ‘o’ 分别对应1 2 3 4

使用levels可以自定义level对应关系：

 #在levels=c()中，先后出现的是"a", "b", "o", "ab"也就对应1 2 3 4
(x=factor(c("a","b","o","ab","a","ab"),levels=c("a", "b", "o", "ab"))) 
unclass(x)
#输出
[1] a  b  o  ab a  ab
Levels: a b o ab
[1] 1 2 3 4 1 4
attr(,"levels")
[1] "a"  "b"  "o"  "ab"

从输出可以看出通过我们的自定义，a依旧是对应1，但是b o ab的对应关系由3 4 2变成2 3 4，符合levels=c()中b o ab出现的次序。

2)、利用gl()函数来创建因子

#声明4个量，每个重复3次。
> (f2=gl(4,3,labels = c(‘blue‘,‘red‘,‘green‘,‘yellow‘)))
 [1] blue   blue   blue   red    red    red    green  green  green  yellow
[11] yellow yellow
Levels: blue red green yellow
#查看级别
> unclass(f2)
 [1] 1 1 1 2 2 2 3 3 3 4 4 4
attr(,"levels")
[1] "blue"   "red"    "green"  "yellow"

2、提取子集

1)、用向量组成下标来提取

> (f2=gl(4,3,labels = c(‘blue‘,‘red‘,‘green‘,‘yellow‘)))
 [1] blue   blue   blue   red    red    red    green  green  green  yellow
[11] yellow yellow
> (f2[1:5])
[1] blue blue blue red  red 
Levels: blue red green yellow
> (f2[seq(5,by=1,length=3)])
[1] red   red   green
Levels: blue red green yellow
> (f2[-1:-5])
[1] red    green  green  green  yellow yellow yellow
Levels: blue red green yellow

2)、利用which来做条件选择提取

> (f2[which(f2==‘blue‘)])
[1] blue blue blue
Levels: blue red green yellow
> (f2[which(f2==‘red‘)])
[1] red red red
Levels: blue red green yellow

二维数据类型

矩阵

一个有行有列的二维结构，矩阵中每个元素的数据类型必须完全一样，要么都是字符串，要么都是整型，要么都是整形。

1、生成矩阵

1)、matrix()方法

举例：

#1:6是一个1到6 的向量,将1到6这6个元素填充到之后申明的那个2*3的矩阵中，需要注意的是这里元素是默认一列一列进行填充的。
> (x=matrix(1:6,nrow=2,ncol=3))
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
#设置byrow=T修改填充方式为按行来填充
> (x=matrix(1:6,nrow=2,ncol=3,byrow=T))
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

2)、 修改dim属性来完成由向量派生矩阵

举例：

> (x=1:18) #先生成一个向量
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18
> dim(x)=c(3,6);x  #再更改向量的dim属性，dim是数据的维度属性。将向量改成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

3)、 由向量组合生成

举例：

(x=1:10)
(y=11:20)
(z=21:30)
> (m1=rbind(x,y,z)) #按行来生成矩阵 将x,y,z分别作为三行
  [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
x    1    2    3    4    5    6    7    8    9    10
y   11   12   13   14   15   16   17   18   19    20
z   21   22   23   24   25   26   27   28   29    30

> (m2=cbind(x,y,z))#按列来生成矩阵 将x,y,z分别作为三列
       x  y  z
 [1,]  1 11 21
 [2,]  2 12 22
 [3,]  3 13 23
 [4,]  4 14 24
 [5,]  5 15 25
 [6,]  6 16 26
 [7,]  7 17 27
 [8,]  8 18 28
 [9,]  9 19 29
[10,] 10 20 30

2、操作

1)、通过下标访问元素

举例：

> x
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
> (x[2,3]) #访问2,3位置的元素
[1] 6
> (x[,2]) #访问第2列
[1] 2 5
> (x[2,]) #访问第2行
[1] 4 5 6

#矩阵的访问，在行和列这两维度上都是支持向量的。
> (x[,c(2,3)])  #访问第2，3列元素的信息
     [,1] [,2]
[1,]    2    3
[2,]    5    6

> (x <- matrix(1:12,nrow = 4,byrow=T))
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9
[4,]   10   11   12
> (x[c(2,3),] )#访问第2，3行元素的信息
     [,1] [,2] [,3]
[1,]    4    5    6
[2,]    7    8    9

> (x[c(1,2),c(3,4)]) #提取第1,2行的第3,4列元素组成一个子矩阵。
     [,1] [,2]
[1,]    3    4
[2,]    7    8

2)、通过利用给行、列的命名的名字来访问

举例：

> (x=matrix(1:24,ncol=6))
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    5    9   13   17   21
[2,]    2    6   10   14   18   22
[3,]    3    7   11   15   19   23
[4,]    4    8   12   16   20   24
> rownames(x) = c(‘R1‘,‘R2‘,‘R3‘,‘R4‘)
> colnames(x) = c(‘C1‘,‘C2‘,‘C3‘,‘C4‘,‘C5‘,‘C6‘)
> x
   C1 C2 C3 C4 C5 C6
R1  1  5  9 13 17 21
R2  2  6 10 14 18 22
R3  3  7 11 15 19 23
R4  4  8 12 16 20 24

> x[‘R4‘,‘C6‘] #访问第4行的第6列
[1] 24 
> x[c(‘R2‘,‘R3‘),c(‘C2‘,‘C3‘)] #访问第2,3行的第2,3列
   C2 C3
R2  6 10
R3  7 11

3、矩阵运算

向量运算和矩阵运算统一

1)、加减运算

1）、矩阵加数字，对应矩阵中每个元素加上相应的数字。
2）、相同规模的矩阵相加。
举例

> (m1=matrix(1:12,nrow = 3))
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
> (m2=matrix(13:24,nrow = 3))
     [,1] [,2] [,3] [,4]
[1,]   13   16   19   22
[2,]   14   17   20   23
[3,]   15   18   21   24
> m1+10
     [,1] [,2] [,3] [,4]
[1,]   11   14   17   20
[2,]   12   15   18   21
[3,]   13   16   19   22

> m1+m2
     [,1] [,2] [,3] [,4]
[1,]   14   20   26   32
[2,]   16   22   28   34
[3,]   18   24   30   36

> m2-m1
     [,1] [,2] [,3] [,4]
[1,]   12   12   12   12
[2,]   12   12   12   12
[3,]   12   12   12   12

2)、乘法运算：

(m1=matrix(1:12,n row=3,ncol=4))
(m2=matrix(13:24,n row=3,ncol=4))
（1）、数乘，矩阵乘以数字，也就是每个元素乘以相应的数字。
举例：m1*10

> m1*10
     [,1] [,2] [,3] [,4]
[1,]   10   40   70  100
[2,]   20   50   80  110
[3,]   30   60   90  120

（2）、对应元素相乘（两个规模相同的矩阵的乘法运算），两个矩阵中对应元素相乘组成新的矩阵。这种乘法是R语言创造的，不是数学中的矩阵乘法。
举例：m1*m2

> m1*m2
     [,1] [,2] [,3] [,4]
[1,]   13   64  133  220
[2,]   28   85  160  253
[3,]   45  108  189  288

（3）、矩阵乘法，记住“左行右列”，乘号左边的矩阵出第A行与乘号右边的矩阵出的第B列对应元素相乘的和，组成新的列表的第[A,B]号元素。矩阵乘法的条件是，左边的矩阵的列数等于右边矩阵的行数。例如：矩阵T乘以矩阵R，T是a*b的规模，R是c*d的规模，则T*R的条件是b=c。最后得到的新矩阵是a*d的新矩阵。这种乘法才是线性代数中的矩阵相乘。
举例：m1 %*% t(m2)

#数学上的矩阵相乘，要求左边的矩阵的列数等于右边矩阵的行数,而m1和m2都是3*4的矩阵，需要将m2转置成4*3才可以完成数学相乘，最终得到的是一个3*3的矩阵。
> m1 %*% t(m2)
     [,1] [,2] [,3]
[1,]  430  452  474
[2,]  500  526  552
[3,]  570  600  630

单位矩阵：所有元素都是1，必须是方阵。必须是方阵。

3)、使用diag生成对角阵

对角矩阵：对角线上的元素都是1，其他位置的元素必须是0。必须是方阵。
举例：

#1
> diag(4)#生成4*4的对角矩阵
     [,1] [,2] [,3] [,4]
[1,]    1    0    0    0
[2,]    0    1    0    0
[3,]    0    0    1    0
[4,]    0    0    0    1
#2
diag(c(1,2,3,4,5)) #生成对角线上是1,2,3,4的4*4对角矩阵
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    0    0    0    0
[2,]    0    2    0    0    0
[3,]    0    0    3    0    0
[4,]    0    0    0    4    0
[5,]    0    0    0    0    5
#3
> (a=matrix(1:16,4,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) #提取a矩阵上的对角元素
[1]  1  6 11 16

4)、矩阵转置

把行才换成列，把列换成行。（2,3）元素在转置之后变成了（3,2元素），用t()方法就可以了

举例

> (x=matrix(1:15,nrow=3))
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    4    7   10   13
[2,]    2    5    8   11   14
[3,]    3    6    9   12   15
> (t(x))
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9
[4,]   10   11   12
[5,]   13   14   15

5)、矩阵的特征值和特征向量

6)、矩阵的逆

举例：

> (x=matrix(rnorm(16,10,2),4,4)) #生成一个由16的随机数组成的4*4矩阵 rnorm(随机数个数,基准数字,偏移范围)
         [,1]      [,2]      [,3]      [,4]
[1,] 8.829662  8.570598  9.841040  9.944716
[2,] 8.097175 11.455700  8.370946  8.990764
[3,] 8.847266 10.421503  9.706328  7.751728
[4,] 7.471214 13.794859 10.761544 10.298522

> (y=solve(x)) #使用solve方法求逆
            [,1]       [,2]        [,3]        [,4]
[1,] -0.03594978  0.3024169  0.18049339 -0.36515764
[2,] -0.23173767  0.1736797  0.03126641  0.04861701
[3,]  0.07765014 -0.6111155  0.25961327  0.26311887
[4,]  0.25535134  0.1865548 -0.44410841  0.02193914

> x %*% y  #互逆的两个矩阵，相乘是一个对角矩阵,由输出可见，对角线上的元素基本上都是1，其他位置的元素基本接近0。
             [,1]         [,2]          [,3]          [,4]
[1,] 1.000000e+00 6.661338e-16 -8.881784e-16 -3.053113e-16
[2,] 0.000000e+00 1.000000e+00  4.440892e-16  3.053113e-16
[3,] 2.220446e-16 6.661338e-16  1.000000e+00 -4.440892e-16
[4,] 4.440892e-16 6.661338e-16  8.881784e-16  1.000000e+00

(y=solve(x)) #使用solve方法求逆

7)、求解线性方程组

举例：

> (x=matrix(rnorm(16,10,2),4,4))
          [,1]      [,2]      [,3]      [,4]
[1,]  9.375275  8.449186  9.742935 11.062033
[2,]  9.132176 12.227294  9.683535  6.924871
[3,]  9.988475 10.483249 11.765395 10.387113
[4,] 11.948738 11.510251 10.458448 12.582581

> (b = 1:4)
[1] 1 2 3 4
> solve(x,b)
[1] 11.784273 -6.028383  1.323694 -6.458354

实际上是求解
a11*x1+a12*x2+a13*x3+a14*x4 = 1
a21*x1+a22*x2+a23*x3+a24*x4 = 2
a31*x1+a32*x2+a33*x3+a34*x4 = 3
a41*x1+a42*x2+a43*x3+a44*x4 = 4
这个线性方程组的x1、x2、x3、x4的解。

数据框

数据框由记录和域组成，域就是列，记录就是行。数据框要求每一条域中的元素的数据类型必须一样。

1、创建数据框

数据框的本质就是一个二维的数据表
利用data.frame()创建数据框
举例：

>(a=data.frame(fx=rnorm(10,10,2),
              fy=runif(10,10,20),
              fmonth=1:10)) #一个有10条记录3个域的数据框

          fx       fy fmonth
1   9.636283 11.33449      1
2   9.143942 15.93721      2
3   9.445728 10.29192      3
4   8.082495 11.27979      4
5   7.975052 16.61200      5
6   6.326113 15.15761      6
7  10.333080 18.70560      7
8  12.059794 18.09572      8
9   8.612815 17.04949      9
10 13.405404 18.68178     10        

2、操作

1)、访问元素

$、[]下标访问
举例：

> a[1,1] #访问第一条记录的第一个域
[1] 9.636283
> a[1,] #访问第一条记录的所有域
        fx       fy fmonth
1 9.636283 11.33449      1
> a[,2] #访问所有巨记录的第二个域
 [1] 11.33449 15.93721 10.29192 11.27979 16.61200 15.15761 18.70560 18.09572 17.04949
[10] 18.68178
> (y3=a$fx)  #访问数据框的fx数据域，双中括号也有想推开那个的效果
 [1]  9.636283  9.143942  9.445728  8.082495  7.975052  6.326113 10.333080 12.059794
 [9]  8.612815 13.405404
> (y3 = a [[1]]) #访问数据框的第一个域，也就是fx数据域
 [1]  9.636283  9.143942  9.445728  8.082495  7.975052  6.326113 10.333080 12.059794
 [9]  8.612815 13.405404

 #注意对比以下三个a[[1]]和a[[‘fx‘]]、a$fxshi
> (y3 = a [[1]][2]) #访问第二条记录的第一个数据域，等价于(y3=a [[‘fx‘]][2])
[1] 9.143942
> (y3 = a[[‘fx‘]][2])
[1] 9.143942
> (y3= a$fx[2])
[1] 9.143942

2)、attach、detach

挂载和去挂载方法

举例：

> fx #a没有在搜索路径，输入域名fx，不能找到fx
Error: object ‘fx‘ not found
> attach(a)
> search() #查看搜索路径，a已经被添加到了搜索路径。不用像之前y3=a $fx这样每次都指明搜索路径了。
 [1] ".GlobalEnv"        "a"                 "tools:rstudio"     "package:stats"    
 [5] "package:graphics"  "package:grDevices" "package:utils"     "package:datasets" 
 [9] "package:methods"   "Autoloads"         "package:base"  
> fx #这时再搜索fx，就能找到这个域了
 [1]  1  2  3  4  5  6  7  8  9 10
 > detach(a) #去挂载a
> search() #查看搜索路径，a已经从搜索路径中移除了。
 [1] ".GlobalEnv"        "tools:rstudio"     "package:stats"     "package:graphics" 
 [5] "package:grDevices" "package:utils"     "package:datasets"  "package:methods"  
 [9] "Autoloads"         "package:base" 
 > fx #再搜索fx就找不到了
Error: object ‘fx‘ not found

3)、with、within

with方法能用来重写数据框的元素，先全部清除再重新写入。within 可以向数据框里写入新的数据或者覆盖原数据
举例：

> (a=data.frame(fx=rnorm(10,10,2),
+ fy=runif(10,10,20),
+ fmonth=1:10)) #一个有10条记录3个域的数据框
          fx       fy fmonth
1  13.443635 10.06230      1
2  13.006166 12.27293      2
3   6.094351 12.29516      3
4  13.028642 10.65463      4
5   9.751618 16.13500      5
6   9.185354 12.75577      6
7  10.998482 19.68448      7
8   8.311340 19.97293      8
9   9.832441 15.79029      9
10 12.850348 10.49540     10
> a = with(a,{fx = rnorm (10,10,20)})
> a #a = with(a,{fx = rnorm (10,10,20)})执行之后原来的数据被清除，只有fx = rnorm (10,10,20)在里面。
 [1]  22.891675 -21.576549  27.226358 -10.035888 -29.819505  29.220687  38.918151
 [8]  21.573663   7.863019   2.488882
> a
          fx       fy fmonth
1   9.822649 11.83050      1
2   9.385922 15.01415      2
3  11.001721 19.85722      3
4  13.204639 13.34855      4
5   9.310447 15.04144      5
6   8.065048 12.83656      6
7  12.037258 10.62446      7
8   8.942234 10.14267      8
9  13.324897 14.67673      9
10 12.710792 11.68848     10
> a = within(a ,{ #使用within，数据框原来的数据是不会全部清除的。
+ fx=1:10  #修改fx由随机数变成1:10
+ abc=2:11 #添加abc这个域
+ })
> a
   fx       fy fmonth abc
1   1 11.83050      1   2
2   2 15.01415      2   3
3   3 19.85722      3   4
4   4 13.34855      4   5
5   5 15.04144      5   6
6   6 12.83656      6   7
7   7 10.62446      7   8
8   8 10.14267      8   9
9   9 14.67673      9  10
10 10 11.68848     10  11

> a\$fz = a\$fx + a\$fy  #新增一个数据域，为fx和fy的和，可以直接使用$符来添加数据域
> a
   fx       fy fmonth abc       fz
1   1 11.83050      1   2 12.83050
2   2 15.01415      2   3 17.01415
3   3 19.85722      3   4 22.85722
4   4 13.34855      4   5 17.34855
5   5 15.04144      5   6 20.04144
6   6 12.83656      6   7 18.83656
7   7 10.62446      7   8 17.62446
8   8 10.14267      8   9 18.14267
9   9 14.67673      9  10 23.67673
10 10 11.68848     10  11 21.68848

4)、subset

subset是一个条件过滤的语句

举例：

#fx>1&fmonth==8表示将符合条件的行记录（行）取出来，select=c(fx,fb,fz)表示将这些行记录的fx和fb、fz域（列）取出来。
> b = subset(a, fx>1&fmonth==8,select=c(fx,fb,fz))
> b
  fx      fb       fz
8  8 163.284 18.14267

5)、edit和fix

b = edit(a) edit是Rstudio的一个可视化工具，将a修改之后的数据存到b里面。

fix(a) fix也是Rstudio的一个可视化工具，直接在a基础上修改数据框的内容。

高维的数据类型

列表

什么数据都可以在列表里面存储，元素被称为成份，R语言中的数组是矩阵的延伸，必须是三维以上的数据结构。列表主要是用于函数调用和返回。

1、创建 list()

举例：

#创造一个列表，里面有三个元素x,y,z，分别是数组，矩阵，数据框。
> (a=list(x=1:10,y=matrix(1:16,4,4),z=data.frame()))
$x
 [1]  1  2  3  4  5  6  7  8  9 10

$y
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16

$z
data frame with 0 columns and 0 rows

2、操作

举例：

> names(a) #查看列表成份
[1] "x" "y" "z"
> names(a) = c(‘C1‘,‘C2‘,‘C3‘) #修改列表成份名称
> names(a)
[1] "C1" "C2" "C3"
> (c = a[‘C2‘]) #利用成分的名称访问数，这时c是一个列表，不是矩阵，不能用c[2,3]来访问数据
$C2
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16
> (c[1,2]) #c是一个列表，不是矩阵，不能用c[2,3]
Error in c[1, 2] : incorrect number of dimensions
> class(c)  #查看c的数据结构是列表
[1] "list"


> (c = a[[‘C2‘]])  #通过这样的方式来访问C2，C2就是矩阵了
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16
> class(c)
[1] "matrix"
> (c[1,2]) #能用c[2,3]来访问数据
[1] 5
> (c=a$C2)   #c=a$C2和c = a[[‘C2‘]]效果一样
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16
> class(c)
[1] "matrix"

数组：

1、利用array函数创建数组

举例：

> (a = array(1:60,c(3,4,5)))
, , 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

, , 3

     [,1] [,2] [,3] [,4]
[1,]   25   28   31   34
[2,]   26   29   32   35
[3,]   27   30   33   36

, , 4

     [,1] [,2] [,3] [,4]
[1,]   37   40   43   46
[2,]   38   41   44   47
[3,]   39   42   45   48

, , 5

     [,1] [,2] [,3] [,4]
[1,]   49   52   55   58
[2,]   50   53   56   59
[3,]   51   54   57   60

2、访问

利用下来访问元素

举例：

> (a[1,2,3])
[1] 28

类型转换

1、转换安全级别：字符>数字>布尔

由数字转字符，是安全的，但是由字符转数字是不安全的。因为字符的安全级别比数字高，由较高安全级别的数据类型转化成较低安全级别的数据类型是不安全的。

• mode(x) #查看数据类型
• class(x) #查看结构类型

举例：

> (x = c(1:2,"hello",T)) #1:2是数字，"hello"是字符串，T是布尔值 由于隐式的数据类型的转换，输出x全部都是字符串
[1] "1"     "2"     "hello" "TRUE" 
> mode(x)   #查看数据类型
[1] "character"
> class(x) #查看结构类型，mode()和class()用在向量上的时候，都是character，字符型的数据
[1] "character"

> (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
> mode(a)
[1] "numeric"
> class(a)  #mode方法和class方法用在矩阵或者数据框上的时候使不同的结果
[1] "matrix"

2、数据结构转换：

• is.charatcer [is.****] #检查是否是字符串
• as.characer [as.****] #转换成字符串

举例：

> x
[1] "1"     "2"     "hello" "TRUE" 
> (a = matrix(1:20,nrow=4))
     [,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

> class(x)
[1] "character"
> class(a)
[1] "matrix"

> is.matrix(a) #判断a是不是矩阵
[1] TRUE
> is.matrix(x)
[1] FALSE
> (as.matrix(x)) #将不是矩阵的x转换成矩阵
     [,1]   
[1,] "1"    
[2,] "2"    
[3,] "hello"
[4,] "TRUE"