前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >R语言的数据结构(包含向量和向量化详细解释)

R语言的数据结构(包含向量和向量化详细解释)

作者头像
Y大宽
发布2020-01-02 23:39:27
7.1K0
发布2020-01-02 23:39:27
举报
文章被收录于专栏:Y大宽

更多内容请参考《R语言编程艺术》 ———————————————

向量类型是R语言的核心。深入理解向量对R中数据结构及其操作,函数的开发和应用有着重要意义。

1 几个概念:向量,向量化,标量,元素,组件,标签,原子向量,递归向量

以下叙述参考书籍加自己理解,有叙述不妥的留言

向量vector和标量

个人理解,向量是有方向的,由大于等于2个元素构成的数据类型。也就是说,向量的所有元素必须属于同种模式(mode),或数据类型(见1.2),比如数值型,字符型等。其类型可以用typeof()查看。 标量只含有一个元素,在R中没有0维度或标量类型。单独的数字或字符串本质是一元向量。

代码语言:javascript
复制
> x <- c(3,23,5)
> x
[1]  3 23  5
> length(x)
[1] 3

上面x是三元向量,并且赋值给了x。[1]表示这行得第一项是输出结果的第一项。 x由3个元素组成,分别是3,23,5 长度就是其包含的元素的个数。注意区别后面的列表的长度。

向量有哪些基本类型

两大类,原子向量和列表(又叫递归向量)

原子向量有6种类型:逻辑型,整型,双精度型,字符型,复数型和原始型。整型和双精度型统称为数值型向量。 为什么叫原子型(atomic):向量的元素已经是最小的,不可再分的。 列表型,又叫递归型,因为是列表中可以继续包括列表。列表中的“元素”就是列表的各组件,其名称叫标签(tag)。

2向量的循环补齐

两个向量使用运算符,如果两个向量长度不同,R会自动循环补齐(recycle),也就是它会自动重复较短的向量,直到与另外一个向量匹配。举例如下

代码语言:javascript
复制
> c(1,2,3)+c(4,5,6,7,8,9)
[1]  5  7  9  8 10 12
> c(1,2,3,1,2,3)+c(4,5,6,7,8,9)
[1]  5  7  9  8 10 12
> 1+1:8
[1] 2 3 4 5 6 7 8 9
> c(1,1,1,1,1,1,1,1)+c(1,2,3,4,5,6,7,8)
[1] 2 3 4 5 6 7 8 9

有没有感觉像生物学中的复制,只是模版决定了待合成的链的长度,并不决定其组成序列,影响其组成的是自身。但是当要进行两者运算的时候,必须一一匹配,就像碱基互补配对,不能错配。

继续看下面这个例子

代码语言:javascript
复制
> x <- matrix(1:6,nrow = 3)
> x
     [,1] [,2]
[1,]    1    4
[2,]    2    5
[3,]    3    6
> length(x)
[1] 6
> x[5]
[1] 5

x是矩阵。有6个元素。x[5]是第五个元素,值是5,明显看出,矩阵就是向量,按列填充(可以更改填充方向)。

代码语言:javascript
复制
> x+100
     [,1] [,2]
[1,]  101  104
[2,]  102  105
[3,]  103  106

100被重复6次(矩阵的长度)。相当于纵向拉长,但最终仍然生成矩阵。

代码语言:javascript
复制
> x+c(100,200,300,400,500,600)
     [,1] [,2]
[1,]  101  404
[2,]  202  505
[3,]  303  606

上面这个更清晰看出按列进行填充。

3向量化及向量化函数

3.1向量输入,向量或矩阵输出

向量输入,向量输出

向量化就是对向量的每一个元素应用函数,如果一个函数使用了向量化的运算符,那么它也被向量化了,代码运行速度会提升。 上面的+,还有*,/等都是向量化运算符。再举一个>

代码语言:javascript
复制
> c(5,2,4)<c(2,8,0)
[1] FALSE  TRUE FALSE
> c(5,2,8)>7
[1] FALSE FALSE  TRUE

返回的都是逻辑型向量。记得原则是短的自动循环补充,然后一一配对,返回一一配对的向量化结果(也可能直接输出矩阵结果)。

向量输入,矩阵输出sapply函数

