R语言-基础

第二章：数据与运算

2.1基础知识

211向量

向量是R语言中用于构成数据的基本单位。它们可以包含数值、字符或逻辑值，并且是创建更复杂数据结构（如数据框和矩阵）的基础。

创建向量

1. 赋值创建向量：使用赋值操作符 <- 可以创建向量。例如，创建一个包含数字1到4的向量：

   a <- c(1, 2, 3, 4)
   

   注意：在创建向量时，应该使用函数 c()，它代表“合并”（combine）。

2. 使用 c() 函数：c() 函数可以合并多个值来创建向量。例如：

   b <- c(1, 2, 3, 4)
   

   这里，b 是一个包含四个数字的向量。

3. 使用 : 运算符：: 运算符可以创建一个数值序列。例如，创建一个从1到4的序列：

   c <- 1:4
   

   这将创建一个向量 c，包含数字1, 2, 3, 4。

212对象

在R语言中，几乎所有事物都是对象。对象是类的具体实例，而类则是对具有共同特征的对象的抽象描述。

对象和类的概念

• 对象：在R中，数据结构（如向量、矩阵、数组、数据框、列表）和其他实体都是对象。对象是存储数据和函数的地方。
• 类：类定义了对象的类型和它能够执行的操作。例如，向量类定义了向量对象可以进行的操作，如数学运算和子集选择。

创建对象

在R中，使用赋值语句可以创建对象。例如：

x <- c(1, 2, 3, 4)  # 创建一个向量对象
y <- matrix(1:9, nrow = 3)  # 创建一个矩阵对象

查看对象和类

• 查看当前环境中的所有对象：使用 ls() 函数可以列出当前环境中的所有对象名。
• 查看对象的类：使用 class() 函数可以查看一个对象所属的类。例如，class(x) 将显示对象 x 的类。

213函数

函数是由若干语句组成的代码块，用于执行特定的任务或计算。在R中，函数是重用代码和实现复杂操作的核心。

内置函数分类

R语言内置了大量的函数，这些函数可以根据其功能进行分类：

1. 数值计算函数：用于执行数学运算，如 sum(), mean(), sqrt() 等。
2. 字符串处理函数：用于处理文本数据，如 paste(), gsub(), strsplit() 等。
3. 创建数据结构的函数：用于生成数据结构，如 c(), matrix(), data.frame() 等。
4. 描述统计函数：用于生成数据的统计摘要，如 summary(), var(), sd() 等。
5. 数据切片和抽取方法：用于选择和分析数据的子集，如 subset(), slice(), filter() 等。
6. 其他函数：包括数据处理、图形绘制、模型拟合等功能的函数。

用户自定义函数

除了使用内置函数外，R还允许用户编写自己的函数。自定义函数可以增强代码的可重用性和模块化。一个简单的自定义函数示例：

my_function <- function(x) {
  return(x^2)
}

这个函数接受一个参数 x，并返回其平方。

214标识符与保留字

标识符

标识符是用于命名对象和函数的字符串。在R中，标识符的命名和使用遵循以下规则：

1. 组成：标识符可以由数字、字母（区分大小写）、点和下划线组成。
2. 开头：标识符可以以点开头，但第二位不能是数字。
3. 区分大小写：R是区分大小写的，因此 MyVar 和 myvar 是不同的标识符。

保留字

保留字是R语言中具有特定意义的单词，不能用作标识符。这些包括：

• 控制流语句：if, else, repeat, while, function, for, in, break, next
• 常量：TRUE, FALSE, NULL, Inf, NaN
• 特殊值：NA, 以及以 NA_ 开头的一系列特殊值表示不同类型的缺失数据（如 NA_character_）

使用这些保留字作为标识符会导致语法错误。因此，在命名变量和函数时，应避免使用这些单词。

2.2数据类型与数据表示

221基本数据类型

在R语言中，基本数据类型共有六种：

1. 逻辑型（logical）：表示真（TRUE）或假（FALSE），也可以是逻辑表达式，如 2 < 3。

2. 浮点型（double）：表示带小数的实数，以十进制形式表示。

3. 整数型（integer）：在R中，为了明确表示一个整数，需要在其后加上后缀 L，例如 3L。

4. 字符型（character）：包含文本的数据，需要用双引号或单引号括起来。

5. 复数类型（complex）：包含实部和虚部，虚部以 i 或 j 结尾，例如 2+3i。

6. 原始类型（raw）：用于存储原始的字节数据。

要检查一个对象的类型，可以使用 typeof() 函数。此外，is.*() 函数族（如 is.logical(), is.double(), is.integer() 等）可以用来测试一个对象是否属于特定的数据类型，如果属于则返回 TRUE，否则返回 FALSE。

在R中处理字符串时，字符串向量中的每个元素都需要用引号括起来。若要合并向量中的字符串并创建一个句子，paste() 函数是一个更好的选择，而不是 str()。paste() 函数可以合并字符串，并且可以指定分隔符。cat() 函数则用于打印输出，它会合并并显示字符串，但不会改变原始对象。

关于转义字符，R语言使用反斜杠 \ 作为转义字符。例如，\n 用于换行，\t 用于制表符（相当于四个空格），以及其他如 \r（回车）、\b（退格）等。要表示一个反斜杠本身或引号，需要使用转义字符，例如 \\ 表示一个反斜杠，\" 或 \' 表示双引号或单引号。

222变量

在R语言中，变量用于存储数据，这些数据存储在内存中，并且可以根据需要改变。变量的命名规则与标识符的命名规则相同，但有一些特定的规则需要遵守：

1. 变量名必须以字母或点号开头：这意味着变量名不能以数字或特殊字符（如 %, #, $ 等）开头。

2. 可以使用字母、数字、点号和下划线：变量名可以包含字母（大写或小写）、数字、点号（.）和下划线（_）。

3. 区分大小写：在R中，大写字母和小写字母是区分开的，因此 Variable 和 variable 是两个不同的变量。

4. 不能使用R的关键字：变量名不能是R语言中的关键字，如 if, else, function 等。

5. 长度限制：虽然R没有硬性限制变量名的长度，但为了代码的可读性和易用性，建议变量名简洁明了。

223常量

在R语言中，常量是指那些在程序执行过程中不会改变的量。它们通常用于表示固定的值，如数学常数、预定义的序列等。R语言中的一些内置常量包括：

1. letters：包含所有小写字母的字符向量。

2. LETTERS：包含所有大写字母的字符向量。

3. month.name：包含所有月份全名的字符向量。

4. month.abb：包含所有月份缩写的字符向量。

5. pi：数学常数π的近似值。

这些常量在R中预定义，可以直接在代码中使用，无需额外定义。例如，要引用数学常数π，可以直接使用 pi 而不是写出一个近似的数值。

