《R数据科学》学习笔记|Note14:向量_r数据科学 14.2习题答案-CSDN博客

本文链接：https://blog.csdn.net/weixin_45822007/article/details/114896672

在这里插入图片描述

写在前面

本系列为《R数据科学》(R for Data Science)的学习笔记。相较于其他R语言教程来说，本书一个很大的优势就是直接从实用的R包出发，来熟悉R及数据科学。更新过程中，读者朋友如发现错误，欢迎指正。如果有疑问，也可以后台私信。希望各位读者朋友能学有所得！

向量

14.1 向量基础

向量的类型主要有两种。

原子向量，其共有 6 种类型：逻辑型、整型、双精度型、字符型、复数型和原始型。整型和双精度型向量又统称为数值型向量。
列表，有时又称为递归向量，因为列表中也可以包含其他列表。

原子向量与列表之间的主要区别是，原子向量中的各个值都是同种类型的，而列表中的各个值可以是不同类型的。NULL 是一个与向量相关的对象，用于表示空向量（与表示向量中的一个值为空的 NA 不同），通常指长度为 0 的向量。向量类型的层次图

每个向量都有两个关键属性。

类型。可以使用 typeof() 函数来确定向量的类型：

typeof(letters)
> [1] "character"
typeof(1:10)
> [1] "integer"

长度。可以使用 length() 函数来确定向量的长度：

x <- list("a", "b", 1:10)
length(x)
> [1] 3

14.2 重要的原子向量

4 种最重要的原子向量类型是逻辑型、整型、双精度型和字符型。

14.2.1 逻辑型

逻辑型向量是最简单的一种原子向量，因为它们只有 3 个可能的取值：FALSE、TRUE 和 NA。一般可以通过比较运算符来构建逻辑向量。还可以通过 c() 函数来手工创建逻辑向量：

1:10 %% 3 == 0
> [1] FALSE FALSE TRUE FALSE FALSE
> [2] TRUE FALSE FALSE TRUE FALSE
c(TRUE, TRUE, FALSE, NA)
> [1] TRUE TRUE FALSE NA

14.2.2 数值型

整型与双精度型向量统称为数值型向量。R 中默认数值是双精度型的。如果想要创建整型数值，可以在数字后面加一个 L：

typeof(1)
> [1] "double"
typeof(1L)
> [1] "integer"
1.5L
> [1] 1.5

双精度型是近似值。双精度型表示的是浮点数，不能由固定数量的内存精确表示。这意味着你应该将所有双精度数当成近似值。eg:

x <- sqrt(2) ^ 2 #2的平方根的平方
x
> [1] 2
x - 2
> [1] 4.44e-16

在比较浮点数时，不能使用 ==，而应该使用 dplyr::near()，后者可以容忍一些数据误差。

整型数据有 1 个特殊值 NA，而双精度型数据则有 4 个特殊值：NA、NaN、Inf 和 -Inf。其他 3 个特殊值都可以由除法产生：

c(-1, 0, 1) / 0
> [1] -Inf NaN Inf

不要使用 == 来检查这些特殊值，而应该使用辅助函数 is.finite()、is.infinite() 和 is.nan()。

14.2.3 字符型

字符向量每个元素都是一个字符串，可以包含任意数量的数据。

14.2.4 缺失值

每种类型的原子向量都有自己的缺失值：

NA # 逻辑型
> [1] NA
NA_integer_ # 整型
> [1] NA
NA_real_ # 双精度型
> [1] NA
NA_character_ # 字符型
> [1] NA

14.3 使用原子向量

14.3.1 强制转换

将一种类型的向量强制转换成另一种类型的方式有两种。

显式强制转换：当调用 as.logical()、as.integer()、as.double() 或 as.character() 这样的函数进行转换时，使用的就是显式强制转换。
隐式强制转换：当在特殊的上下文环境中使用向量，而这个环境又要求使用特定类型的向量时，就会发生隐式强制转换。

常见的隐式强制转换：在数值环境中使用逻辑向量。这种情况下，TRUE 转换为 1，FALSE 转换为 0。这意味着对逻辑向量求和的结果就是其中真值的个数，逻辑向量的均值就是其中真值的比例：

x <- sample(20, 100, replace = TRUE)
y <- x > 10
sum(y) # 大于10的数有多少个？
> [1] 44
mean(y) # 大于10的数的比例是多少？
> [1] 0.44

