R语言笔记之数据篇

R语言杂七杂八

与R语言有关的应用工具

Shiny

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

Slidify

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

RPubs

• 你可以在RPubs上面发布，查看报告。

kaggle

• 欢迎来到kaggle挑战自我。

探索性数据分析：

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

统计推断：

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

回归分析：

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

机器学习-分类问题：

训练模型+预测

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版本，包版本，报错信息。
4. str(函数名)可以之间看到函数的参数表，其中FUN代表函数。

R语言特点

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

R语言语法基础之数据篇

R语言中的数据

R语言支持的数据类型：

1. character 字符型
2. numeric 数值型
3. integer 整型不
4. complex 负数型
5. boolean 布尔型/逻辑型

基本数据结构

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

一维数据类型

向量 vocter

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后面必须跟上另外一个向量。

4)、vector(“向量的数据类型”,length=长度)

> (x=vector("character",length = 10)) #创建一个有10个空值的向量 [1] "" "" "" "" "" "" "" "" "" ""

2、提取子集

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

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

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

因子 factor

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

分类数据分为有序分类数据和无序分类数据

1、创建

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

> (x=factor(c("a","b","o","ab","a","ab")))  #将这个向量转化成因子格式[1] a  b  o  ab a  abLevels: a ab b o> unclass(x)    #去除属性影响[1] 1 3 4 2 1 2attr(,"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  abLevels: a b o ab[1] 1 2 3 4 1 4attr(,"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 yellowLevels: blue red green yellow#查看级别> unclass(f2) [1] 1 1 1 2 2 2 3 3 3 4 4 4attr(,"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   greenLevels: blue red green yellow> (f2[-1:-5])[1] red    green  green  green  yellow yellow yellowLevels: blue red green yellow

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

> (f2[which(f2=='blue')])[1] blue blue blueLevels: blue red green yellow> (f2[which(f2=='red')])[1] red red redLevels: blue red green yellow

二维数据类型

矩阵 matrix

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

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    10y   11   12   13   14   15   16   17   18   19    20z   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,3,drop=FALSE]  #访问2,3位置的元素，设置drop=FALSE,输出的就是一个矩阵。     [,1][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> x  v1 v2 v31  1  6 112  2  7 NA3  3  8 134  4  9 NA5  5 10 15#x$v1>2、which(x$v1>2)、x[which(x$v1>2),]注层层递进的变化> x$v1>2 #x$v1>2直接查看v1里面有哪些是大于2的，直接返回对应的TRUE或者FALSE。[1] FALSE FALSE  TRUE  TRUE  TRUE> which(x$v1>2) #which(x$v1>2)返回的是v1中大于2的数据的下标[1] 3 4 5> x[which(x$v1>2),] #x[which(x$v1>2),]以矩阵形式将结果返回  v1 v2 v33  3  8 134  4  9 NA5  5 10 15> subset(x,v2>2) #使用subset函数  v1 v2 v31  1  6 112  2  7 NA3  3  8 134  4  9 NA5  5 10 15

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

• rownames 行命名
• colnames 列命名
• dimnames 整体命名

举例：

> (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')> dimnames(x)=list(c('R1','R2','R3','R4'),c('C1','C2','C3','C4','C5','C6'))> x   C1 C2 C3 C4 C5 C6R1  1  5  9 13 17 21R2  2  6 10 14 18 22R3  3  7 11 15 19 23R4  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 C3R2  6 10R3  7 11

3)、查看矩阵的行数和列数

> (x=matrix(1:20,nrow=5))     [,1] [,2] [,3] [,4][1,]    1    6   11   16[2,]    2    7   12   17[3,]    3    8   13   18[4,]    4    9   14   19[5,]    5   10   15   20> dim(x)[1] 5 4

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#2diag(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的解。

8)、矩阵拼接

• 使用cbind()或者rbind()来拼接矩阵

举例

> (y1=matrix(1:6,nrow=2))     [,1] [,2] [,3][1,]    1    3    5[2,]    2    4    6> (y2=matrix(1:6,nrow=2))     [,1] [,2] [,3][1,]    1    3    5[2,]    2    4    6> (y3=cbind(y1,y2))   #按列拼接     [,1] [,2] [,3] [,4] [,5] [,6][1,]    1    3    5    1    3    5[2,]    2    4    6    2    4    6> (y3=rbind(y1,y2))  #按行拼接     [,1] [,2] [,3][1,]    1    3    5[2,]    2    4    6[3,]    1    3    5[4,]    2    4    6

数据框 data frame

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

1、利用data.frame()创建数据框

数据框的本质就是一个二维的数据表

举例：

>(a=data.frame(fx=rnorm(10,10,2),              fy=runif(10,10,20),              fmonth=1:10)) #一个有10条记录3个域的数据框          fx       fy fmonth1   9.636283 11.33449      12   9.143942 15.93721      23   9.445728 10.29192      34   8.082495 11.27979      45   7.975052 16.61200      56   6.326113 15.15761      67  10.333080 18.70560      78  12.059794 18.09572      89   8.612815 17.04949      910 13.405404 18.68178     10        