虽然R语言没有像其他编程语言那样明确规定常量，但通常的做法是将不会改变的值定义为常量，以提高代码的可读性和可维护性。在R中，可以通过将变量赋值给一个不变的值来模拟常量的行为，并遵循命名惯例，如使用大写字母来命名常量，以区别于普通变量。

224特殊值

在R语言中，有几种特殊值用于表示特定的数据状态：

1. NA：表示缺失值，用于表示数据中缺少的或不可用的值。NA可以用于任何数据类型。

2. Inf：表示无穷大。在数值计算中，当一个结果超过了R能够表示的最大数值时，会返回Inf。例如，1/0 将返回 Inf。

3. -Inf：表示负无穷大。与Inf相对，当数值计算结果是一个非常小的负数，小于R能够表示的最小数值时，会返回-Inf。例如，-1/0 将返回 -Inf。

4. NaN：表示“不是一个数字”（Not a Number）。当进行一个无意义的数学运算（如 0/0）时，结果将是NaN。

5. NULL：表示空值或不存在。在R中，NULL是一个不包含任何值的数据类型。它通常用于表示空数据结构或初始化变量。需要注意的是，NULL在计算长度时不会被计算在内。

这些特殊值在数据处理和分析中非常重要，因为它们提供了处理缺失数据、异常值和空值的标准方法。

2.3基本运算

在R语言中，基本运算符用于执行数学运算、比较值和逻辑操作。除了常见的运算符，R还提供了一些特殊的运算符：

1. %%：求余 - 对两个数进行除法运算后，返回余数。例如，7 %% 3 的结果是 1。

2. %/%：整除 - 对两个数进行除法运算，并返回结果的整数部分。例如，7 %/% 3 的结果是 2。

3. ＆：与 - 逻辑与运算符，当两边的表达式都为真时，结果为真。例如，TRUE & TRUE 的结果是 TRUE。

4. ｜：或 - 逻辑或运算符，当两边的表达式至少有一个为真时，结果为真。例如，FALSE | TRUE 的结果是 TRUE。

5. ！：非 - 逻辑非运算符，用于反转表达式的真值。例如，!TRUE 的结果是 FALSE。

在R中，运算符的优先级决定了它们在表达式中的执行顺序。运算优先级从高到低依次是：

1. 括号 - 使用括号可以改变运算的顺序。

2. 函数运算 - 函数调用。

3. 算术运算符 - 如 +, -, *, / 等。

4. 字符连接 - 使用 paste() 函数或运算符  paste0() 进行字符连接。

5. 关系运算符 - 如 ==, !=, <, >, <=, >=。

6. 逻辑运算符 - 如 !, ＆, ｜。

理解运算符的优先级对于编写正确的R代码非常重要，尤其是在复杂的表达式中。

2.4数据类型转换

241自动转换类型

在R语言中，数据类型的自动转换遵循一定的规律，通常发生在进行运算或比较时。这种转换被称为“隐式类型转换”。自动转换的规律可以概括为“大小听话轮”，即：

1. 逻辑型（logical）：在需要转换时，逻辑值 TRUE 被转换为 1，而 FALSE 被转换为 0。

2. 整数型（integer）：当与浮点数进行运算时，整数会被转换为浮点数。

3. 浮点型（double）：在进行字符连接或与字符进行比较时，浮点数会被转换为字符型。

4. 字符型（character）：在R中，字符型数据通常不会自动转换为其他类型，除非在特定情况下，例如在使用数学函数时。

这种转换遵循从“小”类型到“大”类型的方向：逻辑型（最小）→ 整数型 → 浮点型 → 字符型（最大）。这种转换机制确保了在混合类型数据进行运算时，R能够合理地处理数据，但也可能导致意外的结果。因此，了解和预期这些转换对于编写准确和高效的R代码至关重要。

242强制转换类型

在R语言中，除了自动类型转换，还可以通过强制类型转换来显式地将一个对象转换为特定的数据类型。强制类型转换使用 as.*() 函数族，其中 * 代表目标数据类型。基本格式是 as.A(n)，其中 A 是目标数据类型，n 是要转换的对象。

例如：

1. 转换为逻辑型：as.logical(x) 将 x 转换为逻辑型。非零数值转换为 TRUE，零转换为 FALSE。

2. 转换为整数型：as.integer(x) 将 x 转换为整数型。小数部分会被截断。

3. 转换为浮点型：as.double(x) 将 x 转换为浮点型。整数和字符型数据可以被转换为相应的浮点数值。

4. 转换为字符型：as.character(x) 将 x 转换为字符型。数值会被转换为它们的字符表示。

5. 转换为复数型：as.complex(x) 将 x 转换为复数型。如果 x 是字符型，它应该表示为一个复数。

强制类型转换是一种非常有用的工具，特别是在处理来自不同源的数据时，或者当需要确保变量是特定类型以进行某些操作时。然而，需要注意的是，不恰当的强制类型转换可能会导致数据丢失或意外的结果。

第三章：程序设计基础

3.1控制流

控制流是编程语言中用于控制程序执行顺序的结构。在R语言中，控制流主要有以下四种结构：

1. 顺序结构

顺序结构是程序中最基本的结构，它表示程序按代码的先后顺序依次执行。在R中，除非特别指定，代码默认就是按照顺序执行的。

2. 分支结构

分支结构基于条件执行不同的代码路径。R语言提供了if、else if和else关键字来实现单分支、双分支和多分支选择结构。此外，分支结构可以嵌套，即一个分支结构内部可以包含另一个分支结构。

• 单分支：只有if语句，当条件满足时执行一段代码。
• 双分支：if语句加上else语句，条件满足时执行一段代码，不满足时执行另一段代码。
• 多分支：使用if、else if和else，根据多个条件选择不同的代码路径。
• 嵌套分支：一个分支结构内包含另一个分支结构。

3. 循环结构

循环结构允许重复执行一段代码，直到满足某个条件。R语言中有几种循环结构：

• repeat循环：创建一个永久循环，直到使用break语句跳出。
• while循环：当条件成立时，重复执行一段代码。
• for循环：执行固定次数的循环，通常与序列一起使用。
• next/break：在循环内部使用next跳过当前迭代，或使用break提前退出循环。

4. 选择函数

R语言还提供了特定的函数来处理控制流，例如：

• lftest函数：用于执行逻辑函数测试。
• switch函数：根据给定的表达式选择执行不同的代码路径。

示例代码

以下是每种控制流结构的简单示例：

# 顺序结构
x <- 5
y <- x + 3
print(y)

# 分支结构
if (x > 10) {
  print("x is greater than 10")
} else if (x > 5) {
  print("x is between 5 and 10")
} else {
  print("x is 5 or less")
}

# 循环结构
for (i in 1:5) {
  print(i)
}

# 选择函数
result <- switch(
  x,
  "one" = "x is 1",
  "two" = "x is 2",
  "x is not 1 or 2"
)
print(result)

311顺序结构

顺序结构是R语言中的基本控制流，它按照代码的书写顺序自上而下执行。以下是两个关于顺序结构的重要点：