14.3.2 检验函数

检验向量类型的一种方法是使用 typeof() 函数，另一种方法是使用检验函数来返回 TRUE 或 FALSE。

14.3.3 标量与循环规则

R 可以对向量长度进行强制转换。这种转换称为向量循环，因为 R 会将较短的向量重复（或称循环）到与较长的向量相同的长度。为 R 中没有真正的标量，只有长度为 1 的向量。

两个长度不同的向量相加:

1:10 + 1:2
> [1] 2 4 4 6 6 8 8 10 10 12

R 会扩展较短的向量，使其与较长的向量一样长，这个过程就称作向量循环。这个过程是默默进行的，除非较长向量的长度不是较短向量长度的整数倍：

> 1:10 + 1:3
 [1]  2  4  6  5  7  9  8 10 12 11
Warning message:
In 1:10 + 1:3 : 长的对象长度不是短的对象长度的整倍数

虽然可以创建非常简洁优雅的代码，但向量循环也可以悄无声息地掩盖某些问题。为此，只要循环的不是一个标量，那么 tidyverse 中的向量化函数就会抛出一条错误消息。如果确实想要执行向量循环，那么你需要使用 rep() 函数手工完成：

> tibble(x = 1:4, y = 1:2)
  Error: Variables must be length 1 or 4.
  Problem variables: 'y'
> tibble(x = 1:4, y = rep(1:2, 2))
# A tibble: 4 x 2
      x     y
  <int> <int>
1     1     1
2     2     2
3     3     1
4     4     2

> tibble(x = 1:4, y = rep(1:2, each = 2))
# A tibble: 4 x 2
      x     y
  <int> <int>
1     1     1
2     2     1
3     3     2
4     4     2

14.3.4 向量命名

所有类型的向量都是可以命名的。使用 c() 函数创建向量时进行命名：

c(x = 1, y = 2, z = 4)
> c(x = 1, y = 2, z = 4)
x y z 
1 2 4

也可以在向量创建完成后，使用 purrr::set_names() 函数来命名：

> set_names(1:3, c("a", "b", "c"))
a b c 
1 2 3

14.3.5 向量取子集