举例:

代码语言:javascript
复制
> z12 <- function(x) return(c(x,x^2))
> z12(4)
[1]  4 16
> z12(1:8)
 [1]  1  2  3  4  5  6  7  8  1  4  9 16 25 36 49 64

输出结果都是向量化的。但看起来并不是我们想要的呈现方式。所以可以转变为矩阵

代码语言:javascript
复制
> matrix(z12(1:8),ncol = 2)
     [,1] [,2]
[1,]    1    1
[2,]    2    4
[3,]    3    9
[4,]    4   16
[5,]    5   25
[6,]    6   36
[7,]    7   49
[8,]    8   64

除了上面,如果函数本身的返回值就是向量,可用sapply函数进行简化,调用sapply(x,f)可对x的每一个元素使用函数f(),并将结果转化为矩阵。注意

代码语言:javascript
复制
> sapply(1:8, z12)
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,]    1    2    3    4    5    6    7    8
[2,]    1    4    9   16   25   36   49   64

直接输出8*2矩阵。 注意sapply是simplify apply的缩写,简化结果,但不是简单。它也可以用于列表操作,使得结果输出不再是列表,而是向量。类似本处结果的逆操作。最终目的是让结果看起来更自然更简洁。

3.2向量筛选

筛选filtering就是提取向量中符合一定条件的元素。

3.2.1生成筛选索引

目的,筛选x中平方值大于8的元素(不是元素位置,是元素本身)

代码语言:javascript
复制
x <- c(5,2,-3,8)
代码语言:javascript
复制
> x <- c(5,2,-3,8)
> x[x*x>8]
[1]  5 -3  8

向量化操作。x是4元向量,x*x也是4元向量,>是向量运算符,所以8实际是进行了循环补齐,实际是进行了如下比较

代码语言:javascript
复制
x*x>c(8,8,8,8)

返回值是布尔值向量

代码语言:javascript
复制
[1]  TRUE FALSE  TRUE  TRUE

所以实际是用布尔值向量筛选x中的符合条件的元素,也就是执行的是

代码语言:javascript
复制
x[c(TRUE,FALSE,TRUE,TRUE)]

运用上述方式可以筛选另一个向量,也可以筛选自身。 再看下面这个例子

代码语言:javascript
复制
> x <- c(5,2,-3,8)
> x[x>3] <- 100
[1] 100   2  -3 100
> x[x>3] <- 'up'
> x
[1] "up" "2"  "-3" "up"

第一个是x中大于3的元素赋值为100,结果仍然是数值型向量 第二个是x中大于3的赋值为‘up’,结果全部变为字符型向量

3.2.2使用subset(好处是自动去除NA值)

代码语言:javascript
复制
> subset(x,x*x>10)
[1] 5 8

3.2.3which:返回元素所处位置

代码语言:javascript
复制
> x <- c(5,2,-3,8)
> which(x*x>10)
[1] 1 4

返回的满足条件的元素所在的位置。这个对找出满足条件的元素首次出现的未知很重要,结合break。 另外match,%in%也可以进行筛选。但这两个不是向量化函数。???

3.3向量化的ifelse函数

ifelse(b,u,v) b是布尔值向量,u和v是向量。返回向量。

代码语言:javascript
复制
> x <- c(5,2,-4,3,0)
> ifelse(x%%2==0,5,12)
[1] 12  5  5 12  5
> ifelse(x>=3,'up', ifelse(x<=-3,'down','no'))
[1] "up"   "no"   "down" "up"   "no"  

可见,返回值都是向量。其中进行的是x中的每一个元素一次进行ifelse中的逻辑判断,返回相应的值,自动进行了循环补齐。所以ifelse是向量化的。

4 常见数据结构和向量的关系及常见操作

4.1矩阵

前已述及,矩阵也是向量,特殊的向量,包含量阿哥附加的属性:行和列。所以,矩阵也有模式,例如数值型或字符型。但向量不能看做有一列或一行的矩阵。

我对矩阵的比喻是‘神龙摆尾’。从左上角开始到右下角结束,有向无环。

对矩阵可以进行各种线性代数运算,矩阵索引,矩阵筛选