1. 将多行命令并入一行

在R中，您可以在一行内执行多个命令，只需在每个命令后添加分号（;）。这样做可以使代码更加紧凑。

x <- 5; y <- x + 3; print(y)

2. 使用大括号{}连接多行命令

当您需要执行一系列相互关联的语句时，使用大括号{}将这些语句组合成一个代码块。这在编写if语句或其他控制流结构时特别有用。

例如，在if函数内部：

if (x > 0) {
  y <- x^2
  print(y)
}

在这个例子中，y <- x^2和print(y)只有在x > 0时才执行。使用大括号将这些命令组合起来，确保它们作为一个整体被执行。

312分支结构

R语言中的分支结构允许程序根据条件选择性地执行代码。这些结构主要由if、else if和else语句构成。

1. 单分支结构 - if

单分支结构仅检查一个条件，如果该条件为真，则执行相应的代码块。

if (condition) {
  # 执行某些操作
}

2. 双分支结构 - if...else

双分支结构检查一个条件，并根据条件的真假执行两个不同的代码块。

if (condition) {
  # 条件为真时执行的代码
} else {
  # 条件为假时执行的代码
}

3. 多分支结构 - if...else if...else

多分支结构检查多个条件，并根据这些条件的真假执行不同的代码块。

if (condition1) {
  # 条件1为真时执行的代码
} else if (condition2) {
  # 条件1为假且条件2为真时执行的代码
} else {
  # 所有条件都为假时执行的代码
}

4. 嵌套分支结构 - if...if...if...else

嵌套分支结构中，if语句嵌套在其他if语句中。else子句与最近的未配对的if语句配对。

if (condition1) {
  if (condition2) {
    # 条件1和条件2都为真时执行的代码
  } else {
    # 条件1为真但条件2为假时执行的代码
  }
} else {
  # 条件1为假时执行的代码
}

在嵌套分支中，每个else子句与最近的未配对的if语句配对。

313循环结构

R语言中的循环结构用于重复执行代码块，直到满足某个条件。主要的循环结构包括repeat、while和for循环。

1. repeat循环

repeat循环会无限重复执行其内部的代码块，直到遇到break语句。

repeat {
  # 语句块
  if (condition) {
    break
  }
}

在repeat循环中，if语句通常用于设置停止条件。如果没有满足if条件，循环将一直重复执行。

2. while循环

while循环在满足条件表达式的情况下重复执行代码块。

while (condition) {
  # 语句块
}

只要条件表达式为真，while循环就会一直执行其内部的代码块。

3. for循环

for循环通过一个序列（通常是向量）来重复执行代码块。

for (name in vector) {
  # 语句块
}

在这个循环中，代码块对向量vector中的每个元素执行一次。

4. next和break语句

• next语句用于跳过当前循环的剩余部分，直接进入下一次循环。
• break语句用于立即退出循环。

for (i in 1:5) {
  if (i == 3) next  # 跳过i等于3的情况
  print(i)
  if (i == 4) break  # 当i等于4时退出循环
}

在这个例子中，当i等于3时，next语句会导致循环跳过打印操作。而当i等于4时，break语句会导致循环完全停止。

314选择相关函数

R语言中的选择函数用于根据条件选择性地执行或返回不同的值。两个常用的选择函数是ifelse和switch。

1. ifelse函数

ifelse函数是R中的一个向量化的if-else语句，它根据条件向量来选择返回值。

ifelse(test, yes, no)

• test: 一个逻辑向量，用于测试每个元素是否为真。
• yes: 如果test中的元素为真，则返回这个值。
• no: 如果test中的元素为假，则返回这个值。

示例：

result <- ifelse(c(T, F, T), "Yes", "No")
print(result)  # 输出: "Yes" "No" "Yes"

在这个例子中，result的每个元素根据test的逻辑值选择返回"Yes"或"No"。

2. switch函数

switch函数用于根据给定的值选择性地执行或返回函数列表中的元素。

switch(EXPR, ...)

• EXPR: 一个表达式，用于选择列表中的元素。
• ...: 一个或多个表达式或函数，用于EXPR的每个可能值。

示例：

# 当EXPR为整数时
result <- switch(2, "One", "Two", "Three")
print(result)  # 输出: "Two"

# 当EXPR为字符串时
result <- switch("Three", One="First", Two="Second", Three="Third")
print(result)  # 输出: "Third"

在第一个例子中，switch根据整数索引选择列表中的第二个元素。在第二个例子中，它根据字符串匹配选择相应的元素。如果找不到匹配项，switch默认返回NULL。

3.2函数设计

321函数的声明，定义和调用

在R中，函数是用于执行特定任务的自包含代码块。函数通过将输入参数（形式参数）转换为输出（返回值）来实现这一目的。

1. 函数的声明和定义

函数通过function关键字来声明和定义。函数的基本结构如下：

函数名 <- function(arg1, arg2, ...) {
  # 函数体
  return(表达式)
}

• 函数名: 用于调用函数的名称。
• arg1, arg2, ...: 函数的形式参数，用于接收传递给函数的值。
• 函数体: 函数的具体实现步骤，包括计算和处理数据。
• return: 语句用于指定函数的返回值，并停止执行函数。

2. 函数的调用

定义函数后，可以通过提供实际参数来调用它。调用格式如下：

函数名(实际参数1, 实际参数2, ...)

实际参数是将传递给函数的形式参数的具体值。

下面是一个简单的函数示例，该函数接受两个数字作为输入，计算它们的和，并返回结果：

add <- function(x, y) {
  sum <- x + y
  return(sum)
}

result <- add(3, 4)
print(result)  # 输出: 7

在这个例子中，add是一个接受两个参数x和y的函数。函数体计算它们的和，并使用return语句返回结果。然后，我们通过add(3, 4)调用这个函数，并将结果存储在result变量中。

3.3综合应用

331求最大公约数和最小公倍数

最大公约数（GCD）

最大公约数是两个或多个整数共有的最大的约数。在R中，我们可以使用gcd函数从numbers包中计算最大公约数。

首先，确保安装了numbers包：

install.packages("numbers")

然后，使用gcd函数：

library(numbers)

gcd <- function(a, b) {
  return(gcd(a, b))
}

# 示例
result_gcd <- gcd(60, 48)
print(result_gcd)  # 输出: 12

最小公倍数（LCM）

最小公倍数是能被两个或多个整数共同整除的最小正整数。在R中，我们可以使用以下公式计算最小公倍数：

在R中实现：

lcm <- function(a, b) {
  return(abs(a * b) / gcd(a, b))
}

# 示例
result_lcm <- lcm(60, 48)
print(result_lcm)  # 输出: 240

在这个例子中，我们首先定义了一个gcd函数来计算最大公约数，然后定义了一个lcm函数来计算最小公倍数。这两个函数都接受两个整数作为输入，并返回相应的结果。

332求素数

检查素数的函数

