R的数据结构（向量）

向量

定义

一个数据序列，（如：一个人的成绩，序号）

向量的属性

向量的类型

对于一个向量而言，其数据的类型可以是数值型、字符型、逻辑型。但一个向量中元素只能是同一个数据类型。

class（）函数

在R中可以运用class（）函数，来查看向量的数据类型。

> class(ages)
[1] "numeric"          #数值型
> class(colors)
[1] "character"        #字符型
> class(booleans)
[1] "logical"          #逻辑型

向量的长度

向量的长度是指向量中元素的个数。

lengeth（）函数

> length(ages)
[1] 6
> length(colors)
[1] 4
> length(booleans)
[1] 5

创建向量

c（）函数

在R中创建向量最常用的方法是，使用c（）函数。

> ages <- c(4, 7, 6, 5, 6, 7)   ## 数值型向量

这里的c(…)函数会把它所有的参数首尾相连而形成一个向量，其中函数可以传入任意数量参数。
函数的参数也可以是向量，比如：

> new_ages <- c(12, ages, 17)
> > ages
[1] 4 7 6 5 6 7
> new_ages
[1] 12  4  7  6  5  6  7 17

用c（）函数也可以创建字符型、逻辑型向量。

**> colors <- c('red', 'black', 'blue', 'yellow')  ## 字符型向量
> colors
[1] "red"    "black"  "blue"   "yellow"
> booleans <- c(TRUE, FALSE, TRUE, FALSE, TRUE)  ## 逻辑型向量
> booleans
[1]  TRUE FALSE  TRUE FALSE  TRUE**

利用冒号创建向量

冒号:运算符可用来产生等差级数向量，其使用形式为x:y，其规则为：

• 当x>y时，将生成 x, x+1, x+2, x+3, …等差级数，公差为1，最后的元素≤y
• 当x<y时，将生成 x, x-1, x-2, x-3, …等差级数，公差为-1，最后的元素≤y

> 2:7   ## integer
[1] 2 3 4 5 6 7
> 9:3   ## integer，公差为-1
[1] 9 8 7 6 5 4 3
> 3.14:9   ## real
[1] 3.14 4.14 5.14 6.14 7.14 8.14
> 3:9.3   ## integer
[1] 3 4 5 6 7 8 9
> 3.14:9.3   ## real
[1] 3.14 4.14 5.14 6.14 7.14 8.14 9.14
> 9:3.2   ## integer，公差为-1
[1] 9 8 7 6 5 4

另外，通过冒号:运算符可以非常简单地产生等比级数向量

> 2^(0:5)    ## 公比为2
[1]  1  2  4  8 16 32
> 2.1^(0:5)  ## 公比为2.1
[1]  1.00000  2.10000  4.41000  9.26100 19.44810 40.84101

利用seq()函数创建向量

seq()函数也是用来产生等差级数向量的，其原型为seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),length.out = NULL, along.with = NULL, …)

• seq(from, to)：等价于from:to运算
• seq(from, to, by= )：参数by设置公差的大小，最后元素≤to值
• seq(from, to, length.out= )：参数length.out设置输出向量的长度，第一个元素为from值，最后元素的值为to，公差由函数自动计算给出

> seq(2, 7)
[1] 2 3 4 5 6 7
> seq(11, 3)
[1] 11 10  9  8  7  6  5  4  3
> seq(2.1, 7)
[1] 2.1 3.1 4.1 5.1 6.1
> seq(2, 7, by=1.1)   ## 公差为1.1
[1] 2.0 3.1 4.2 5.3 6.4
> seq(2, 7, length.out=8)  ## 输出向量的长度为8，第一个元素为2，最后元素为7
[1] 2.000000 2.714286 3.428571 4.142857 4.857143 5.571429 6.285714 7.000000

利用req（）函数创建向量

rep()函数的作用是重复向量中的元素

> rep(1:4, 2)
[1] 1 2 3 4 1 2 3 4
> rep(1:4, each = 2)        ## not the same.
[1] 1 1 2 2 3 3 4 4
> rep(1:4, c(2,2,2,2))      ## same as second.
[1] 1 1 2 2 3 3 4 4
> rep(1:4, c(2,1,2,1))
[1] 1 1 2 3 3 4
> rep(1:4, each = 2, len = 4)     ## first 4 only.
[1] 1 1 2 2
> rep(1:4, each = 2, len = 10)    ## 8 integers plus two recycled 1's.
 [1] 1 1 2 2 3 3 4 4 1 1
> rep(1:4, each = 2, times = 3)    ## length 24, 3 complete replications
 [1] 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4

有名称的向量