矩阵因为是特殊的向量所以可以用向量的方式索引(意义不大)或根据行列进行索引。

代码语言:javascript
复制
> z <- matrix(1:24,nrow = 6)
> z
     [,1] [,2] [,3] [,4]
[1,]    1    7   13   19
[2,]    2    8   14   20
[3,]    3    9   15   21
[4,]    4   10   16   22
[5,]    5   11   17   23
[6,]    6   12   18   24
> z[15]
[1] 15
> which(z>17)
[1] 18 19 20 21 22 23 24
> z[2,]
[1]  2  8 14 20
> z[,-c(3:4)]
     [,1] [,2]
[1,]    1    7
[2,]    2    8
[3,]    3    9
[4,]    4   10
[5,]    5   11
[6,]    6   12
> z[2,2]
[1] 8
> z[,2:4]
     [,1] [,2] [,3]
[1,]    7   13   19
[2,]    8   14   20
[3,]    9   15   21
[4,]   10   16   22
[5,]   11   17   23
[6,]   12   18   24
> z[,c(TRUE,FALSE,FALSE,TRUE)]
     [,1] [,2]
[1,]    1   19
[2,]    2   20
[3,]    3   21
[4,]    4   22
[5,]    5   23
[6,]    6   24

上述最后一个很重要,很多运算基于此。比如我们想找出第二列大于10的行。 注意上述返回的结果,有的是向量有的是矩阵。

代码语言:javascript
复制
> z[z[,2]>10,]
     [,1] [,2] [,3] [,4]
[1,]    5   11   17   23
[2,]    6   12   18   24

实际进行的是: z中第二列的每一个元素与10进行比较,所以z[,2]是向量,而10需要自动补齐,实际运行的是

代码语言:javascript
复制
> z[,2]>10
[1] FALSE FALSE FALSE FALSE  TRUE  TRUE

这就把返回值为TRUE的行提取出来了。

4.2对矩阵的行和列调用函数

apply函数(在矩阵的各行和格列上调用制定的函数)

代码语言:javascript
复制
apply(m,dimcode,f,fargs)

m为矩阵 dimcode为维度编号,1代表对每一行应用函数,2代表对列应用函数 f是应用在行或列上的函数(内部函数,自定义函数都可以) fargs是f的可选参数集

4.3 增加或删除矩阵的行或列

矩阵一旦产生,其行列固定,但可以对其重新赋值。 类似操作可以改变矩阵大小,比如rbind``cbind

代码语言:javascript
复制
> cbind(100,z)
     [,1] [,2] [,3] [,4] [,5]
[1,]  100    1    7   13   19
[2,]  100    2    8   14   20
[3,]  100    3    9   15   21
[4,]  100    4   10   16   22
[5,]  100    5   11   17   23
[6,]  100    6   12   18   24
> rbind(100,z)
     [,1] [,2] [,3] [,4]
[1,]  100  100  100  100
[2,]    1    7   13   19
[3,]    2    8   14   20
[4,]    3    9   15   21
[5,]    4   10   16   22
[6,]    5   11   17   23
[7,]    6   12   18   24

可见,进行了自动补齐。

5 列表和数据框(都不是向量)

5.1 列表

列表创建及基本结构

向量的元素要求同种类型,而列表list与向量不同,可以组合多个不同类型的对象。所以列表不是向量。但从技术上来说,列表就是向量,属于递归型向量(recursive vector)。

看例子

代码语言:javascript
复制
> j <- list(name="Joe",salary=55000,union=T)
> j
$name
[1] "Joe"

$salary
[1] 55000

$union
[1] TRUE

> length(j)
[1] 3
> str(j)
List of 3
 $ name  : chr "Joe"
 $ salary: num 55000
 $ union : logi TRUE

上面这个list有3个组件,其标签(tag)分别是name,salary,union。并且三个变量的类型不一样,分别是字符型,数字型,逻辑值。 注意,列表的长度是3,是组件的个数

列表索引

三种方式访问列表lst中的组件c,返回值是c的数据类型lst$c lst[["c"]] lst[[i]]

代码语言:javascript
复制
> j$salary
[1] 55000
> j$sa
[1] 55000
> j[[2]]
[1] 55000
> j[["salary"]]
[1] 55000
列表上应用apply系列函数lapply``sapply