[ 就是取子集函数，调用形式是 x[a]。

使用仅包含整数的数值向量。整数要么全部为正数，要么全部为负数，或者为 0。使用正整数取子集时，可以保持相应位置的元素：

x <- c("one", "two", "three", "four", "five")
x[c(3, 2, 5)]
> [1] "three" "two" "five"

# 位置可以重复，这样可以生成比输入更长的输出结果：
x[c(1, 1, 5, 5, 5, 2)]
> [1] "one" "one" "five" "five" "five" "two"

#使用负整数取子集时，会丢弃相应位置的元素：
x[c(-1, -3, -5)]
#> [1] "two" "four"

#正数与负数混合使用则会引发一个错误：
> x[c(1, -1)]
Error in x[c(1, -1)] : 只有负下标里才能有零

使用逻辑向量取子集。这种方式可以提取出 TRUE 值对应的所有元素，一般与比较函数结合起来使用效果最佳：

x <- c(10, 3, NA, 5, 8, 1, NA)
# x中的所有非缺失值
x[!is.na(x)]
> [1] 10 3 5 8 1
# x中的所有偶数值（或缺失值）
x[x %% 2 == 0]
> [1] 10 NA 8 NA

如果是命名向量，那么可以使用字符向量来取子集：

x <- c(abc = 1, def = 2, xyz = 5)
x[c("xyz", "def")]
> x[c("xyz", "def")]
xyz def 
  5   2

取子集的最简方式就是什么都不写：x[]，这样就会返回 x 中的全部元素。对于矩阵（或其他高维数据结构）这样可以取出所有的行或所有的列，只要将行或列保持为空即可。例如，如果 x 是二维的，那么 x[1, ] 可以选取出第 1 行和所有列，x[, -1] 则可以选取出所有行和除第 1 列外的所有列。

14.4 递归向量（列表）

可以使用 list() 函数创建列表：

x <- list(1, 2, 3)
x
> x
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

在处理列表时，str() 函数是一个非常有用的工具，因为其重点关注列表结构，而不是列表内容：

str(x)
> str(x)
List of 3
 $ : num 1
 $ : num 2
 $ : num 3

x_named <- list(a = 1, b = 2, c = 3)
str(x_named)
> str(x_named)
List of 3
 $ a: num 1
 $ b: num 2
 $ c: num 3

与原子向量不同，list() 中可以包含不同类型的对象：

> y <- list("a", 1L, 1.5, TRUE)
> str(y)
List of 4
 $ : chr "a"
 $ : int 1
 $ : num 1.5
 $ : logi TRUE

14.4.1 列表可视化

x1 <- list(c(1, 2), c(3, 4))
x2 <- list(list(1, 2), list(3, 4))
x3 <- list(1, list(2, list(3)))

可以用以下图形来表示它们：

列表可视化

这种可视化表示遵循以下 3 个原则。

列表用圆角矩形表示，原子向量用直角矩形表示。
子向量绘制在父向量中，而且背景要比父向量深一些，这样更容易表示出层次结构。
子向量的方向（也就是其行和列）并不重要，我们只在示例中表示出一行或一列。

14.4.2 列表取子集

列表取子集有 3 种方式：

a <- list(a = 1:3, b = "a string", c = pi, d = list(-1, -5))
> a
$a
[1] 1 2 3

$b
[1] "a string"

$c
[1] 3.141593

$d
$d[[1]]
[1] -1

$d[[2]]
[1] -5

使用 [ 提取子列表。

> str(a[1:2])
List of 2
 $ a: int [1:3] 1 2 3
 $ b: chr "a string"
> str(a[4])
List of 1
 $ d:List of 2
  ..$ : num -1
  ..$ : num -5

使用 [[ 从列表中提取单个元素。

> str(a[[1]])
 int [1:3] 1 2 3
> str(a[[4]])
List of 2
 $ : num -1
 $ : num -5

$ 是提取列表命名元素的简单方式，其作用与 [[ 相同，只是不需要使用括号：

> a$a
[1] 1 2 3
> a[["a"]]
[1] 1 2 3

对于列表来说，[ 和 [[ 之间的区别是非常重要的，因为 [[ 会使列表降低一个层级，而 [ 则会返回一个新的、更小的列表。如下图所示：

列表取子集的可视化表示

14.5 扩展向量

原子向量和列表是最基础的向量，使用它们可以构建出另外一些重要的向量类型，比如因子和日期。我们称构建出的这些向量为扩展向量，因为它们具有附加特性，其中包括类。因为扩展向量中带有类，所以它们的行为就与基础的原子向量不同。如：

因子
日期
日期时间
tibble

14.5.1 因子

因子是设计用来表示分类数据的，只能在固定集合中取值。因子是在整型向量的基础上构建的，添加了水平特性：

> x <- factor(c("ab", "cd", "ab"), levels = c("ab", "cd", "ef"))
> x
[1] ab cd ab
Levels: ab cd ef

> typeof(x)
[1] "integer"
> attributes(x)
$levels
[1] "ab" "cd" "ef"

$class
[1] "factor"

14.5.2 日期和日期时间

R 中的日期是一种数值型向量，表示从 1970 年 1 月 1 日开始的天数

> x <- as.Date("1971-01-01")
> x
[1] "1971-01-01"
> typeof(x)
[1] "double"
> attributes(x)
$class
[1] "Date

14.5.3 tibble

tibble 是扩展的列表，有 3 个类：tbl_df、tbl 和 data.frame。它的特性有 2 个：（列）names 和 row.names。

> tb <- tibble::tibble(x = 1:5, y = 5:1)
> tb
# A tibble: 5 x 2
      x     y
  <int> <int>
1     1     5
2     2     4
3     3     3
4     4     2
5     5     1
> typeof(tb)
[1] "list"
> attributes(tb)
$names
[1] "x" "y"

$row.names
[1] 1 2 3 4 5

$class
[1] "tbl_df"     "tbl"        "data.frame"

传统 data.frames 具有非常相似的结构：

> df <- data.frame(x = 1:5, y = 5:1)
> df
  x y
1 1 5
2 2 4
3 3 3
4 4 2
5 5 1
> typeof(df)
[1] "list"
> attributes(df)
$names
[1] "x" "y"

$class
[1] "data.frame"

$row.names
[1] 1 2 3 4 5

tibble 的类包括了 data.frame，这说明 tibble 自动继承了普通数据框的行为。