is_prime <- function(n) {
  if (n <= 1) {
    return(FALSE)
  }
  for (i in 2:sqrt(n)) {
    if (n %% i == 0) {
      return(FALSE)
    }
  }
  return(TRUE)
}

这个is_prime函数接受一个整数n作为输入，并返回一个逻辑值，指示该数是否为素数。函数首先检查n是否小于或等于1，如果是，则返回FALSE。然后，函数使用一个for循环来检查从2到sqrt(n)的每个数是否能整除n。如果能找到任何这样的数，函数返回FALSE；否则，返回TRUE。

找出一定范围内的所有素数

使用is_prime函数，我们可以找出一定范围内的所有素数：

find_primes <- function(max_number) {
  primes <- c()
  for (i in 2:max_number) {
    if (is_prime(i)) {
      primes <- c(primes, i)
    }
  }
  return(primes)
}

# 示例：找出1到100之间的所有素数
primes_up_to_100 <- find_primes(100)
print(primes_up_to_100)

在这个例子中，find_primes函数接受一个整数max_number作为输入，并返回一个包含从2到max_number之间所有素数的向量。函数内部，我们使用is_prime函数来检查每个数是否为素数，并将素数添加到结果向量中。

333打印金字塔图形

print_pyramid <- function(height) {
  for (i in 1:height) {
    # 打印空格
    cat(rep(" ", height - i))
    # 打印星号
    cat(rep("* ", i))
    # 换行
    cat("\n")
  }
}

# 示例：打印一个高度为5的金字塔
print_pyramid(5)

在这个例子中，print_pyramid函数接受一个整数height作为输入，表示金字塔的高度。函数使用一个for循环来控制金字塔的每一行。在内循环中，首先打印一定数量的空格，然后打印星号，每行的星号数量比上一行多一个。最后，使用cat("\n")进行换行，开始下一行的打印。

运行这个函数将打印出一个漂亮的金字塔图形：

    *
   * *
  * * *
 * * * *
* * * * *

第五章：数据结构与数据处理

5.1向量

511创建向量

在R语言中，创建向量是基础且常用的操作。有几种方法可以创建向量：

1. 直接赋值：直接给向量赋值。
2. 使用c()函数：通过连接多个值来创建向量。
3. 使用“:”操作符：创建一个数值序列。

此外，还有一些特殊函数可以用来创建特定类型的向量。

使用seq()创建等差数列

seq()函数用于生成等差数列。其格式如下：

seq(from = num1, to = num2, by = num3, length.out = num4)

• from：序列的起始值。
• to：序列的结束值。
• by：序列中每两个相邻值的差（步长）。默认为1。
• length.out：生成的序列的长度。例如，要生成一个长度为5的序列，即使from和to的数量级相差很大。

使用rep()创建重复向量

rep()函数用于重复向量中的元素。其格式如下：

rep(x, times = num)

• x：要重复的向量。
• times：重复的次数。

示例

1. 使用seq()创建一个从1到10的等差数列：

   seq(1, 10)
   

2. 使用rep()重复向量c(1, 2, 3)三次：

   rep(c(1, 2, 3), times = 3)
   

通过这些方法，可以灵活地在R中创建各种向量，满足不同的数据需求。

512使用索引访问向量元素

在R中，可以使用索引来访问和修改向量中的元素。索引的使用方法如下：

向量1[向量2]

这里，向量2通常包含正整数，表示从向量1中提取索引值对应的元素。

使用正数索引

R中的索引从1开始，这与Python等其他编程语言不同（它们从0开始）。

使用负数索引

在R中，使用负数索引表示删除对应位置的元素，并返回剩余的元素。例如，对于向量a <- c("a", "b", "c", "d")，a[-1]将返回"b", "c", "d"。

使用逻辑索引

逻辑索引使用逻辑值（TRUE或FALSE）来选择元素。例如，a[c(TRUE, FALSE)]将从a中选择所有在TRUE位置的元素。

修改向量元素

可以使用索引来修改向量中的元素。例如，mec_vec[10] <- 33会将mec_vec中索引为10的元素值改为33。如果向量原长度不足10，R会自动扩展向量，并在新位置填充NA。

在向量中添加元素

要在向量的特定位置添加元素，可以使用以下方法：

A <- c(A[1:n], m, A[(n+1):length(A)])

这段代码将向量A重新初始化，保持1:n位置的元素不变，在n之后添加新元素m，然后保持n+1到向量末尾的元素不变。

另外，也可以使用append()函数来简化这一过程：

append(A, m, after=n)

这会在n之后添加m。需要注意的是，如果添加的是字符串（如'm'），而原向量是数值型，那么整个向量的类型可能会变为字符型。

513循环补齐

循环补齐是R中一种特殊的向量操作机制，当进行运算或函数调用时，如果两个向量的长度不同，R会自动重复较短向量的元素，以匹配较长向量的长度。

例子

考虑以下向量相加的例子：

c(1, 2, 3) + c(1, 2, 3, 4, 5, 6, 7)

在这个例子中，第一个向量c(1, 2, 3)长度为3，而第二个向量c(1, 2, 3, 4, 5, 6, 7)长度为7。为了进行相加，R会将第一个向量循环补齐，使其长度与第二个向量相同。补齐后的向量变为c(1, 2, 3, 1, 2, 3, 1)。

然后进行逐元素相加：

• 1 + 1 = 2
• 2 + 2 = 4
• 3 + 3 = 6
• 1 + 4 = 5
• 2 + 5 = 7
• 3 + 6 = 9
• 1 + 7 = 8

最终结果为c(2, 4, 6, 5, 7, 9, 8)。

注意事项

• 循环补齐只在必要且可行时才会发生。如果向量长度差异太大，或者无法通过重复较短向量来匹配较长向量，R会报错。
• 循环补齐是R的一种特性，在其他编程语言中可能不存在或表现不同。

514向量的比较

在R中，向量之间的比较是按索引位置进行的，比较结果是一个逻辑向量，其中每个元素表示相应位置上的比较结果。

按索引比较

例如，比较两个向量c(1, 2, 3)和c(1, 3, 2)：

c(1, 2, 3) == c(1, 3, 2)

这将返回一个逻辑向量c(TRUE, FALSE, FALSE)，表示第一个元素相等，后两个元素不相等。

使用identical()进行比较

identical()函数用于检查两个对象是否完全相同。如果两个向量在所有元素和属性上都相同，则返回TRUE，否则返回FALSE。

identical(V1, V2)

需要注意的是，由于浮点数的精度问题，即使数值上看起来相等，identical()也可能返回FALSE。例如，1.4 - 0.9并不完全等于0.5。

使用all()和any()函数

all()和any()函数用于检查逻辑向量中的元素。

• all()：如果所有元素都是TRUE，则返回TRUE。
• any()：如果至少有一个元素是TRUE，则返回TRUE。

例如，对于向量V1，使用all(V1 > 3)将检查V1中所有元素是否都大于3。