以上的向量是没有名称的向量，在R中也可以创建有名称的向量。
创建有名称的向量，也可以使用c（）函数。

> new_ages <- c(kim=7, rob=6, tony=12)  ## 向量元素的名称分别为'kim', 'rob', 'tony'，值分别为7,6,12
> new_ages
 kim  rob tony 
   7    6   12

对于无名称向量，利用names()函数可用给向量的每个元素命名，比如：

> ages <- c(4, 7, 6, 5, 6, 7)   ## 无名称向量
> names(ages) <- c('bob', 'tom', 'lucy', 'andy', 'sandy', 'joe')   ## 向量元素命名
> ages
  bob   tom  lucy  andy sandy   joe 
    4     7     6     5     6     7 
> names(ages)  ## 输出向量名称
[1] "bob"   "tom"   "lucy"  "andy"  "sandy" "joe"

删除有名称的向量的名称

利用as.vector()函数可以删除向量中元素的名称

> new_ages <- c(kim=7, rob=6, tony=12)
> new_ages
 kim  rob tony 
   7    6   12 
> as.vector(new_ages)
[1]  7  6 12

访问向量中的元素

访问向量中的元素需要使用索引，在R中[]，代表索引。（索引是从数字1开始的）

访问某个元素

向量名+[要访问的元素索引位置]

> ages[4]       #访问向量ages的第四个元素
[1] 5

访问某些元素

向量名+[元素1索引位置,元素2索引位置,…]

> index <- c(2, 3, 6)
> ages[index]
[1] 7 6 7
> ages[c(2, 3, 6)]
[1] 7 6 7

访问除某个元素外的其他元素

向量名+[- 要去除的元素索引]

> ages[-4]   ## 访问除第四个元素外的其它元素
[1] 4 7 6 6 7

运用逻辑条件访问元素

向量名+[逻辑条件]

> ages[ages > 5]  ##通过逻辑运算访问所需元素
[1] 7 6 6 7

注意：元素访问操作不会改变原向量的内容。如需改变向量内容，则需对向量重新赋值操作

访问有名称的向量

对于有名称的向量既可以通过向量索引访问，也可以通过向量的名称进行访问。

• ages[i]：返回向量元素的值和名称
• ages[[i]]：只返回向量元素的值
• ages[元素名称]：返回向量元素的值和名称
• ages[[元素名称]]：只返回向量元素的值

> ages[2]
tom 
  7 
> ages[[2]]
[1] 7
> ages['tom']
tom 
  7 
> ages[['tom']]
[1] 7

向量的操作

c（）函数

量中的元素必须为同一属性，创建向量会经常使用c()函数。如果c()函数的参数类型不一致，函数会强制将所有参数变为同一类型
而且每种类型的强弱不一样，强弱顺序为：character > complex > numeric > integer > logical（字符型>复数型>数值型>整数型>逻辑型）

> c(2, 3, 6)
[1] 2 3 6
> c(2, TRUE, 'hello')  ## 全部强制转化为 character
[1] "2"     "TRUE"  "hello"
> c(2.1, TRUE, 'hello') ## 全部强制转化为 character
[1] "2.1"   "TRUE"  "hello"
> c(2+3i, TRUE, 'hello')  ## 全部强制转化为 character
[1] "2+3i"  "TRUE"  "hello"
> c(2, TRUE)  ## 全部强制转化为 integer
[1] 2 1
> c(2.1, TRUE)  ## 全部强制转化为 numeric
[1] 2.1 1.0
> c(2+3i, TRUE)  ## 全部强制转化为 complex
[1] 2+3i 1+0i
> c(2, 2.1)  ## 全部强制转化为 numeric
[1] 2.0 2.1
> c(2, 2.1, 2+3i)  ## 全部强制转化为 complex
[1] 2.0+0i 2.1+0i 2.0+3i

标量

标量：向量的一种特殊情况，（元素个数只有一个）。

> is.vector(3)   ## 单个数也是向量
[1] TRUE
> is.vector(c(2, 3, 5))
[1] TRUE

可以通过is.vector()函数来判断变量是否为向量。

向量的运算

长度相同的向量

当向量的长度相同时，向量间的运算只不过是对应元素的运算。

> x <- c(1, 3, 5)
> y <- c(4, 3, 2)
> x + y
[1] 5 6 7
> x * y
[1]  4  9 10
> x ^ y
[1]  1 27 25

长度不同的向量

当向量的长度不同时，短的向量会自动循环补齐至与长向量相同，然后再运算。

