R语言学习（4）——R中的数据结构之向量

闲鱼粗面

已于 2024-02-22 10:25:47 修改

阅读量760

点赞数 30

分类专栏： R语言学习文章标签： r语言学习数据结构

于 2024-02-22 10:13:19 首次发布

本文链接：https://blog.csdn.net/liukaiyue99/article/details/133207940

版权

R语言学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

上一期文章
R语言学习（3）——R中变量的创建和删除及数据类型

文章目录

向量的创建
向量中元素的命名
运算符
获取向量中的元素
向量元素的扩展、替换和删除
向量的排序

向量的创建

向量是 R 语言中最基本的数据结构，可以通过 c()函数将给定的值来构造向量

# 生成数值型向量
c(2, 4, 6, 8)
#[1] 2 4 6 8
c(2:6) # 生成2-6的数值型向量，步长为1
#[1] 2 3 4 5 6
c(pi, 1.25, 1.36, 1)
#[1] 3.141593 1.250000 1.360000 1.000000

# 生成字符型向量
c("a", "b", "c")
#[1] "a" "b" "c"

# 生成逻辑型向量
c(TRUE, FALSE, TRUE, FALSE)
#[1]  TRUE FALSE  TRUE FALSE

# 生成复数向量
complex_data <- complex(real = c(1:5), imaginary = c(5:1))
complex_data
#[1] 1+5i 2+4i 3+3i 4+2i 5+1i

# 生成原始型向量
raw_data <- charToRaw("abcde")
raw_data
#[1] 61 62 63 64 65

单个值可以看作长度为1的向量，可以使用length()函数查看向量的长度

length(1)

length("a")
length(TRUE)

length(complex_data)
#[1] 5

length(complex_data)
#[1] 5

length(raw_data)
#[1] 5

向量中元素必须为相同的数据类型，如果为不同的数据类型，R会强制转换成相同的类型。

数据类型转换的优先级为：Character > Numeric > Logical

data_set <- c("a", 1:2, TRUE, FALSE)
data_set
#[1] "a"     "1"     "2"     "TRUE"  "FALSE"
typeof(data_set)
#[1] "character"

data_set <- c(1:2, TRUE, FALSE)
data_set
#[1] 1 2 1 0
typeof(data_set)
#[1] "integer"

向量中元素的命名

使用names()函数可以为向量的每个元素命名

name <- c("小王", "小李", "小张", "小陈", "小赵")
name
#[1] "小王" "小李" "小张" "小陈" "小赵"

score <- c(75, 66, 69, 85, 76)
score
#[1] 75 66 69 85 76

names(score) <- name
score
#小王 小李 小张 小陈 小赵 
# 75   66   69   85   76 

# 也可以通过下面的方式直接给向量中的元素命名
score <- c("小王" = 75, "小李" = 66, "小张" = 69, "小陈" = 85, "小赵" = 76)
score
#小王 小李 小张 小陈 小赵 
# 75   66   69   85   76

运算符

算术运算

算术运算符	含义
+	加
-	减
*	乘
/	除
^或**	幂次
%%	求余数
%/%	整除

单个数值之间的运算，例如：

2 + 4
#[1] 6

2 - 4
#[1] -2

2 * 4
#[1] 8

2 / 4
#[1] 0.5

2^4
#[1] 16

2**4
#[1] 16

7 %% 2
#[1] 1

7 %/% 2
#[1] 3

-2 %/% 4
#[1] -1

数值型向量与单个数值的算术运算规则为每个元素与单个数值之间进行运算，例如：

data_set <- c(-4, -1, 2, 4, 6, 7)
data_set + 2
#[1] -2  1  4  6  8  9

data_set - 4
#[1] -8 -5 -2  0  2  3

data_set * 3
#[1] -12  -3   6  12  18  21

data_set / 4
#[1] -1.00 -0.25  0.50  1.00  1.50  1.75

data_set^3
#[1] -64  -1   8  64 216 343

data_set %% 2
#[1] 0 1 0 0 0 1

data_set %/% 4
#[1] -1 -1  0  1  1  1

等长数值型向量之间的算术运算规则为对应元素之间进行运算，例如：

data_set1 <- c(-4, 7)
data_set2 <- c(2, -3)

data_set1 + data_set2
#[1] -2  4

data_set1 - data_set2
#[1] -6 10

data_set1 * data_set2
#[1]  -8 -21

data_set1 / data_set2
#[1] -2.000000 -2.333333

data_set1^data_set2
#[1] -2.000000 -2.333333