515按条件提取元素

在R中，可以使用条件表达式在方括号[]内来提取满足特定条件的向量元素。这种操作通常称为子集选择。

语法和示例

假设有一个向量v，您想要提取所有大于某个值x的元素。可以使用以下语法：

v[v > x]

例如，对于向量v <- c(1, 3, 5, 7, 9)，如果您想要提取所有大于5的元素，可以这样做：

v[v > 5]

这将返回7和9，因为它们是v中大于5的元素。

使用逻辑运算符

您可以使用各种逻辑运算符来构建更复杂的条件，例如：

• >：大于
• <：小于
• ==：等于
• >=：大于或等于
• <=：小于或等于
• !=：不等于

例如，提取所有大于等于5且小于等于7的元素：

v[v >= 5 & v <= 7]

结合多个条件

您还可以结合多个条件，使用逻辑运算符&（且）和|（或）：

• 使用&来选择同时满足多个条件的元素。
• 使用|来选择满足任一条件的元素。

例如，提取所有大于5或小于3的元素：

v[v > 5 | v < 3]

注意事项

• 条件表达式必须返回一个逻辑向量，其长度与被筛选的向量相同。
• 确保使用适当的括号来明确逻辑运算的顺序。

5.2矩阵与数组

521创建矩阵

矩阵是R中的一种基本数据结构，用于存储和操作二维数组。在R中，有多种方法可以创建矩阵。

使用dim()转换向量

通过dim()函数，可以将一个向量转换成矩阵。方法是先创建一个向量，然后用dim()指定行数和列数。

vec <- c(1, 2, 3, 4, 5, 6)
dim(vec) <- c(2, 3)

这将创建一个2行3列的矩阵。在R中，默认是按列填充矩阵。

使用matrix()函数

matrix()函数是创建矩阵的另一种方法。其格式如下：

matrix(data = NA, nrow = num1, ncol = num2, byrow = FALSE, dimnames = NULL)

• data：用于指定矩阵的数据。
• nrow：指定矩阵的行数。
• ncol：指定矩阵的列数。
• byrow：逻辑值，表示元素是否按行填充。默认为FALSE，即按列填充。
• dimnames：为矩阵的行和列命名。

例如，创建一个3行2列的矩阵：

matrix(c(1, 2, 3, 4, 5, 6), nrow = 3, ncol = 2)

特殊矩阵

• 使用diag()创建对角矩阵：

  diag(c(1, 2, 3))
  

  这将创建一个3x3的对角矩阵，其对角线上的元素为1, 2, 3。

合并矩阵

• 使用rbind()按行合并矩阵或向量。
• 使用cbind()按列合并矩阵或向量。

例如，合并两个向量：

rbind(c(1, 2, 3), c(4, 5, 6))
cbind(c(1, 2, 3), c(4, 5, 6))

522矩阵乘法

R提供了丰富的函数来进行矩阵运算，包括矩阵乘法、转置、求逆矩阵等。

矩阵乘法

在R中，矩阵乘法使用%*%运算符。例如，如果A和B是两个矩阵，它们的乘积可以用以下方式计算：

result <- A %*% B

转置矩阵

矩阵的转置可以通过t()函数得到。例如，A的转置为t(A)。

求逆矩阵

solve()函数用于求解矩阵的逆。如果A是一个方阵，其逆矩阵可以用solve(A)得到。

计算行列式

行列式可以使用det()函数计算。例如，矩阵A的行列式为det(A)。

求解特征值和特征向量

eigen()函数用于计算矩阵的特征值和特征向量。例如，eigen(A)将返回矩阵A的特征值和特征向量。

求解线性方程组

在R中，线性方程组Ax = b可以通过solve()函数求解。其中A是系数矩阵，b是常数列向量。解向量x可以通过以下方式得到：

x <- solve(A, b)

这个例子中的描述有一点小错误，solve(A, b)实际上是求解Ax = b，返回的是方程组的解向量x，而不是A + b的逆。

523使用矩阵索引

在R中，可以使用索引来访问和修改矩阵中的元素。索引使用方括号[]，并可以指定行和列的位置。

访问单个元素

要访问矩阵中的单个元素，可以指定其行号和列号。例如，对于矩阵M，访问第i行第j列的元素可以这样写：

element <- M[i, j]

访问行或列

使用:运算符可以访问矩阵中的行或列。例如，要访问矩阵M的第i行到第j行和第k列到第l列的所有元素：

sub_matrix <- M[i:j, k:l]

使用负数索引

在R中，使用负数索引可以从矩阵中去除指定的行或列。例如，M[-i, ]将返回除了第i行之外的所有行。

赋值操作

同样，可以使用索引来修改矩阵中的元素。例如，将矩阵M中第i行第j列的元素赋值为value：

M[i, j] <- value

524apply函数族

apply()函数族是R中用于对矩阵或数组进行批量操作的函数。它通过应用函数来简化对矩阵或数组的行或列的处理。

apply()函数的基本用法

apply()函数的基本格式如下：

apply(X, MARGIN, fun)

• X：矩阵或数组。
• MARGIN：一个或两个整数，表示要应用函数的维度。对于矩阵，MARGIN=1表示对每一行应用函数，MARGIN=2表示对每一列应用函数。
• fun：要应用的函数。

应用场景

apply()函数常用于计算矩阵的行或列的统计量，如均值、标准差、求和等。例如，计算矩阵M每一行的均值：

row_means <- apply(M, 1, mean)

apply()函数的灵活性

• apply()函数非常灵活，可以与各种统计函数结合使用。
• 它适用于矩阵或数组，但对于更高维的数据结构，apply()可能不是最佳选择。

示例

计算矩阵M每一列的和：

col_sums <- apply(M, 2, sum)

这个操作会将矩阵M“压扁”，即计算每一列的元素和。

525多维数组

多维数组是R中用于存储和操作多维数据的基本数据结构。在R中，可以使用array()函数来创建多维数组。

array()函数的基本用法

array()函数的基本格式如下：

array(data = NA, dim = length(data), dimnames = NULL)

• data：必选参数，用于指定数组中的元素值。可以是向量、矩阵或其他R支持的数据类型。
• dim：可选参数，一个整数向量，用于指定数组的维度。例如，dim = c(2, 3)表示创建一个2行3列的数组。
• dimnames：可选参数，用于指定数组各维度的名称。是一个嵌套的列表，例如dimnames = list(c("row1", "row2"), c("col1", "col2", "col3"))表示给数组的第一维定义名为"row1"和"row2"，第二维定义名为"col1"、“col2"和"col3”。

示例

创建一个2行3列的数组，元素为向量c(1, 2, 3, 4, 5, 6)：

my_array <- array(c(1, 2, 3, 4, 5, 6), dim = c(2, 3), dimnames = list(c("row1", "row2"), c("col1", "col2", "col3")))

注意事项