lapply=list apply,对每个组件执行给定的函数,并返回另一个列表

代码语言:javascript
复制
> lapply(list(1:3,1:9), median)
[[1]]
[1] 2

[[2]]
[1] 5

> sapply(list(1:3,1:9), median)
[1] 2 5

可见,sapply输出的是向量。还记得上面3.1部分吗 如果函数本身的返回值就不是标量,而是向量。则sapply可以自动把向量形式的结果转化为矩阵输出 如下

代码语言:javascript
复制
> sapply(1:8,function(x) return(c(x^2, sqrt(x))))
     [,1]     [,2]     [,3] [,4]      [,5]     [,6]      [,7]      [,8]
[1,]    1 4.000000 9.000000   16 25.000000 36.00000 49.000000 64.000000
[2,]    1 1.414214 1.732051    2  2.236068  2.44949  2.645751  2.828427

5.2数据框

直观上看,数据框更类似矩阵,有行和列两个维度,但是数据框与矩阵的不同是,数据框的每一列可以是不同的模式mode。比如一列数字,一列字符串,一列布尔值。 所以,数据框可以类比为二维矩阵,当然这里的类比是异质性的,因为每个组件的数据类型不同。 技术层面看,数据框是每个组件长度相等的列表。 数据框是实际应用中最为常见。

代码语言:javascript
复制
> d <- data.frame(kids=c("Jack","Jill"),
+                 ages=c(12,10),
+                 stringsAsFactors = FALSE)
> d
  kids ages
1 Jack   12
2 Jill   10

数据框的访问,提取,增加,删除和矩阵非常类似,不再详述。 还有合并

apply族函数在数据框中的用法

apply lapply sapply

apply

如果数据框的每一列的数据类型相同,则可以对该数据框使用apply函数。或针对数据框中的某些列应用。

lapply和sapply

因为数据框技术上就是列表,所以lapply和sapply可以应用于数据框。 数据框是列表的特例,数据框的列构成列表的组件,所以lapply函数会作用于数据框的每一列,返回返回一个列表。但未知错乱,意义不大。

代码语言:javascript
复制
> lapply(d,sort)
$kids
[1] "Jack" "Jill"

$ages
[1] 10 12

> as.data.frame(lapply(d,sort))
  kids ages
1 Jack   10
2 Jill   12
代码语言:javascript
复制
> apply(d[,-1],2,mean)
 ages score 
 11.0  92.5 
> lapply(d[,-1],mean)
$ages
[1] 11

$score
[1] 92.5

> sapply(d[,-1],mean)
 ages score 
 11.0  92.5

6 因子factor

因子是R中许多强大运算和可视化的基础,暴多很多针对表格数据的运算。其来源是统计学中的名义变量(nominal variables),或称之为分类变量(categorical variables)。这种变量的本质不是数字,而是对应分类。 因子可以看做附加了更多信息的向量。

代码语言:javascript
复制
> x <- c(5,12,13,12)
> xf <- factor(x)
> xf
[1] 5  12 13 12
Levels: 5 12 13
> str(xf)
 Factor w/ 3 levels "5","12","13": 1 2 3 2
> unclass(xf)
[1] 1 2 3 2
attr(,"levels")
[1] "5"  "12" "13"
> x <- c(5,12,13,12)
> xf <- factor(x)
> xf
[1] 5  12 13 12
Levels: 5 12 13
> length(x)
[1] 4
> str(xf)
 Factor w/ 3 levels "5","12","13": 1 2 3 2
> unclass(xf)
[1] 1 2 3 2
attr(,"levels")
[1] "5"  "12" "13"

其中值得注意的几个地方

1 xf包含四个数值,共3个水平(levels,就是xf中不同的数值) 2 length返回的是数据的长度,而不是水平的个数 3 unclass要引起注意。其中返回的1232代表的是第1,2,3,2个水平,在这里这些数字已经重新编码为水平,而不是数值2,是水平2.

因子的常用函数tapply split by

tapply

tapply(x,f,g)其中,x是向量,f是因子(比如性别,党派),g是函数 要求f中每个因子需要与x有想通的长度。 tapply()执行的操作是,暂时将x分组,每组对应一个因子水平(多个因子对应一组因子组合),得到x的子向量,然后对这些子向量应用函数g()