data_set1 %% data_set2
#[1]  0 -2

data_set1 %/% data_set2
#[1] -2 -3

不等长数值型向量的算术运算时，会将长度较短的向量循环使用，例如：

data_set1 <- c(-4, 1, 7)
data_set2 <- c(2, -3)

# 相当于向量c(-4, 1, 7)和向量c(2, -3, 2)进行算术运算
data_set1 + data_set2
#[1] -2 -2  9
#Warning message:
#In data_set1 + data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 - data_set2
#[1] -6  4  5
#Warning message:
#In data_set1 + data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 * data_set2
#[1] -8 -3 14
#Warning message:
#In data_set1 + data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 / data_set2
#[1] -2.0000000 -0.3333333  3.5000000
#Warning message:
#In data_set1 + data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1^data_set2
#[1] 16  1 49
#Warning message:
#In data_set1 + data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 %% data_set2
#[1]  0 -2  1
#Warning message:
#In data_set1 + data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 %/% data_set2
#[1] -2 -1  3
#Warning message:
#In data_set1 + data_set2 : 长的对象长度不是短的对象长度的整倍数

逻辑型向量也可以像数值型向量进行算术运算，TRUE表示1，FALSE表示0

关系运算符

关系运算符	含义
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于
!=	不等于

单个值之间的关系运算，例如：

2 < 4
#[1] TRUE

2 <= 4
#[1] TRUE

2 > 4
#[1] FALSE

2 >= 4
#[1] FALSE

2 == 4
#[1] FALSE

2 != 4
#[1] TRUE

"a" == "b"
#[1] FALSE

"a" != "b"
#[1] TRUE

# 逻辑值之间的关系运算时，TRUE相当于数值1，FALSE相当于数值0
TRUE < FALSE
#[1] FALSE

TRUE <= FALSE
#[1] FALSE

TRUE > FALSE
#[1] TRUE

TRUE >= FALSE
#[1] TRUE

TRUE == FALSE
#[1] FALSE

TRUE != FALSE
#[1] TRUE

向量和单个值之间进行关系运算时，向量中的每个元素均与单个值进行比较，例如：

data_set1 <- c(1:3)

data_set1 < 2
#[1]  TRUE FALSE FALSE

data_set1 <= 2
#[1]  TRUE  TRUE FALSE

data_set1 > 2
#[1] FALSE FALSE  TRUE

data_set1 >= 2
#[1] FALSE  TRUE  TRUE

data_set1 == 2
#[1] FALSE  TRUE FALSE

data_set1 != 2
#[1]  TRUE FALSE  TRUE

data_set2 <- c("a", "b", "ab")

data_set2 == "a"
#[1]  TRUE FALSE FALSE

data_set2 != "a"
#[1] FALSE  TRUE  TRUE

data_set3 <- c(TRUE, FALSE, TRUE)

data_set3 == TRUE
#[1]  TRUE FALSE  TRUE

data_set3 != TRUE
#[1] FALSE  TRUE FALSE

等长向量之间在进行关系运算时，对应元素之间将会比较，例如：

data_set1 <- c(1:3)
data_set2 <- c(3:1)

data_set1 < data_set2
#[1]  TRUE FALSE FALSE

data_set1 <= data_set2
#[1]  TRUE  TRUE FALSE

data_set1 > data_set2
#[1] FALSE FALSE  TRUE

data_set1 >= data_set2
#[1] FALSE  TRUE  TRUE

data_set1 == data_set2
#[1] FALSE  TRUE FALSE

data_set1 != data_set2
#[1]  TRUE FALSE  TRUE

data_set3 <- c("a", "b", "ab")
data_set4 <- c("ab", "b", "a")

data_set3 == data_set4
#[1] FALSE  TRUE FALSE

data_set3 != data_set4
#[1]  TRUE FALSE  TRUE

data_set5 <- c(TRUE, FALSE, TRUE)
data_set6 <- c(FALSE, TRUE, FALSE)

data_set5 == data_set6
#[1] FALSE FALSE FALSE

data_set5 != data_set6
#[1] TRUE TRUE TRUE

不等长数值型向量的算术运算时，会将长度较短的向量循环使用，例如：

data_set1 <- c(1:5)
data_set2 <- c(3:1)