• 数组的维度必须是一个整数向量，其中每个元素表示相应维度的大小。
• dimnames参数是可选的，但提供了对数组元素进行更清晰标注的途径。

5.3数据框

531创建数据框

数据框是R中用于存储和操作表格数据的基本数据结构，它允许不同的列包含不同类型的数据。

data.frame()函数的基本用法

data.frame()函数的基本格式如下：

data.frame(col1, col2, stringsAsFactors = FALSE)

• col1、col2等：数据框中的列，可以是向量、因子、数值型或逻辑型数据。
• stringsAsFactors：一个逻辑值，表示是否将字符串向量自动转换为因子向量。默认为TRUE，但建议设置为FALSE，特别是在处理外部数据时。

添加行或列

• 使用rbind()添加行：

  rbind(df, list(row1, row2, ...))
  

• 使用cbind()添加列：

  cbind(df, colname1 = c(value1, value2, ...), colname2 = c(value2, value3, ...))
  

合并数据框

使用merge()函数可以合并两个或多个数据框。合并时，数据框必须具有相同的列作为合并的依据。

merge(df1, df2)

注意事项

• row.names参数用于指定行名，默认为NULL，即不指定行名。
• check.names参数用于指定是否检查列名是否合法，默认为TRUE。

532访问数据库中的元素

在R中，可以使用多种方法来访问数据框中的元素，包括使用索引、列名和行名。

使用索引访问数据框

• 使用方括号[]和行号来访问数据框中的特定行。例如，访问数据框df的第二行：

  second_row <- df[2, ]
  

• 使用方括号和列名来访问数据框中的特定列。例如，访问数据框df的名为"col1"的列：

  specific_column <- df[, "col1"]
  

• 使用美元符号$来访问数据框中的特定列。例如，访问数据框df的名为"col1"的列：

  specific_column <- df$col1
  

查询和修改行名和列名

• 使用rownames()函数查询或修改行名。例如，查询数据框df的行名：

  rownames(df)
  

• 使用colnames()函数查询或修改列名。例如，修改数据框df的名为"col1"的列名：

  colnames(df)[1] <- "new_col1_name"
  

• 在查询时，直接在方括号中加上数据框名。例如，查询名为df的数据框的第二个元素：

  second_element <- df[2, 1]
  

• 在修改时，指定数据框后使用<-符号来赋值。例如，将数据框df的第二行第一个元素修改为5：

  df[2, 1] <- 5

5.4因子

因子是R中用于存储和操作分类数据的一种特殊数据类型。它将文本或数字数据转换为可以进行分类统计的变量。

创建因子

使用factor()函数可以创建因子。例如，将一个向量转换为因子：

my_vector <- c("A", "B", "A", "C", "B")
my_factor <- factor(my_vector)

在factor()函数中，重复的元素会被合并为一种因子。

修改因子水平

创建因子后，可以使用levels()函数来重新定义因子水平。例如，将因子df$my_factor的水平顺序从factor1, factor2, factor3改为2, 3, 1：

levels(df$my_factor) <- c("因子2", "因子3", "因子1")

因子的设定原因

因子的一个重要用途是确保数据的分类一致性。例如，一个样本的类别设定为ABC，创建因子后，如果输入不属于ABC的数据，R会提示错误。

向因子中添加新元素

向已有的因子中添加一个不存在的元素会导致该位置为空值。

因子的应用

因子在数据分析中广泛应用于分类汇总和统计。例如，在描述性统计分析中，因子可以用来表示不同类别之间的差异。

5.5列表

列表是R中用于存储和操作不同类型对象的复合数据结构。它允许将多个向量、矩阵、数据框、函数等对象组合在一起。

创建列表

使用list()函数可以创建列表。例如，创建一个包含向量、矩阵和数据框的列表：

my_list <- list(vec = c(1, 2, 3), mat = matrix(1:9, nrow = 3), df = data.frame(col1 = 1:3, col2 = 4:6))

在列表中，使用=符号来赋值，而不是<-。

访问列表元素

• 使用方括号[]和整数索引来访问列表中的特定元素。例如，访问列表my_list的第二个元素：

  second_element <- my_list[[2]]
  

• 使用美元符号$来访问列表中的特定项目。例如，访问列表my_list中名为"mat"的项目：

  mat_element <- my_list$mat
  

• 使用方括号和项目名来访问列表中的特定元素。例如，访问列表my_list中名为"col1"的数据框的列：

  column <- my_list$df$col1
  

如果通过方括号输入整数索引，R会返回整个列表，而不是直接访问项目。

列表的应用

列表在数据分析中用于存储和操作复杂数据结构，如数据预处理步骤的集合、模型的参数列表等。

5.6数据的导入与导出

561数据文件的读写

R提供了多种函数来读取和写入数据文件，如read.table()和write.table()。

读取数据文件

使用read.table()函数可以读取数据文件。其基本格式如下：

data <- read.table("文件名地址（通常是盘符:/文件名带后缀）", header = TRUE, sep = "")

• header = TRUE：表示文件包含表头，即文件的第一行包含列名。
• sep = ""：表示文件中各列之间的分隔符。对于CSV文件，通常使用逗号","作为分隔符，此时应将sep设置为","。

例如，读取一个CSV文件：

data <- read.csv("file.csv")

写入数据文件

使用write.table()函数可以将数据写入文件。其基本格式如下：

write.table(数据, file = "带盘符文件名")

• 数据：要写入文件的数据，可以是数据框、矩阵或其他R支持的类型。
• file：写入文件的路径和名称。

例如，将数据框df写入一个CSV文件：

write.table(df, file = "output.csv")

注意事项

• 确保文件路径和名称正确无误。
• 根据文件格式选择合适的分隔符。

562数据编辑器

R提供了数据编辑器功能，允许用户直接编辑R中的数据对象。

使用数据编辑器

通过edit()函数可以指定编辑一个对象。例如，编辑名为my_data的数据对象：

my_data <- edit(my_data)

这将打开一个编辑器，允许用户直接修改数据对象的内容。

查看数据集的子集

• 使用head()函数可以查看数据集的前几项。例如，查看数据集my_data的前5项：

  head(my_data, 5)
  

• 使用tail()函数可以查看数据集的后几项。例如，查看数据集my_data的后5项：

  tail(my_data, 5)
  

保存修改后的数据

完成编辑后，可以使用fix()函数来保存修改后的数据。例如，保存对my_data的修改：

fix(my_data)

这将确认保存更改并关闭编辑器。

注意事项

• 数据编辑器适用于数据框、矩阵等R支持的数据类型。
• 确保在保存修改后重新加载数据对象，以应用更改。

第六章：绘图与数据可视化

6.1基本图形与绘图函数

611基础图形的创建

plot()函数是R中用于绘制基础图形的核心函数。

plot()函数的基本用法

plot()函数的基本格式如下：

plot(x, y, main, xlab, ylab, type = "参数")