代码语言:javascript
复制
> ages <- c(25,26,55,37,21,42)
> affils <- c('R','D','D','R','U','D')
> tapply(ages, affils, mean)
 D  R  U 
41 31 21 

第二个例子

代码语言:javascript
复制
> d <- data.frame(list(gender=c("M","M","F","M","F","F"),
+                      age=c(47,59,21,32,33,24),
+                      income=c(55000,88000,32450,76500,12300,45650)))
> d
  gender age income
1      M  47  55000
2      M  59  88000
3      F  21  32450
4      M  32  76500
5      F  33  12300
6      F  24  45650
> tapply(d$income,d$gender,mean)
       F        M 
30133.33 73166.67 

现在假如同时对age和gender感兴趣,想知道其每组平均收入。假如我们以25岁为条件,那么需要把年龄转化为因子,比如大于25的为1,小于25的为0,或其他,用前面的ifelse函数进行赋值 排列组合,性别2个因子,年龄2个因子,所以会将收入分为4组,每组代表性别和年龄的一种组合,然后对每个组合应用函数。

代码语言:javascript
复制
> d$over25 <- ifelse(d$age>25,'over','under')
> tapply(d$income, list(d$gender,d$over25), mean)
      over under
F 12300.00 39050
M 73166.67    NA
split 只是形成分组

注意,这点和tapply不同,tapply是将向量分割为组,然后针对每个组应用制定函数。split的基本形式是split(x,f),注意返回的是列表。 还有一点注意的是split中x可以是数据框,而tapply不可以。

代码语言:javascript
复制
> split(d$income,d$over25)
$over
[1] 55000 88000 76500 12300

$under
[1] 32450 45650

> as.data.frame(split(d$income,d$over25))
   over under
1 55000 32450
2 88000 45650
3 76500 32450
4 12300 45650

split可以很翻过的找出各个因子的索引

代码语言:javascript
复制
> split(1:length(d$over25),d$over25)
$over
[1] 1 2 4 5

$under
[1] 3 6
by函数

假如现在有这么一个需求,想对不同的性别编码组分别做年龄对收入的回归分析。 tapply好像很适合,因为分组,应用函数。但是,tapply的第一个参数必须是向量,不能是矩阵或数据框,而回归分析必须至少两列的数据或数据框,其中第一列是被预测的变量,第二列或多列是预测变量。所以tapply函数不能满足任务。

代码语言:javascript
复制
> by(d,d$gender,function(m) lm(d$income~d$age))
d$gender: F

Call:
lm(formula = d$income ~ d$age)

Coefficients:
(Intercept)        d$age  
       8493         1199  

--------------------------------------------------------------------- 
d$gender: M

Call:
lm(formula = d$income ~ d$age)

Coefficients:
(Intercept)        d$age  
       8493         1199

by()的调用和tapply()非常相似,第一个参数是数据,第二个是分组因子,第三个是函数。 tapply是根据因子水平简历索引的分组,by会查找数据框不同分组的行号,从而产生2个子数据框,分别对应2个性别水平。lm函数被调用2次,作了2次回归分析。

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 1 几个概念:向量,向量化,标量,元素,组件,标签,原子向量,递归向量
    • 向量vector和标量
      • 向量有哪些基本类型
      • 2向量的循环补齐
      • 3向量化及向量化函数
        • 3.1向量输入,向量或矩阵输出
          • 3.2向量筛选
            • 3.2.1生成筛选索引
            • 3.2.2使用subset(好处是自动去除NA值)
            • 3.2.3which:返回元素所处位置
          • 3.3向量化的ifelse函数
          • 4 常见数据结构和向量的关系及常见操作
            • 4.1矩阵
              • 4.2对矩阵的行和列调用函数
                • apply函数(在矩阵的各行和格列上调用制定的函数)
              • 4.3 增加或删除矩阵的行或列
              • 5 列表和数据框(都不是向量)
                • 5.1 列表
                  • 5.2数据框
                    • apply族函数在数据框中的用法
                • 6 因子factor
                  • 因子的常用函数tapply split by
                  领券
                  问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档