# 相当于向量c(1, 2,,3, 4, 5)和向量c(3, 2, 1, 3, 2)之间进行关系运算
data_set1 < data_set2
#[1]  TRUE FALSE FALSE FALSE FALSE
#Warning message:
#In data_set1 < data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 <= data_set2
#[1]  TRUE  TRUE FALSE FALSE FALSE
#Warning message:
#In data_set1 <= data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 > data_set2
#[1] FALSE FALSE  TRUE  TRUE  TRUE
#Warning message:
#In data_set1 > data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 >= data_set2
#[1] FALSE  TRUE  TRUE  TRUE  TRUE
#Warning message:
#In data_set1 >= data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 == data_set2
#[1] FALSE  TRUE FALSE FALSE FALSE
#Warning message:
#In data_set1 == data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 != data_set2
#[1]  TRUE FALSE  TRUE  TRUE  TRUE
#Warning message:
#In data_set1 != data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set3 <- c("a", "b", "ab")
data_set4 <- c("ab", "b")

# 相当于向量c("a", "b", "ab")和向量c("ab", "b", "ab")之间进行关系运算
data_set3 == data_set4
#[1] FALSE  TRUE  TRUE
#Warning message:
#In data_set3 == data_set4 : 长的对象长度不是短的对象长度的整倍数

data_set3 != data_set4
#[1]  TRUE FALSE FALSE
#Warning message:
#In data_set3 != data_set4 : 长的对象长度不是短的对象长度的整倍数

data_set5 <- c(TRUE, FALSE, TRUE)
data_set6 <- c(FALSE, TRUE)

# 相当于向量c(TRUE, FALSE, TRUE)和向量c(FALSE, TRUE, FALSE)之间进行关系运算
data_set5 == data_set6
#[1] FALSE FALSE FALSE
#Warning message:
#In data_set5 == data_set6 : 长的对象长度不是短的对象长度的整倍数

data_set5 != data_set6
#[1] TRUE TRUE TRUE
#Warning message:
#In data_set5 != data_set6 : 长的对象长度不是短的对象长度的整倍数

逻辑运算符

逻辑运算只适用于数值，逻辑值或复数值数据类型。在数值型数据类型中，只有0表示为FALSE，其余数值表示为TRUE；在数值型数据类型中，只有0表示为FALSE，其余数值表示为TRUE；

逻辑运算符	含义
!	非
\|	或
&	与

单个值之间的逻辑运算，例如：

#非逻辑运算
!TRUE
#[1] FALSE

!FALSE
#[1] TRUE

!1
#[1] FALSE

!0
#[1] TRUE

TRUE & TRUE
#[1] TRUE

TRUE & FALSE
#[1] FALSE

FALSE & FALSE
#[1] FALSE

等长向量之间的逻辑运算，例如：

data_set1 <- c(1:3)
data_set2 <- c(3:1)

data_set1 & data_set2
#[1] TRUE TRUE TRUE

data_set1 | data_set2
#[1] TRUE TRUE TRUE

!data_set1
#[1] FALSE FALSE FALSE

!data_set2
#[1] FALSE FALSE FALSE

data_set3 <- c(TRUE, FALSE, TRUE)
data_set4 <- c(FALSE, TRUE, TRUE)

data_set3 & data_set4
#[1] FALSE FALSE  TRUE

data_set3 | data_set4
#[1] TRUE TRUE TRUE

!data_set3
#[1] FALSE  TRUE FALSE

!data_set4
#[1]  TRUE FALSE FALSE

不等长数值型向量的逻辑运算时，会将长度较短的向量循环使用，例如：

data_set1 <- c(1:5)
data_set2 <- c(3:1)

data_set1 & data_set2
#[1] TRUE TRUE TRUE TRUE TRUE
#Warning message:
#In data_set1 & data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set1 | data_set2
#[1] TRUE TRUE TRUE TRUE TRUE
#Warning message:
#In data_set1 | data_set2 : 长的对象长度不是短的对象长度的整倍数

data_set3 <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
data_set4 <- c(FALSE, TRUE, TRUE)

data_set3 & data_set4
#[1] FALSE FALSE  TRUE FALSE FALSE
#Warning message:
#In data_set3 & data_set4 : 长的对象长度不是短的对象长度的整倍数

data_set3 | data_set4
#[1] TRUE TRUE TRUE TRUE TRUE
#Warning message:
#In data_set3 | data_set4 : 长的对象长度不是短的对象长度的整倍数

获取向量中的元素

通过元素的位置索引获取向量中的元素

在R中，元素的位置索引从1开始，可以使用方括号（[]）来获取向量中的元素

data_set <- c(5, 4, 3, 2, 1, 0)

data_set[2]
#[1] 4