• x：x轴的数值或数值向量。
• y：y轴的数值或数值向量。
• main：图形标题。
• xlab：x轴标题。
• ylab：y轴标题。
• type：图形类型，如“l”表示线图，“p”表示点图，“s”表示散点图等。

示例

• 绘制一条直线：

  x <- 1:10
  y <- 2 * x
  plot(x, y, main = "线性方程图", xlab = "X轴", ylab = "Y轴")
  

• 绘制散点图：

  x <- rnorm(100)
  y <- rnorm(100)
  plot(x, y, main = "散点图", xlab = "X轴", ylab = "Y轴")
  

注意事项

• type参数可以改变绘图类型，根据需要选择合适的参数值。
• 确保x和y的数据类型和长度匹配。

612新增绘图窗口和导出

新增绘图窗口

使用window()函数可以新增一个绘图窗口，这样在后续调用plot()函数时，新的图形将不会替代已有的图形。

window()

导出图形

R提供了多种函数来导出图形到不同格式的文件。常用的格式包括PNG、JPEG和TIFF。

• 使用png()函数保存图形为PNG格式：

  png("plot.png")
  x <- ...
  y <- ...
  plot(x, y)
  dev.off()
  

• 使用jpeg()函数保存图形为JPEG格式：

  jpeg("plot.jpg")
  x <- ...
  y <- ...
  plot(x, y)
  dev.off()
  

• 使用tiff()函数保存图形为TIFF格式：

  tiff("plot.tiff")
  x <- ...
  y <- ...
  plot(x, y)
  dev.off()
  

注意事项

• 确保在调用导出函数后，使用dev.off()关闭图形设备。
• 根据需要选择合适的文件格式。

6.2调整绘图参数

621自定义特征

R中的图形可以通过多种方式进行自定义，以满足特定的绘图需求。

使用plot()函数自定义特征

plot()函数提供了多种参数来定制图形特征。

• type：指定绘制点的类型，如“p”表示点图，“l”表示线图，“o”表示点线图等。
• lty：指定线条的类型，如1表示实线，2表示虚线，3表示点线等。
• pch：指定点的形状，如1表示圆形，2表示三角形，3表示正方形等。
• cex：指定点的大小。
• lwd：指定线条的宽度。

例如，绘制一个具有特定特征的散点图：

x <- rnorm(100)
y <- rnorm(100)
plot(x, y, pch = 19, cex = 2, lwd = 2, col = "blue")

使用par()函数保存设置

par()函数用于设置图形参数，但它不会立即生成图形。相反，它保存当前的设置，用于后续的所有绘图。

par(pch = 19, cex = 2, lwd = 2, col = "blue")
x <- rnorm(100)
y <- rnorm(100)
plot(x, y)

注意事项

• 确保在使用par()函数后，调用plot()函数来生成图形。
• par()设置会覆盖plot()函数中的相同设置。

622调整符号与线条

R中可以通过调整点符号和线条特征来创建更个性化的图形。

调整点符号

• pch参数用于指定点的形状。例如，pch = 1表示圆形，pch = 2表示三角形，等等。

  plot(x, y, pch = 19)  # 绘制一个具有特定形状的点
  

调整点的大小

• cex参数用于调整点的大小。例如，cex = 2表示将点的大小调整为默认大小的两倍。

  plot(x, y, pch = 19, cex = 2)  # 绘制一个更大的点
  

调整线条类型

• lty参数用于指定线条的类型。例如，lty = 1表示实线，lty = 2表示虚线，等等。

  plot(x, y, type = "l", lty = 2)  # 绘制一条虚线
  

调整线条宽度

• lwd参数用于调整线条的宽度。例如，lwd = 2表示将线条的宽度调整为默认宽度的两倍。

  plot(x, y, type = "l", lwd = 2)  # 绘制一条更粗的线条
  

注意事项

• 确保在使用这些参数时，图形中的其他元素（如坐标轴标签、标题等）也得到适当调整，以保持整体的一致性。

623调整颜色

R中可以通过多种方式来调整图形颜色，以增强图形的表现力和可读性。

调整坐标轴颜色

• col.axis：设置坐标轴字符的颜色。

  plot(x, y, col.axis = "blue")  # 将坐标轴字符颜色设置为蓝色
  

调整标题和标签颜色

• col.lab：设置x和y坐标标记的颜色。

• col.main：设置图形标题的颜色。

• col.sub：设置副标题的颜色。

  plot(x, y, col.lab = "red", col.main = "green", col.sub = "purple")
  

调整前景色和背景色

• fg：设置绘图的前景色。

• bg：设置绘图的背景色。

  plot(x, y, fg = "white", bg = "black")  # 将前景色设置为白色，背景色设置为黑色
  

使用colors()函数查看颜色名

• colors()函数可以列出R中可用的颜色名。

  colors()
  

使用palette()函数设置和查看调色板

• palette()函数用于设置和查看调色板。

• palette(rainbow(n))：从光谱色中均匀选取n种颜色组成向量。

• palette("default")：恢复默认调色板。

  palette()
  palette(rainbow(5))  # 创建一个包含5种颜色的调色板
  

绘制调色板

• 使用pie()函数可以绘制调色板，展示当前调色板中的颜色。

  pie(rep(1, length(palette())), labels = seq_along(palette()), col = palette())
  

注意事项

• 颜色可以使用颜色名称、RGB值或十六进制代码表示。
• 确保颜色设置与图形的其他元素（如线条、点符号等）协调一致。

624调整标签与标题文本

R中可以通过title()函数来调整图形中的标题和标签文本。

title()函数的基本用法

title()函数的基本格式如下：

title(main = "", sub = "", xlab = "", ylab = "", line = 1, col.main = NULL, col.sub = NULL, col.lab = NULL, font.main = NULL, font.sub = NULL, font.lab = NULL)

• main：主标题。
• sub：副标题。
• xlab：x轴标签。
• ylab：y轴标签。
• line：标题的行数，一般为1或2。
• col.main：主标题颜色。
• col.sub：副标题颜色。
• col.lab：标签颜色。
• font.main：主标题字体。
• font.sub：副标题字体。
• font.lab：标签字体。

示例

• 设置一个带副标题的主标题：

  title(main = "主标题", sub = "副标题", col.main = "blue", col.sub = "green")
  

• 设置x轴和y轴的标签：

  xlab("X轴标签")
  ylab("Y轴标签")
  

注意事项

• 确保标题和标签的设置与图形的其他元素（如颜色、线条等）协调一致。

6.3其他自定义元素

631坐标轴

R中的坐标轴可以通过多种方式进行调整，以满足特定的绘图需求。

屏蔽默认坐标轴

• 使用axes = FALSE参数在plot()函数中屏蔽默认的坐标轴。

  plot(x, y, axes = FALSE)
  

调整坐标轴参数