2、操作

1)、访问元素

$、[]下标访问
举例：

> a[1,1] #访问第一条记录的第一个域[1] 9.636283> a[1,] #访问第一条记录的所有域        fx       fy fmonth1 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$fx> (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> (x=data.frame(v1=1:5,v2=6:10,v3=11:15))  v1 v2 v31  1  6 112  2  7 123  3  8 134  4  9 145  5 10 15> x$v3[c(2,4)]=NA  #设置缺省值> x  v1 v2 v31  1  6 112  2  7 NA3  3  8 134  4  9 NA5  5 10 15> x[(x$v1<4 & x$v2>=8),] #添加筛选条件  v1 v2 v33  3  8 13> x[(x$v1<4 | x$v2>=8),]  v1 v2 v31  1  6 112  2  7 NA3  3  8 134  4  9 NA5  5 10 15

2)、attach、detach

挂载和去挂载方法

举例：

> fx #a没有在搜索路径，输入域名fx，不能找到fxError: 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 fmonth1  13.443635 10.06230      12  13.006166 12.27293      23   6.094351 12.29516      34  13.028642 10.65463      45   9.751618 16.13500      56   9.185354 12.75577      67  10.998482 19.68448      78   8.311340 19.97293      89   9.832441 15.79029      910 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 fmonth1   9.822649 11.83050      12   9.385922 15.01415      23  11.001721 19.85722      34  13.204639 13.34855      45   9.310447 15.04144      56   8.065048 12.83656      67  12.037258 10.62446      78   8.942234 10.14267      89  13.324897 14.67673      910 12.710792 11.68848     10> a = within(a ,{ #使用within，数据框原来的数据是不会全部清除的。+ fx=1:10  #修改fx由随机数变成1:10+ abc=2:11 #添加abc这个域+ })> a   fx       fy fmonth abc1   1 11.83050      1   22   2 15.01415      2   33   3 19.85722      3   44   4 13.34855      4   55   5 15.04144      5   66   6 12.83656      6   77   7 10.62446      7   88   8 10.14267      8   99   9 14.67673      9  1010 10 11.68848     10  11> a\$fz = a\$fx + a\$fy  #新增一个数据域，为fx和fy的和，可以直接使用$符来添加数据域> a   fx       fy fmonth abc       fz1   1 11.83050      1   2 12.830502   2 15.01415      2   3 17.014153   3 19.85722      3   4 22.857224   4 13.34855      4   5 17.348555   5 15.04144      5   6 20.041446   6 12.83656      6   7 18.836567   7 10.62446      7   8 17.624468   8 10.14267      8   9 18.142679   9 14.67673      9  10 23.6767310 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       fz8  8 163.284 18.14267

5)、edit和fix

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

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

高维数据类型

高维数据中，数组和列表的区别是，数组中元素的类型必须是相同的，而列表中的成分不一定一样。

列表 list

什么数据都可以在列表里面存储，元素被称为成份，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$zdata 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"#查看列表中嵌套的列表的元素> (x=list(a=list(1,2,3,4),b=c('Monday','Tuesday')))$a$a[[1]][1] 1$a[[2]][1] 2$a[[3]][1] 3$a[[4]][1] 4$b[1] "Monday"  "Tuesday"> (x[[1]][[3]])  #查看子列表中的第3个元素的内容[1] 3> (x[[1]][3])  #查看子列表中的第3个元素[[1]][1] 3> (x[[c(1,3)]]) #查看第一个元素的第三个内容[1] 3    > (x[[c(2,2)]]) #查看第二个元素的第二个内容[1] "Tuesday"#列表对元素有不完全匹配的功能> (y=list(asdfg=1:10,rtytre=11:20))  #先生成一个有两个成分的元素$asdfg [1]  1  2  3  4  5  6  7  8  9 10$rtytre [1] 11 12 13 14 15 16 17 18 19 20> y$asdfg   #输入完整的名字 [1]  1  2  3  4  5  6  7  8  9 10> y$a       #输入开头字母一样可以完成匹配 [1]  1  2  3  4  5  6  7  8  9 10> y[['asdfg']] [1]  1  2  3  4  5  6  7  8  9 10> y[['a',exact = FALSE]] #输入开头字母一样可以完成匹配，不过需要设置exact = FALSE关闭精确匹配 [1]  1  2  3  4  5  6  7  8  9 10

数组 array

1、利用array函数创建数组

举例：

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

日期和时间 date

Date

• Date 距离19701-01-01的天数/date()/Sys.Date()
• weekdays() / months() /quarters()/as.Date/julian

1、常用函数

举例