data_set[3:5]
#[1] 3 2 1

# 当索引大于向量的长度时，则会返回缺失值NA
data_set[7]
#[1] NA

data_set[c(3, 5)]
#[1] 3 1

通过逻辑型向量获取向量中的元素

data_set <- c(5, 4, 3, 2, 1, 0)
data_set[c(TRUE, FALSE, TRUE, FALSE, TRUE, TRUE)]
#[1] 5 3 1 0

# 当逻辑型向量小于向量的长度时，逻辑向量则会循环使用
data_set[c(TRUE, FALSE)]
#[1] 5 3 1
#相当于data_set[c(TRUE, FALSE, TRUE, FALSE, TRUE, FALSE)]

# 当逻辑型向量大于向量的长度时，多余部分TRUE对应的元素将会返回为缺失值NA
data_set[c(TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, TRUE)]
# [1]  5  3  1  0 NA

data_set[data_set > 3 & data_set < 5]
#[1] 4

通过元素名字获取向量中的元素

name <- c("小王", "小李", "小张", "小陈", "小赵")
score <- c(75, 66, 69, 85, 76)
names(score) <- name

#当使用非向量中的元素名时，则会返回为缺失值NA
score[c("小王", "小陈", "小刘")]
#小王 小陈 <NA> 
# 75   85   NA

使用which()函数进行筛选

which()函数返回结果为TURE对应向量元素的位置，使用which()进行函数来筛选本质上是通过元素的位置索引获取向量中的元素

data <- c(1, 3, 5, 7)
which(data == 3)
#[1] 2

data[which(data == 3)]
#[1] 3

向量元素的扩展、替换和删除

元素的扩展

使用c()函数，直接将多个向量合并

data_set1 <- c(5:7)
data_set2 <- c(1, 8)
data_set3 <- c(2, 4)
data_set <- c(data_set1, data_set2, data_set3, 3)
data_set
#[1] 5 6 7 1 8 2 4 3

使用append()函数在指定的位置添加元素

# 不指定元素添加的位置c()函数的功能一直
append(data_set1, data_set2)
#[1] 5 6 7 1 8

# 指定元素添加的位置
# 在data_set1向量的第二个元素之后插入data_set2向量
append(data_set1, data_set2, 2)
#[1] 5 6 1 8 7

# 在data_set1向量之前插入data_set2向量
append(data_set1, data_set2, 0)
#[1] 1 8 5 6 7

元素的替换

data_set <- 1:6
data_set
#[1] 1 2 3 4 5 6

data_set[1] <- 7
data_set
#[1] 7 2 3 4 5 6

data_set[2:4] <- 8
data_set
#[1] 7 8 8 8 5 6

data_set[5:6] <- c(10, 9)
data_set
#[1]  7  8  8  8 10  9

元素的删除

在位置索引前加负号（-），可以删除向量中对应位置的元素。

data_set <- 1:6
data_set
#[1] 1 2 3 4 5 6

data_set[-1]
#[1] 2 3 4 5 6

data_set[-c(2:4)]
#[1] 1 5 6

向量的排序

sort()函数

sort(x, decreasing = FALSE, na.last = NA, index.return = FASLE, …)

x 为要被排序的向量；

decreasing 为排序的顺序，默认为FALSE，即为升序，若为TRUE则按照降序排列；

na.last 是对向量中NA值的处理，默认值为NA，会删除向量中的NA，若为TRUE，则将NA值放在最后；若为FALSE，将NA值放在最前面；

index.return 默认值为FALSE，若设置为TRUE则还会返回原来未排序前元素所处的位置，若index.return = TRUE，na.last必须设置为NA。

data_set <- c(10, NA, 9, 10, 8, 13, 10, 10, 12)
data_set
#[1] 10 NA  9 10  8 13 10 10 12

sort(data_set)
#[1]  8  9 10 10 10 10 12 13

sort(data_set, index.return = TRUE)
#$x
#[1]  8  9 10 10 10 10 12 13
#
#$ix
#[1] 4 2 1 3 6 7 8 5

order()函数

返回升序排序后，在原有向量中元素的位置

data_set <- c(3, 4, 2, 1)
data_set
#[1] 3 4 2 1

order(data_set)
#[1] 4 3 1 2

rank()函数

返回升序排序后，向量中每个元素对应的秩，即在新向量中的位置

data_set <- c(8, 6, 1, 5)
data_set
#[1] 8 6 1 5

rank(data_set)
#[1] 4 3 1 2