> x <- c(1, 3)
> y <- c(4, 3, 2, 1)
> z <- c(2, 4, 5)
> x + 4      ## 单个的数值4会被补齐为 c(4, 4)
[1] 5 7
> x - y      ## 等价于 c(1, 3, 1, 3) - c(4, 3, 2, 1)，因为x会自动补齐为 c(1, 3, 1, 3)
[1] -3  0 -1  2
> x / y         ## 等价于 c(1, 3, 1, 3) / c(4, 3, 2, 1)，因为x会自动补齐为 c(1, 3, 1, 3)
[1] 0.25 1.00 0.50 3.00
> x / z         ## 等价于c(1, 3, 1) / c(2, 4, 5)，由于长向量的长度不是短向量长度的倍数，会给出警告信息，不过还是会给出结果
[1] 0.50 0.75 0.20
Warning message:
In x/z : longer object length is not a multiple of shorter object length

向量内积

内积符号：%*%

> x <- c(1, 3, 5)
> y <- c(2, 4, 6)
> x %*% y    ## 点积 1*2+3*4+5*6
     [,1]
[1,]   44

常用的函数

max(x)：找出x向量中的最大值
min(x)：找出x向量中的最小值
range(x)：找出x向量中的最小值和最大值
length(x)：求x向量的长度
sum(x)：求x向量的元素和
prod(x)：求x向量的元素积
mean(x)：求x向量的算术平均值
median(x)：求x向量的中位数
var(x)：求x向量的方差
sd(x)：求x向量的标准差
cor(x, y)：求x向量和y向量的相关系数
sort(x)：将x向量按大小顺序排序
rank(x)：返回x向量中对应元素的排名
order(x)：返回对应“排名”的元素在x向量中的位置
quantile(x)：返回x向量的最小值、下分位数、中位数、上分位数和最大值
cumsum(x)：返回x向量的累计和
cumprod(x)：返回x向量的累计积
cummax(x)：返回x向量的累计最大值
cummin(x)：返回x向量的累计最小值
pmax(x, y, z)：返回x、y、z向量对应位置上的最大值
pmin(x, y, z)：返回x、y、z向量对应位置上的最小值
table(x)：返回x向量的元素统计频数
diff(x)：返回x向量的相邻两元素之差
unique(x)：删除x向量中的重复元素
union(x, y)：x向量和y向量的并集
intersect(x, y)：x向量和y向量的交集
setdiff(x, y)：x向量和y向量的差集（即返回属于x向量的元素但不属于y向量）
x %in% y：判断x向量中的元素是否在y向量中

> x <- c(2, 4, 5, 3, 2)
> y <- c(7, 2, 3, 8, 6)
> z <- c(1, 7, 2, 9, 0)

> max(x)   ## 最大值
[1] 5

> min(x)   ## 最小值
[1] 2

> range(x)   ## 最小值和最大值
[1] 2 5

> length(x)   ## 长度
[1] 5

> sum(x)   ## 求和
[1] 16

> prod(x)   ## 求积
[1] 240

> mean(x)   ## 算术平均值
[1] 3.2

> median(x)   ## 中位数
[1] 3

> var(x)   ## 方差
[1] 1.7

> sd(x)   ## 标准差
[1] 1.30384

> cor(x, y)   ## 相关系数
[1] -0.7555763

> sort(x)  ## 按大小顺序排序
[1] 2 2 3 4 5

> rank(y)  ## 对应元素的排名
[1] 4 1 2 5 3

> order(x)   ## 对应排名的元素在x向量中的位置
[1] 1 5 4 2 3

> quantile(x)   ## 最小值、下分位数、中位数、上分位数和最大值
  0%  25%  50%  75% 100% 
   2    2    3    4    5 

> cumsum(x)   ## 累计和
[1]  2  6 11 14 16

> cumprod(x)   ## 累计积
[1]   2   8  40 120 240

> cummax(x)   ## 累计最大值
[1] 2 4 5 5 5

> cummin(x)   ## 累计最小值
[1] 2 2 2 2 2

> pmax(x, y, z)   ## x、y、z向量对应位置上的最大值

[1] 7 7 5 9 6

> pmin(x, y, z)   ## x、y、z向量对应位置上的最小值
[1] 1 2 2 3 0

> table(x)   ## 元素统计频数
x
2 3 4 5 
2 1 1 1 

> diff(x)     ## 相邻两元素之差
[1]  2  1 -2 -1

> unique(x)    ## 删除重复元素
[1] 2 4 5 3

> union(x, y)    ## 并集
[1] 2 4 5 3 7 8 6

> intersect(x, y)    ## 交集
[1] 2 3

> setdiff(x, y)    ## 差集
[1] 4 5

> x %in% y       ## 判断x向量中的元素是否在y向量中

[1]  TRUE FALSE FALSE  TRUE  TRUE