• axis()函数用于调整坐标轴的细节。

  axis(side, at = , labels = , pos = , lty = , col = )
  

  • side：坐标轴的位置，取值为1、2、3、4，分别表示下、左、上、右。
  • at：选择在坐标轴上显示的刻度标记位置。
  • labels：在刻度标记位置显示的标签。如果为 NULL，则使用 at 的值。
  • tick：一个逻辑值，表示是否绘制刻度线。
  • line：此参数可选择坐标轴的长度和位置。当值为负数时，坐标轴向内向图形区域移动。当值为正数时，坐标轴向外移动。
  • pos：坐标轴标签的位置。
  • outer：表示是否把坐标轴画到图像外面。
  • lty：刻度线的类型。
  • col：标签和刻度线的颜色。

示例

• 设置一个特定位置和颜色的坐标轴：

  axis(3, at = 1:5, labels = c("A", "B", "C", "D", "E"), col = "red", lty = 2)
  

• 在左侧坐标轴上绘制刻度线：

  axis(2, tick = TRUE)
  

注意事项

• 确保坐标轴的调整与图形的其他元素（如标题、标签、颜色等）协调一致。

632次要刻度线

在R中，可以通过安装和使用特定包来添加次要刻度线，以提高坐标轴的精确度和可读性。

安装必要的包

首先，需要安装Hmsic包来添加次要刻度线。

install.packages("Hmsic")
library(Hmsic)

使用minor.tick()添加次要刻度线

• minor.tick()函数用于在坐标轴上添加次要刻度线。

  minor.tick(nx = 5, ny = 5, tick.ratio = 0.5, tick.col = "gray")
  

  • nx：x轴次要刻度线的个数。
  • ny：y轴次要刻度线的个数。
  • tick.ratio：次要刻度线长度与主要刻度线长度的比率。
  • tick.col：次要刻度线的颜色。

示例

• 添加x轴和y轴的次要刻度线，设置颜色为灰色：

  minor.tick(nx = 5, ny = 5, tick.ratio = 0.5, tick.col = "gray")
  

注意事项

• 确保在添加次要刻度线之前，坐标轴已经被正确设置。
• 次要刻度线的数量、长度和颜色可以根据需要进行调整。

633网格线

abline()函数是R中用于绘制直线和网格线的常用函数。

abline()函数的基本用法

abline()函数的基本格式如下：

abline(a = 0, b = 1, h = NULL, v = NULL, coef = NULL, untf = FALSE, ...)

• a和b：直线的截距和斜率，它们指向y = a + bx。默认为y = x。其中，当斜率为0（即水平直线）时，a表示直线在y轴上的截距；当截距为0（即竖直直线）时，b表示无穷大的斜率。
• h：横向的直线的位置。它可以是一组坐标，表示要绘制的水平线的y值。例如，h = c(1, 2, 3)表示在y = 1, 2, 3三个位置画直线。
• v：纵向的直线的位置。它可以是一组坐标，表示要绘制的垂直线的x值。
• coef：一个包含两个元素的向量，表示截距和斜率。
• untf：逻辑变量。如果为TRUE，则x和y的向量将被视为未转换（即不设置坐标系）。

示例

• 添加x轴和y轴的网格线：

  abline(h = 1:3, v = 1:3)
  

• 使用coef参数添加一条斜率为2，截距为1的直线：

  abline(coef = c(1, 2))
  

注意事项

• 确保网格线的添加与图形的其他元素（如坐标轴、标题、标签等）协调一致。

634叠加绘图

叠加绘图是一种在同一图形窗口中绘制多个图层的方法，用于比较和展示不同数据集或同一数据集的不同视图。

绘制基础图形

首先，绘制一个基础图形。例如，绘制x和y的关系图：

x <- 1:20
y <- (1:20)^2
plot(x, y, type = "b")

这里，type = "b"表示绘制点图和线图。

叠加其他图形

接着，可以叠加其他图形。例如，添加蓝色的点图和红色的线图：

points(1:20, seq(1, 200, length.out = 20), col = "blue", pch = 17)
lines(1:20, seq(1, 200, length.out = 20), col = "red")

• points()函数用于在现有图形上绘制点图。
• lines()函数用于在现有图形上绘制线图。

示例结果

执行上述代码后，将会在同一图形窗口中看到一个基础的点线图，以及两个叠加的图形：蓝色点图和红色线图。

注意事项

• 确保在绘制每个图形时，坐标轴和图形的其他元素（如标题、标签等）已经正确设置。
• 叠加的图形应该有清晰的区分，如使用不同的颜色和线型。

 635图例

legend()函数是R中用于在图形中添加图例的函数。

legend()函数的基本用法

legend()函数的基本格式如下：

legend(x, y = NULL, legend, fill = NULL, col = par("col"), pch, title=NULL, ...)

• x和y：图例的位置。
• legend：图例中要显示的文本或符号。
• fill：图例中不同类别填充的颜色。
• col：图例中不同类别的颜色。
• pch：图例中不同类别的点形符号。
• title：图例的标题。

示例

• 添加一个自定义的图例：

  legend(x = 0.5, y = 385, legend = c("power", "linear"), 
         col = c("black", "blue"), pch = c(1, 17), 
         text.col = c("black", "red"), title = "My Legend")
  

  这个例子中，图例显示了两个类别（“power” 和 “linear”），每个类别用不同的颜色、点形符号和文本颜色表示。

注意事项

• 确保图例的位置和内容与图形的其他元素（如坐标轴、标题、标签等）协调一致。

636标注

barplot(height, names.arg, beside = FALSE, horiz = FALSE, col = NULL, border = "white", density = NULL, angle = 45, xlim = NULL, ylim = NULL, xlab = NULL, ylab = NULL, axes = TRUE, axisnames = TRUE, cex.names = 1, ...)

pie(x, labels = names(x), clockwise = FALSE, radius = 1, main = NULL, col = NULL, border = NULL, lty = NULL, lwd = NULL, init.angle = if(clockwise) 90 else 0, density = NULL, angle = 45, xlim = NULL, ylim = NULL, ...)

hist(x, breaks = "Sturges", freq = TRUE, probability = FALSE, main = NULL, xlab = NULL, ylab = NULL, xlim = NULL, ylim = NULL, ...)

xbar <- 9900
mu0 <- 10000
sigma <- 120
n <- 30
z <- (xbar - mu0) / (sigma / sqrt(n))
alpha <- 0.05
z.alpha <- qnorm(1 - alpha)
-z.alpha

xbar <- 2.1
mu0 <- 2
sigma <- 0.25
n <- 35
z <- (xbar - mu0) / (sigma / sqrt(n))
alpha <- 0.05
z.alpha <- qnorm(1 - alpha)
z.alpha

xbar <- 14.6
mu0 <- 15.4
sigma <- 2.5
n <- 35
z <- (xbar - mu0) / (sigma / sqrt(n))
alpha <- 0.05
z.half.alpha <- qnorm(1 - alpha / 2)
c(-z.half.alpha, z.half.alpha)