> (x=date()) #查看当前的时间[1] "Sat May 07 01:51:49 2016"> class(x)[1] "character"> (x2=Sys.Date()) #查看当前的日期[1] "2016-05-07"> (x3=as.Date("2016-06-08")) #将普通的数据转化成date型数据[1] "2016-06-08"> class(x3)[1] "Date"> weekdays(x3) #查看是星期几[1] "星期三"> months(x3)  #查看是哪一个月[1] "六月"> quarters(x3) #查看是那个季度 Q2代表是第二个季度[1] "Q2"> julian(x3) #查看，相距1970-01-01过去多少天[1] 16960attr(,"origin")[1] "1970-01-01"

2、计算

举例

> (x3=as.Date("2016-06-08"))[1] "2016-06-08"> (x4=as.Date("2016-01-03"))[1] "2016-01-03"> (x3-x4) #相减Time difference of 157 days> as.numeric(x3-x4) #只得到数字[1] 157

POSIXct/POSIXIt

• POSIXct 整数，用于存入到数据框。
• POSIXlt 列表，还包含星期、年、月、日等信息
• Sys.time() 打印举例1970-01-01的秒数

举例

> (x=Sys.time()) #查看当前时间[1] "2016-05-07 02:06:11 CST"> class(x)  [1] "POSIXct" "POSIXt" > (p=as.POSIXlt(x))  #POSIXct转成POSIXlt [1] "2016-05-07 02:08:28 CST"> class(p)[1] "POSIXlt" "POSIXt" > names(unclass(p)) #unclass把内容列下，把属性去掉。names获取名称 [1] "sec"    "min"    "hour"   "mday"   "mon"    "year"   "wday"   "yday"   "isdst" [10] "zone"   "gmtoff">  p$sec   #查看信息[1] 28.09093

普通数据格式转换成date型数据

> (x1 = 'Jan 1，2015 01:01')[1] "Jan 1，2015 01:01"> strptime(x1,'%B %d，%Y %H:%M')[1] '2015-01-01 01:01:00 CST'

类型转换

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、数据结构转换

1）、使用函数进行数据结构的转变

• 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" 

2）、通过修改维度信息改变数据的结构

举例

#第一示例> (y=1:10) [1]  1  2  3  4  5  6  7  8  9 10> dim(y)=c(2,5) #将一维的向量修改为二维的数组> y     [,1] [,2] [,3] [,4] [,5][1,]    1    3    5    7    9[2,]    2    4    6    8   10#第二示例> (x=matrix(1:20,nrow=5))     [,1] [,2] [,3] [,4][1,]    1    6   11   16[2,]    2    7   12   17[3,]    3    8   13   18[4,]    4    9   14   19[5,]    5   10   15   20> (dim(x)=c(5,2,2))  #将二维的数组修改为三维的列表[1] 5 2 2> x, , 1     [,1] [,2][1,]    1    6[2,]    2    7[3,]    3    8[4,]    4    9[5,]    5   10, , 2     [,1] [,2][1,]   11   16[2,]   12   17[3,]   13   18[4,]   14   19[5,]   15   20

缺省数据过滤

1、单个数据的缺省值过滤

> (x=c(1,NA,2,NA,3))[1]  1 NA  2 NA  3> x[!is.na(x)][1] 1 2 3

2、过滤出多个数据中相同位置都不是缺省值的对应数据使用complete.cases()函数

> (x=c(1,6,2,NA,3))[1]  1  6  2 NA  3> (y=c("a","b",NA,"c",NA))[1] "a" "b" NA  "c" NA > (t=c('2',6,'8','9','10'))[1] "2"  "6"  "8"  "9"  "10"> (z=complete.cases(x,y,t)) [1]  TRUE  TRUE FALSE FALSE FALSE> x[z][1] 1 6> y[z][1] "a" "b"> t[z][1] "2" "6"> library(datasets)  #导入datasets数据集> head(airquality)  #查看datasets中airquality数据开头  Ozone Solar.R Wind Temp Month Day1    41     190  7.4   67     5   12    36     118  8.0   72     5   23    12     149 12.6   74     5   34    18     313 11.5   62     5   45    NA      NA 14.3   56     5   56    28      NA 14.9   66     5   6#由输出可见第5、6号记录分别在第一个域和第一、二个域上是有缺省值的。> g=complete.cases(airquality)> airquality[g,][1:10,] #选择airquqlity中没有缺省值的那些记录，保留所有的域。查看1到10行，列全选。   Ozone Solar.R Wind Temp Month Day1     41     190  7.4   67     5   12     36     118  8.0   72     5   23     12     149 12.6   74     5   34     18     313 11.5   62     5   47     23     299  8.6   65     5   78     19      99 13.8   59     5   89      8      19 20.1   61     5   912    16     256  9.7   69     5  1213    11     290  9.2   66     5  1314    14     274 10.9   68     5  14#由输出可见，第5、6、10、11行是有缺省值的被过滤了