R 语言语法

1. R 语言

1. 什么是 R 语言

R 语言是用于统计分析，图形表示和报告的编程语言和软件环境。 R 语言由 Ross Ihaka 和 Robert Gentleman 在新西兰奥克兰大学创建，目前由 R 语言开发核心团队开发。 R 语言在 GNU 通用公共许可证下免费提供，并为各种操作系统（如 Linux，Windows 和 Mac）提供预编译的二进制版本。 这种编程语言被命名为 R 语言，基于两个 R 语言作者的名字的第一个字母（Robert Gentleman 和 Ross Ihaka），并且部分是贝尔实验室语言 S 的名称。

1.1 概述

R 语言是用于统计分析，图形表示和报告的编程语言和软件环境。 R 语言由 Ross Ihaka 和 Robert Gentleman 在新西兰奥克兰大学创建，目前由R语言开发核心团队开发。

R 语言的核心是解释计算机语言，其允许分支和循环以及使用函数的模块化编程。 R语言允许与以 C，C ++，.Net，Python 或 FORTRAN 语言编写的过程集成以提高效率。

R 语言在 GNU 通用公共许可证下免费提供，并为各种操作系统（如Linux，Windows和Mac）提供预编译的二进制版本。

R 是一个在 GNU 风格的副本左侧的自由软件，GNU 项目的官方部分叫做 GNU S.

1.2 R 的演变

R 语言最初是由新西兰奥克兰奥克兰大学统计系的 Ross Ihaka 和 Robert Gentleman 写的。 R 语言于 1993 年首次亮相。

• 一大群人通过发送代码和错误报告对 R 做出了贡献。
• 自 1997 年年中以来，已经有一个核心组（“R 核心团队”）可以修改 R 源代码归档。

1.3 R 的特点

如前所述，R 语言是用于统计分析，图形表示和报告的编程语言和软件环境。 以下是 R 语言的重要特点：

• R 语言是一种开发良好，简单有效的编程语言，包括条件，循环，用户定义的递归函数以及输入和输出设施。
• R 语言具有有效的数据处理和存储设施，
• R 语言提供了一套用于数组，列表，向量和矩阵计算的运算符。
• R 语言为数据分析提供了大型，一致和集成的工具集合。
• R 语言提供直接在计算机上或在纸张上打印的图形设施用于数据分析和显示。

作为结论，R 语言是世界上最广泛使用的统计编程语言。 它是数据科学家的第一选择，并由一个充满活力和有才华的贡献者社区支持。 R 语言在大学教授并部署在关键业务应用程序中。 本教程将教您 R 编程与适当的例子在简单和容易的步骤。

1.4 R语言 环境设置

• R语言 在线环境: 网上搜索
• 本地环境设置: 官网下载 https://www.r-project.org/

2. R语言 语法

2.1 R语言 基本语法

2.1.1 命令提示符

如果你已经配置好R语言环境，那么你只需要按一下的命令便可轻易开启命令提示符

$ R

这将启动 R 语言解释器，你会得到一个提示 > 在那里你可以开始输入你的程序，具体如下。

> myString <- "Hello, World!"
> print ( myString)
[1] "Hello, World!"

在这里，第一个语句先定义一个字符串变量 myString，并将 Hello，World! 赋值其中，第二句则使用 print() 语句将变量 myString 的内容进行打印。

2.1.2 脚本文件

通常，您将通过在脚本文件中编写程序来执行编程，然后在命令提示符下使用 R 解释器（称为 Rscript）来执行这些脚本。 所以让我们开始在一个命名为 test.R 的文本文件中编写下面的代码

# My first program in R Programming
myString <- "Hello, World!"

print ( myString)

将上述代码保存在 test.R 文件中，并在 Linux 命令提示符下执行，如下所示。 即使您使用的是 Windows 或其他系统，语法也将保持不变。

$ Rscript test.R

当我们运行上面的程序，它产生以下结果。

[1] "Hello, World!"

2.1.3 注释

注释能帮助您解释 R 语言程序中的脚本，它们在实际执行程序时会被解释器忽略。 单个注释使用 # 在语句的开头写入，如下所示:

# My first program in R Programming

R 语言不支持多行注释，但你可以使用一个小技巧，如下

if(FALSE) {
   "This is a demo for multi-line comments and it should be put inside either a single
      OR double quote"
}

myString <- "Hello, World!"
print ( myString)

虽然上面的注释将由R解释器执行，但它们不会干扰您的实际程序。 但是你必须为内容加上单引号或双引号。

2.2 R语言 数据类型

通常，在使用任何编程语言进行编程时，您需要使用各种变量来存储各种信息。 变量只是保留值的存储位置。 这意味着，当你创建一个变量，你必须在内存中保留一些空间来存储它们。

您可能想存储各种数据类型的信息，如字符，宽字符，整数，浮点，双浮点，布尔等。基于变量的数据类型，操作系统分配内存并决定什么可以存储在保留内存中。

与其他编程语言（如 C 中的 C 和 Java）相反，变量不会声明为某种数据类型。 变量分配有 R 对象，R 对象的数据类型变为变量的数据类型。尽管有很多类型的R对象，但经常使用的是：

• 矢量
• 列表
• 矩阵
• 数组
• 因子
• 数据帧

这些对象中最简单的是向量对象，并且这些原子向量有六种数据类型，也称为六类向量。 其他 R 对象建立在原子向量之上。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7jAgcfeh-1670571435893)(http://p8cg9782i.bkt.clouddn.com/R-datatype.png)]

在 R 编程中，非常基本的数据类型是称为向量的 R 对象，其保存如上所示的不同类的元素。 请注意，在 R 中，类的数量不仅限于上述六种类型。 例如，我们可以使用许多原子向量并创建一个数组，其类将成为数组。

2.2.1 Vectors 向量

当你想用多个元素创建向量时，你应该使用 c() 函数，这意味着将元素组合成一个向量。

# Create a vector.
apple <- c('red','green',"yellow")
print(apple)

# Get the class of the vector.
print(class(apple))

当我们执行上面的代码，它产生以下结果

[1] "red"    "green"  "yellow"
[1] "character"

2.2.2 Lists 列表

列表是一个 R 对象，它可以在其中包含许多不同类型的元素，如向量，函数甚至其中的另一个列表。

# Create a list.
list1 <- list(c(2,5,3),21.3,sin)

# Print the list.
print(list1)

当我们执行上面的代码，它产生以下结果

[[1]]
[1] 2 5 3

[[2]]
[1] 21.3

[[3]]
function (x)  .Primitive("sin")

2.2.3 Matrices 矩阵

矩阵是二维矩形数据集。 它可以使用矩阵函数的向量输入创建。

# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

当我们执行上面的代码，它产生以下结果

     [,1] [,2] [,3]
[1,] "a"  "a"  "b" 
[2,] "c"  "b"  "a"

2.2.4 Arrays 数组

虽然矩阵被限制为二维，但阵列可以具有任何数量的维度。 数组函数使用一个 dim 属性创建所需的维数。 在下面的例子中，我们创建了一个包含两个元素的数组，每个元素为 3x3 个矩阵。

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)
当我们执行上面的代码，它产生以下结果

, , 1

     [,1]     [,2]     [,3]    
[1,] "green"  "yellow" "green" 
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green" 

, , 2

     [,1]     [,2]     [,3]    
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green" 
[3,] "yellow" "green"  "yellow"  

2.2.5 Factors 因子

因子是使用向量创建的 r 对象。 它将向量与向量中元素的不同值一起存储为标签。 标签总是字符，不管它在输入向量中是数字还是字符或布尔等。 它们在统计建模中非常有用。

使用 factor() 函数创建因子。nlevels 函数给出级别计数。

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')

# Create a factor object.
factor_apple <- factor(apple_colors)

# Print the factor.
print(factor_apple)
print(nlevels(factor_apple))

当我们执行上面的代码，它产生以下结果

[1] green  green  yellow red    red    red    yellow green 
Levels: green red yellow
# applying the nlevels function we can know the number of distinct values
[1] 3

2.2.6 Data Frames 数据帧

数据帧是表格数据对象。 与数据帧中的矩阵不同，每列可以包含不同的数据模式。 第一列可以是数字，而第二列可以是字符，第三列可以是逻辑的。 它是等长度的向量的列表。

使用 data.frame() 函数创建数据帧。

# Create the data frame.
BMI <- 	data.frame(
   gender = c("Male", "Male","Female"), 
   height = c(152, 171.5, 165), 
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

当我们执行上面的代码，它产生以下结果

  gender height weight Age
1   Male  152.0     81  42
2   Male  171.5     93  38
3 Female  165.0     78  26  

2.3 R语言 变量

变量为我们提供了我们的程序可以操作的命名存储。 R语言中的变量可以存储原子向量，原子向量组或许多 Robject 的组合。 有效的变量名称由字母，数字和点或下划线字符组成。 变量名以字母或不以数字后跟的点开头。

变量名 | 合法性 | 原因
—|—
var_name2. | 有效 | 有字母，数字，点和下划线
VAR_NAME% | 无效 | 有字符’%'。只有点(.)和下划线允许的。
2var_name | 无效 | 以数字开头
.var_name, var.name | 有效 | 可以用一个点(.)，但启动点(.)，不应该后跟一个数字。
.2var_name | 无效 | 起始点后面是数字使其无效。
_var_name | 无效 | 开头_这是无效的

2.3.1 变量赋值

可以使用向左，向右和等于运算符来为变量分配值。 可以使用 print() 或 cat() 函数打印变量的值。 cat() 函数将多个项目组合成连续打印输出。

# Assignment using equal operator.
var.1 = c(0,1,2,3)           

# Assignment using leftward operator.
var.2 <- c("learn","R")   

# Assignment using rightward operator.   
c(TRUE,1) -> var.3           

print(var.1)
cat ("var.1 is ", var.1 ,"
")
cat ("var.2 is ", var.2 ,"
")
cat ("var.3 is ", var.3 ,"
")

当我们执行上面的代码，它产生以下结果

[1] 0 1 2 3
var.1 is  0 1 2 3 
var.2 is  learn R 
var.3 is  1 1 

注 - 向量 c（TRUE，1）具有逻辑和数值类的混合。 因此，逻辑类强制转换为数字类，使 TRUE 为 1。

2.3.2 变量的数据类型

在 R 语言中，变量本身没有声明任何数据类型，而是获取分配给它的 R - 对象的数据类型。 所以 R 称为动态类型语言，这意味着我们可以在程序中使用同一个变量时，一次又一次地更改变量的数据类型。

var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"
")

var_x <- 34.5
cat("  Now the class of var_x is ",class(var_x),"
")

var_x <- 27L
cat("   Next the class of var_x becomes ",class(var_x),"
")

当我们执行上面的代码，它产生以下结果:

The class of var_x is  character 
   Now the class of var_x is  numeric 
      Next the class of var_x becomes  integer

2.3.3 查找变量

要知道工作空间中当前可用的所有变量，我们使用 ls() 函数。 ls() 函数也可以使用模式来匹配变量名。

print(ls())

当我们执行上面的代码，它产生以下结果:

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname" 

注意 - 它是一个示例输出，取决于在您的环境中声明的变量。

ls() 函数可以使用模式来匹配变量名。

# List the variables starting with the pattern "var".
print(ls(pattern = "var"))   

当我们执行上面的代码，它产生以下结果

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"    

以点(.)开头的变量被隐藏，它们可以使用 ls() 函数的 all.names = TRUE 参数列出。

print(ls(all.name = TRUE))

当我们执行上面的代码，它产生以下结果:

[1] ".cars"        ".Random.seed" ".var_name"    ".varname"     ".varname2"   
[6] "my var"       "my_new_var"   "my_var"       "var.1"        "var.2"        
[11]"var.3"        "var.name"     "var_name2."   "var_x"  

2.3.4 删除变量

可以使用 rm() 函数删除变量。 下面我们删除变量 var.3。 打印时，抛出变量错误的值。

rm(var.3)
print(var.3)

当我们执行上面的代码，它产生以下结果

[1] "var.3"
Error in print(var.3) : object 'var.3' not found

所有的变量可以通过使用 rm() 和 ls() 函数一起删除。

rm(list = ls())
print(ls())

当我们执行上面的代码，它产生以下结果

character(0)

2.4 R语言 运算符

运算符是一个符号，通知编译器执行特定的数学或逻辑操作。 R语言 具有丰富的内置运算符，并提供以下类型的运算符。

2.4.1 运算符的类型

R语言 中拥有如下几种运算符类型：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

2.4.2 算术运算符

下表显示了 R语言 支持的算术运算符。 操作符对向量的每个元素起作用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPVDt71Q-1670571435894)(http://p8cg9782i.bkt.clouddn.com/R-operator-suanshu.png)]

2.4.3 关系运算符

下表显示了 R语言 支持的关系运算符。 将第一向量的每个元素与第二向量的相应元素进行比较。 比较的结果是布尔值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4E9U9euU-1670571435894)(http://p8cg9782i.bkt.clouddn.com/R-operator-guanxi.png)]

2.4.4 逻辑运算符

下表显示了 R语言 支持的逻辑运算符。 它只适用于逻辑，数字或复杂类型的向量。 所有大于 1 的数字被认为是逻辑值 TRUE。
将第一向量的每个元素与第二向量的相应元素进行比较。 比较的结果是布尔值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-111YObdM-1670571435894)(http://p8cg9782i.bkt.clouddn.com/R-operator-logical.png)]

逻辑运算符 && 和 || 只考虑向量的第一个元素，给出单个元素的向量作为输出。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MjGfwJ0K-1670571435894)(http://p8cg9782i.bkt.clouddn.com/R-operator-logical2.png)]

2.4.5 赋值运算符

这些运算符用于向向量赋值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xpPtegR2-1670571435895)(http://p8cg9782i.bkt.clouddn.com/R-operator-fuzhi.png)]

2.4.6 其他运算符

这些运算符用于特定目的，而不是一般的数学或逻辑计算。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D3P6OvaN-1670571435895)(http://p8cg9782i.bkt.clouddn.com/R-operator-qita.png)]

2.5 R语言 决策

决策结构要求程序员指定要由程序评估或测试的一个或多个条件，以及如果条件被确定为真则要执行的一个或多个语句，如果条件为假则执行其他语句。

以下是在大多数编程语言中的典型决策结构的一般形式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g1pAjkC6-1670571435895)(http://p8cg9782i.bkt.clouddn.com/R-decision-making.png)]

R 提供以下类型的决策语句。 单击以下链接以检查其详细信息。

Sr.No.	声明和描述
1	if 语句 --> if 语句由一个布尔表达式后跟一个或多个语句组成。
2	if ... else 语句 --> if 语句后面可以有一个可选的 else 语句，当布尔表达式为 false 时执行。
3	switch 语句 --> switch 语句允许根据值列表测试变量的相等性。

2.5.1 if 语句

if 语句由一个布尔表达式后跟一个或多个语句组成。

语法

在 R 中创建 if 语句的基本语法是

if(boolean_expression) {
   // statement(s) will execute if the boolean expression is true.
}

如果布尔表达式的计算结果为 true，那么 if 语句中的代码块将被执行。 如果布尔表达式的计算结果为 false，那么第一组代码在 if 语句结束之后（在结束大括号之后）将被执行。

x <- 30L
if(is.integer(x)) {
   print("X is an Integer")
}

当上面的代码被编译和执行时，它产生以下结果

[1] "X is an Integer"

2.5.2 if ... else 语句

if 语句后面可以是一个可选的 else 语句，当布尔表达式为 false 时执行。

语法

在 R 中创建 if ... else 语句的基本语法是

if(boolean_expression) {
   // statement(s) will execute if the boolean expression is true.
} else {
   // statement(s) will execute if the boolean expression is false.
}

如果布尔表达式的计算结果为真，则将执行 if 代码块，否则将执行代码块。

例

x <- c("what","is","truth")

if("Truth" %in% x) {
   print("Truth is found")
} else {
   print("Truth is not found")
}

当上面的代码被编译和执行时，它产生以下结果

[1] "Truth is not found"

这里 Truth 和 truth 是两个不同的字符串。

2.5.2.1 if ... else if ... else 语句

if 语句后面可以跟一个可选的 else if ... else 语句，这对于使用 single if ... else if 语句测试各种条件非常有用。

当使用 if，else if，else 语句有几点要记住。

• 如果可以有零或一个 else，它必须在任何其他 if 之后。
• 一个 if 可以有 0 到许多 else if 和它们必须在 else 之前。
• 一旦一个 else 如果成功，没有任何剩余的 else if 或 else 将被测试。

语法

在 R 中创建 if ... else if ... else 语句的基本语法是

if(boolean_expression 1) {
   // Executes when the boolean expression 1 is true.
} else if( boolean_expression 2) {
   // Executes when the boolean expression 2 is true.
} else if( boolean_expression 3) {
   // Executes when the boolean expression 3 is true.
} else {
   // executes when none of the above condition is true.
}

例

x <- c("what","is","truth")

if("Truth" %in% x) {
   print("Truth is found the first time")
} else if ("truth" %in% x) {
   print("truth is found the second time")
} else {
   print("No truth found")
}

当上面的代码被编译和执行时，它产生以下结果

[1] "truth is found the second time"

2.5.3 switch 语句

switch 语句允许根据值列表测试变量的相等性。 每个值都称为大小写，并且针对每种情况检查打开的变量。

语法

在 R 中创建 switch 语句的基本语法是

switch(expression, case1, case2, case3....)

以下规则适用于 switch 语句：

• 如果 expression 的值不是字符串，那么它被强制为整数。
• 在交换机中可以有任意数量的 case 语句。 每个案例后面都跟要比较的值和冒号。
• 如果整数的值在 1 和 nargs() - 1（参数的最大数目）之间，则对 case 条件的相应元素求值并返回结果。
• 如果表达式求值为字符串，那么该字符串与元素的名称匹配。
• 如果有多个匹配，则返回第一个匹配元素。
• 无默认参数可用。
• 在没有匹配的情况下，如果有一个未命名的元素…它的值被返回。 （如果有多个这样的参数，则返回错误。）

例

x <- switch(
   3,
   "first",
   "second",
   "third",
   "fourth"
)
print(x)

当上面的代码被编译和执行时，它产生以下结果

[1] "third"

2.6 R语言 包

R语言 的包是 R 函数，编译代码和样本数据的集合。 它们存储在 R语言 环境中名为 library 的目录下。 默认情况下，R语言 在安装期间安装一组软件包。 随后添加更多包，当它们用于某些特定目的时。 当我们启动 R语言 控制台时，默认情况下只有默认包可用。 已经安装的其他软件包必须显式加载以供将要使用它们的 R语言 程序使用。

所有可用的 R语言 包都列在R语言的包。
下面是用于检查，验证和使用R包的命令列表。

2.6.1 检查可用 R语言 的包

2.6.1.1 获取包含 R 包的库位置

.libPaths()

当我们执行上面的代码，它产生以下结果。 它可能会根据您的电脑的本地设置而有所不同。

[2] "C:/Program Files/R/R-3.2.2/library"

2.6.1.2 获取已安装的所有软件包列表

library()

当我们执行上面的代码，它产生以下结果。 它可能会根据您的电脑的本地设置而有所不同。

Packages in library ‘C:/Program Files/R/R-3.2.2/library’:

base                    The R Base Package
boot                    Bootstrap Functions (Originally by Angelo Canty
                        for S)
class                   Functions for Classification
cluster                 "Finding Groups in Data": Cluster Analysis
                        Extended Rousseeuw et al.
codetools               Code Analysis Tools for R
compiler                The R Compiler Package

获取当前在 R 环境中加载的所有包

search()

当我们执行上述代码时，它产生了以下结果。它会根据你的个人电脑的本地设置而异。

[1] ".GlobalEnv"        "package:stats"     "package:graphics" 
[4] "package:grDevices" "package:utils"     "package:datasets" 
[7] "package:methods"   "Autoloads"         "package:base" 

2.6.1.3 安装一个新的软件包

有两种方法来添加新的 R 包。 一个是直接从 CRAN 目录安装，另一个是将软件包下载到本地系统并手动安装它。

直接从 CRAN 安装

以下命令直接从 CRAN 网页获取软件包，并将软件包安装在 R 环境中。 可能会提示您选择最近的镜像。 根据您的位置选择一个。

 install.packages("Package Name")
 
# Install the package named "XML".
 install.packages("XML")

手动安装包

转到链接 R Packages 下载所需的包。 将包作为 .zip 文件保存在本地系统中的适当位置。

现在您可以运行以下命令在 R 环境中安装此软件包。

install.packages(file_name_with_path, repos = NULL, type = "source")

# Install the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

2.6.1.4 装载包到库中

在包可以在代码中使用之前，必须将其加载到当前 R 环境中。 您还需要加载先前已安装但在当前环境中不可用的软件包。

使用以下命令加载包：

library("package Name", lib.loc = "path to library")

# Load the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

2.7 R语言 循环

可能有一种情况，当你需要执行一段代码几次。 通常，顺序执行语句。 首先执行函数中的第一个语句，然后执行第二个语句，依此类推。

编程语言提供允许更复杂的执行路径的各种控制结构。

循环语句允许我们多次执行一个语句或一组语句，以下是大多数编程语言中循环语句的一般形式

R 编程语言提供以下种类的循环来处理循环需求。

2.7.1 循环语句

Sr.No.	循环类型和描述
1	repeat 循环 --> 多次执行一系列语句，并简化管理循环变量的代码。
2	while 循环 --> 在给定条件为真时，重复语句或语句组。 它在执行循环体之前测试条件。
3	for 循环 --> 像 while 语句，不同之处在于它测试在循环体的端部的条件。

2.7.1.1 repeat 循环

Repeat 循环重复执行相同的代码，直到满足停止条件。

语法

在 R 中创建 Repeat 循环的基本语法是

repeat { 
   commands 
   if(condition) {
      break
   }
}

例

v <- c("Hello","loop")
cnt <- 2

repeat {
   print(v)
   cnt <- cnt+1
   
   if(cnt > 5) {
      break
   }
}

当上面的代码被编译和执行时，它产生以下结果

[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 

2.7.1.2 while 循环

While 循环一次又一次地执行相同的代码，直到满足停止条件。

语法

在 R 中创建 while 循环的基本语法是

while (test_expression) {
   statement
}

while 循环的关键点是循环可能永远不会运行。 当条件被测试并且结果为 false 时，循环体将被跳过，while 循环之后的第一条语句将被执行。

例

v <- c("Hello","while loop")
cnt <- 2

while (cnt < 7) {
   print(v)
   cnt = cnt + 1
}

当上面的代码被编译和执行时，它产生以下结果

[1] "Hello"  "while loop"
[1] "Hello"  "while loop"
[1] "Hello"  "while loop"
[1] "Hello"  "while loop"
[1] "Hello"  "while loop"

2.7.1.3 for 循环

For 循环是一种重复控制结构，允许您有效地编写需要执行特定次数的循环。

语法

在 R 中创建一个 for 循环语句的基本语法是

for (test_expression) {
   statement
}

R 的 for 循环是特别灵活的，因为它们不限于整数，或者输入中的偶数。 我们可以传递字符向量，逻辑向量，列表或表达式。

例

v <- LETTERS[1:4]
for ( i in v) {
   print(i)
}

当上面的代码被编译和执行时，它产生以下结果

[1] "A"
[1] "B"
[1] "C"
[1] "D"

2.7.2 循环控制语句

循环控制语句从其正常序列改变执行。 当执行离开作用域时，在该作用域中创建的所有自动对象都将被销毁。

R语言 支持以下控制语句。

Sr.No.	控制语句和描述
1	break 语句 --> 终止循环语句，并将执行转移到循环后立即执行的语句。
2	next 语句 --> next 语句模拟 R语言 switch 语句的行为。

2.7.2.1 break 语句

R语言 中的 break 语句有以下两种用法：

• 当在循环中遇到 break 语句时，循环立即终止，并且程序控制在循环之后的下一语句处恢复。
• 它可以用于终止 switch 语句中的情况（在下一章中讨论）。

语法

在 R 中创建 break 语句的基本语法是

break

例

v <- c("Hello","loop")
cnt <- 2

repeat {
   print(v)
   cnt <- cnt + 1
	
   if(cnt > 5) {
      break
   }
}

当上面的代码被编译和执行时，它产生以下结果

[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop"

2.7.2.2 next 语句

R语言 存在 next 语句，当我们想跳过循环的当前迭代而不终止它时便可使用 next。 遇到 next 时，R 解析器跳过本次迭代，并开始循环的下一次迭代。

语法

在 R 中创建 Next 语句的基本语法是

next

例

v <- LETTERS[1:6]
for ( i in v) {
   
   if (i == "D") {
      next
   }
   print(i)
}

当上面的代码被编译和执行时，它产生以下结果

[1] "A"
[1] "B"
[1] "C"
[1] "E"
[1] "F"

2.8 R语言 数据重塑

R语言 中的数据重塑是关于改变数据被组织成行和列的方式。 大多数时间 R语言 中的数据处理是通过将输入数据作为数据帧来完成的。 很容易从数据帧的行和列中提取数据，但是在某些情况下，我们需要的数据帧格式与我们接收数据帧的格式不同。 R语言 具有许多功能，在数据帧中拆分，合并和将行更改为列，反之亦然。

2.8.1 于数据帧中加入列和行

我们可以使用 cbind() 函数连接多个向量来创建数据帧。 此外，我们可以使用 rbind() 函数合并两个数据帧。

# Create vector objects.
city <- c("Tampa","Seattle","Hartford","Denver")
state <- c("FL","WA","CT","CO")
zipcode <- c(33602,98104,06161,80294)

# Combine above three vectors into one data frame.
addresses <- cbind(city,state,zipcode)

# Print a header.
cat("# # # # The First data frame
") 

# Print the data frame.
print(addresses)

# Create another data frame with similar columns
new.address <- data.frame(
   city = c("Lowry","Charlotte"),
   state = c("CO","FL"),
   zipcode = c("80230","33949"),
   stringsAsFactors = FALSE
)

# Print a header.
cat("# # # The Second data frame
") 

# Print the data frame.
print(new.address)

# Combine rows form both the data frames.
all.addresses <- rbind(addresses,new.address)

# Print a header.
cat("# # # The combined data frame
") 

# Print the result.
print(all.addresses)

当我们执行上面的代码，它产生以下结果

# # # # The First data frame
     city       state zipcode
[1,] "Tampa"    "FL"  "33602"
[2,] "Seattle"  "WA"  "98104"
[3,] "Hartford" "CT"   "6161" 
[4,] "Denver"   "CO"  "80294"

# # # The Second data frame
       city       state   zipcode
1      Lowry      CO      80230
2      Charlotte  FL      33949

# # # The combined data frame
       city      state zipcode
1      Tampa     FL    33602
2      Seattle   WA    98104
3      Hartford  CT     6161
4      Denver    CO    80294
5      Lowry     CO    80230
6     Charlotte  FL    33949

2.8.2 合并数据帧

我们可以使用 merge() 函数合并两个数据帧。 数据帧必须具有相同的列名称，在其上进行合并。

在下面的例子中，我们考虑图书馆名称 MASS 中有关 Pima Indian Women 的糖尿病的数据集。 我们基于血压(bp)和体重指数(bmi)的值合并两个数据集。 在选择这两列用于合并时，其中这两个变量的值在两个数据集中匹配的记录被组合在一起以形成单个数据帧。

library(MASS)
merged.Pima <- merge(x = Pima.te, y = Pima.tr,
   by.x = c("bp", "bmi"),
   by.y = c("bp", "bmi")
)
print(merged.Pima)
nrow(merged.Pima)

当我们执行上面的代码，它产生以下结果

   bp  bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y
1  60 33.8       1   117     23 0.466    27     No       2   125     20 0.088
2  64 29.7       2    75     24 0.370    33     No       2   100     23 0.368
3  64 31.2       5   189     33 0.583    29    Yes       3   158     13 0.295
4  64 33.2       4   117     27 0.230    24     No       1    96     27 0.289
5  66 38.1       3   115     39 0.150    28     No       1   114     36 0.289
6  68 38.5       2   100     25 0.324    26     No       7   129     49 0.439
7  70 27.4       1   116     28 0.204    21     No       0   124     20 0.254
8  70 33.1       4    91     32 0.446    22     No       9   123     44 0.374
9  70 35.4       9   124     33 0.282    34     No       6   134     23 0.542
10 72 25.6       1   157     21 0.123    24     No       4    99     17 0.294
11 72 37.7       5    95     33 0.370    27     No       6   103     32 0.324
12 74 25.9       9   134     33 0.460    81     No       8   126     38 0.162
13 74 25.9       1    95     21 0.673    36     No       8   126     38 0.162
14 78 27.6       5    88     30 0.258    37     No       6   125     31 0.565
15 78 27.6      10   122     31 0.512    45     No       6   125     31 0.565
16 78 39.4       2   112     50 0.175    24     No       4   112     40 0.236
17 88 34.5       1   117     24 0.403    40    Yes       4   127     11 0.598
   age.y type.y
1     31     No
2     21     No
3     24     No
4     21     No
5     21     No
6     43    Yes
7     36    Yes
8     40     No
9     29    Yes
10    28     No
11    55     No
12    39     No
13    39     No
14    49    Yes
15    49    Yes
16    38     No
17    28     No
[1] 17

2.8.3 melt() 拆分数据和 cast() 数据重构

R语言 编程的一个最有趣的方面是关于在多个步骤中改变数据的形状以获得期望的形状。 用于执行此操作的函数称为 melt() 和 cast()。

我们考虑称为船舶的数据集称为 MASS。

library(MASS)
print(ships)

当我们执行上面的代码，它产生以下结果

     type year   period   service   incidents
1     A   60     60        127         0
2     A   60     75         63         0
3     A   65     60       1095         3
4     A   65     75       1095         4
5     A   70     60       1512         6
.............
.............
8     A   75     75       2244         11
9     B   60     60      44882         39
10    B   60     75      17176         29
11    B   65     60      28609         58
............
............
17    C   60     60      1179          1
18    C   60     75       552          1
19    C   65     60       781          0
............
............

2.8.4 melt() 拆分数据

现在我们拆分数据进行重组，将除类型和年份以外的所有列转换为多行展示。

molten.ships <- melt(ships, id = c("type","year"))
print(molten.ships)

当我们执行上面的代码，它产生以下结果

      type year  variable  value
1      A   60    period      60
2      A   60    period      75
3      A   65    period      60
4      A   65    period      75
............
............
9      B   60    period      60
10     B   60    period      75
11     B   65    period      60
12     B   65    period      75
13     B   70    period      60
...........
...........
41     A   60    service    127
42     A   60    service     63
43     A   65    service   1095
...........
...........
70     D   70    service   1208
71     D   75    service      0
72     D   75    service   2051
73     E   60    service     45
74     E   60    service      0
75     E   65    service    789
...........
...........
101    C   70    incidents    6
102    C   70    incidents    2
103    C   75    incidents    0
104    C   75    incidents    1
105    D   60    incidents    0
106    D   60    incidents    0
...........
...........

2.8.5 cast() 重构数据

我们可以将被拆分的数据转换为一种新形式，使用 cast() 函数创建每年每种类型的船的总和。

recasted.ship <- cast(molten.ships, type+year~variable,sum)
print(recasted.ship)

当我们执行上面的代码，它产生以下结果

     type year  period  service  incidents
1     A   60    135       190      0
2     A   65    135      2190      7
3     A   70    135      4865     24
4     A   75    135      2244     11
5     B   60    135     62058     68
6     B   65    135     48979    111
7     B   70    135     20163     56
8     B   75    135      7117     18
9     C   60    135      1731      2
10    C   65    135      1457      1
11    C   70    135      2731      8
12    C   75    135       274      1
13    D   60    135       356      0
14    D   65    135       480      0
15    D   70    135      1557     13
16    D   75    135      2051      4
17    E   60    135        45      0
18    E   65    135      1226     14
19    E   70    135      3318     17
20    E   75    135       542      1

2.9 R语言 函数

函数是一组组合在一起以执行特定任务的语句。 R语言 具有大量内置函数，用户可以创建自己的函数。

在 R语言 中，函数是一个对象，因此 R语言 解释器能够将控制传递给函数，以及函数完成动作所需的参数。

该函数依次执行其任务并将控制返回到解释器以及可以存储在其他对象中的任何结果。

2.9.1 函数定义

使用关键字函数创建 R语言 的函数。 R语言 的函数定义的基本语法如下

function_name <- function(arg_1, arg_2, ...) {
   Function body 
}

2.9.2 函数组件

函数的不同部分

• 函数名称: 这是函数的实际名称。 它作为具有此名称的对象存储在 R 环境中。
• 参数: 参数是一个占位符。 当函数被调用时，你传递一个值到参数。 参数是可选的; 也就是说，一个函数可能不包含参数。 参数也可以有默认值。
• 函数体: 函数体包含定义函数的功能的语句集合。
• 返回值: 函数的返回值是要评估的函数体中的最后一个表达式。

R语言 有许多内置函数，可以在程序中直接调用而无需先定义它们。我们还可以创建和使用我们自己的函数，称为用户定义的函数。

2.9.3 内置功能

内置函数的简单示例是 seq()，mean()，max()，sum(x) 和 paste(...) 等。它们由用户编写的程序直接调用。 您可以参考最广泛使用的 R 函数。

# Create a sequence of numbers from 32 to 44.
print(seq(32,44))

# Find mean of numbers from 25 to 82.
print(mean(25:82))

# Find sum of numbers frm 41 to 68.
print(sum(41:68))

当我们执行上面的代码，它产生以下结果

[1] 32 33 34 35 36 37 38 39 40 41 42 43 44
[1] 53.5
[1] 1526

2.9.4 用户定义的函数

我们可以在 R语言 中创建用户定义的函数。它们特定于用户想要的，一旦创建，它们就可以像内置函数一样使用。 下面是一个创建和使用函数的例子。

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}	

2.9.5 调用函数

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

# Call the function new.function supplying 6 as an argument.
new.function(6)

当我们执行上面的代码，它产生以下结果

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36

2.9.5.1 调用没有参数的函数

# Create a function without an argument.
new.function <- function() {
   for(i in 1:5) {
      print(i^2)
   }
}	

# Call the function without supplying an argument.
new.function()

当我们执行上面的代码，它产生以下结果

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25

2.9.5.2 使用参数值调用函数（按位置和名称）

函数调用的参数可以按照函数中定义的顺序提供，也可以以不同的顺序提供，但分配给参数的名称。

# Create a function with arguments.
new.function <- function(a,b,c) {
   result <- a * b + c
   print(result)
}

# Call the function by position of arguments.
new.function(5,3,11)

# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)

当我们执行上面的代码，它产生以下结果

[1] 26
[1] 58

2.9.5.3 使用默认参数调用函数

我们可以在函数定义中定义参数的值，并调用函数而不提供任何参数以获取默认结果。 但是我们也可以通过提供参数的新值来获得非默认结果来调用这样的函数。

# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
   result <- a * b
   print(result)
}

# Call the function without giving any argument.
new.function()

# Call the function with giving new values of the argument.
new.function(9,5)

当我们执行上面的代码，它产生以下结果

[1] 18
[1] 45

2.9.5.4 功能的延迟计算

对函数的参数进行延迟评估，这意味着它们只有在函数体需要时才进行评估。

# Create a function with arguments.
new.function <- function(a, b) {
   print(a^2)
   print(a)
   print(b)
}

# Evaluate the function without supplying one of the arguments.
new.function(6)

当我们执行上面的代码，它产生以下结果

[1] 36
[1] 6
Error in print(b) : argument "b" is missing, with no default

2.10 R语言 字符串

在 R语言 中的单引号或双引号对中写入的任何值都被视为字符串。 R语言 存储的每个字符串都在双引号内，即使是使用单引号创建的依旧如此。

2.10.1 在字符串构造中应用的规则

• 在字符串的开头和结尾的引号应该是两个双引号或两个单引号。它们不能被混合。
• 双引号可以插入到以单引号开头和结尾的字符串中。
• 单引号可以插入以双引号开头和结尾的字符串。
• 双引号不能插入以双引号开头和结尾的字符串。
• 单引号不能插入以单引号开头和结尾的字符串。

2.10.1.1 有效字符串的示例

以下示例阐明了在 R语言 中创建字符串的规则。

a <- 'Start and end with single quote'
print(a)

b <- "Start and end with double quotes"
print(b)

c <- "single quote ' in between double quotes"
print(c)

d <- 'Double quotes " in between single quote'
print(d)

当运行上面的代码，我们得到以下输出

[1] "Start and end with single quote"
[1] "Start and end with double quotes"
[1] "single quote ' in between double quote"
[1] "Double quote " in between single quote"

2.10.1.2 无效字符串的示例

e <- 'Mixed quotes" 
print(e)

f <- 'Single quote ' inside single quote'
print(f)

g <- "Double quotes " inside double quotes"
print(g)

当我们运行脚本失败给下面的结果。

...: unexpected INCOMPLETE_STRING

.... unexpected symbol 
1: f <- 'Single quote ' inside

unexpected symbol
1: g <- "Double quotes " inside

2.10.2 字符串操作

2.10.2.1 连接字符串 - paste() 函数

R语言 中的许多字符串使用 paste() 函数组合。 它可以采取任何数量的参数组合在一起。

语法

对于粘贴功能的基本语法是

paste(..., sep = " ", collapse = NULL)

以下是所使用的参数的说明:

• ...表示要组合的任意数量的自变量。
• sep 表示参数之间的任何分隔符。它是可选的。
• collapse 用于消除两个字符串之间的空格。 但不是一个字符串的两个字内的空间。

例

a <- "Hello"
b <- 'How'
c <- "are you? "

print(paste(a,b,c))

print(paste(a,b,c, sep = "-"))

print(paste(a,b,c, sep = "", collapse = ""))

当我们执行上面的代码，它产生以下结果

[1] "Hello How are you? "
[1] "Hello-How-are you? "
[1] "HelloHoware you? "

2.10.2.2 格式化数字和字符串 - format() 函数

可以使用 format() 函数将数字和字符串格式化为特定样式。

语法

格式化函数的基本语法是

format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none")) 

以下是所使用的参数的描述

• x 是向量输入。
• digits 是显示的总位数。
• nsmall 是小数点右边的最小位数。
• 科学设置为 TRUE 以显示科学记数法。
• width 指示通过在开始处填充空白来显示的最小宽度。
• justify 是字符串向左，右或中心的显示。

例

# Total number of digits displayed. Last digit rounded off.
result <- format(23.123456789, digits = 9)
print(result)

# Display numbers in scientific notation.
result <- format(c(6, 13.14521), scientific = TRUE)
print(result)

# The minimum number of digits to the right of the decimal point.
result <- format(23.47, nsmall = 5)
print(result)

# Format treats everything as a string.
result <- format(6)
print(result)

# Numbers are padded with blank in the beginning for width.
result <- format(13.7, width = 6)
print(result)

# Left justify strings.
result <- format("Hello", width = 8, justify = "l")
print(result)

# Justfy string with center.
result <- format("Hello", width = 8, justify = "c")
print(result)

当我们执行上面的代码，它产生以下结果

[1] "23.1234568"
[1] "6.000000e+00" "1.314521e+01"
[1] "23.47000"
[1] "6"
[1] "  13.7"
[1] "Hello   "
[1] " Hello  "

2.10.2.3 计算字符串中的字符数 - nchar() 函数

此函数计算字符串中包含空格的字符数。

语法

nchar() 函数的基本语法是

nchar(x)

以下是所使用的参数的描述:

• x是向量输入。

例

result <- nchar("Count the number of characters")
print(result)

当我们执行上面的代码，它产生以下结果

[1] 30

2.10.2.4 更改 case - toupper() 和 tolower() 函数

这些函数改变字符串的字符的大小写。

语法

toupper() 和 tolower() 函数的基本语法是

toupper(x)
tolower(x)

以下是所使用的参数的描述

• x 是向量输入。

例

# Changing to Upper case.
result <- toupper("Changing To Upper")
print(result)

# Changing to lower case.
result <- tolower("Changing To Lower")
print(result)

当我们执行上面的代码，它产生以下结果

[1] "CHANGING TO UPPER"
[1] "changing to lower"

2.10.2.5 提取字符串的一部分 - substring() 函数

此函数提取字符串的部分。

语法

substring() 函数的基本语法是

substring(x,first,last)

以下是所使用的参数的描述:

• x 是字符向量输入。
• 首先是要提取的第一个字符的位置。
• last 是要提取的最后一个字符的位置。

例

# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)

当我们执行上面的代码，它产生以下结果

[1] "act"

2.11 R语言 向量

向量是最基本的 R 语言数据对象，有六种类型的原子向量。 它们是逻辑，整数，双精度，复杂，字符和原始。

2.11.1 创建向量

2.11.1.1 单元素向量

即使在 R语言 中只写入一个值，它也将成为长度为 1 的向量，并且属于上述向量类型之一。

# Atomic vector of type character.
print("abc");

# Atomic vector of type double.
print(12.5)

# Atomic vector of type integer.
print(63L)

# Atomic vector of type logical.
print(TRUE)

# Atomic vector of type complex.
print(2+3i)

# Atomic vector of type raw.
print(charToRaw('hello'))

当我们执行上面的代码，它产生以下结果

[1] "abc"
[1] 12.5
[1] 63
[1] TRUE
[1] 2+3i
[1] 68 65 6c 6c 6f

2.11.1.2 多元素向量

对数值数据使用冒号运算符

# Creating a sequence from 5 to 13.
v <- 5:13
print(v)

# Creating a sequence from 6.6 to 12.6.
v <- 6.6:12.6
print(v)

# If the final element specified does not belong to the sequence then it is discarded.
v <- 3.8:11.4
print(v)

当我们执行上面的代码，它产生以下结果

[1]  5  6  7  8  9 10 11 12 13
[1]  6.6  7.6  8.6  9.6 10.6 11.6 12.6
[1]  3.8  4.8  5.8  6.8  7.8  8.8  9.8 10.8

2.11.1.3 使用 sequence (Seq.) 序列运算符

# Create vector with elements from 5 to 9 incrementing by 0.4.
print(seq(5, 9, by = 0.4))

当我们执行上面的代码，它产生以下结果

[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0

2.11.1.4 使用 C() 函数

如果其中一个元素是字符，则非字符值被强制转换为字符类型。

# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)

当我们执行上面的代码，它产生以下结果

[1] "apple" "red"   "5"     "TRUE" 

2.11.2 访问向量元素

使用索引访问向量的元素。 [] 括号用于建立索引。 索引从位置 1 开始。在索引中给出负值会丢弃来自 result.TRUE，FALSE 或 0 和 1 的元素，也可用于索引。

# Accessing vector elements using position.
t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)

# Accessing vector elements using logical indexing.
v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)

# Accessing vector elements using negative indexing.
x <- t[c(-2,-5)]
print(x)

# Accessing vector elements using 0/1 indexing.
y <- t[c(0,0,0,0,0,0,1)]
print(y)

当我们执行上面的代码，它产生以下结果

[1] "Mon" "Tue" "Fri"
[1] "Sun" "Fri"
[1] "Sun" "Tue" "Wed" "Fri" "Sat"
[1] "Sun"

2.11.3 向量操作

2.11.3.1 向量运算

可以添加，减去，相乘或相除两个相同长度的向量，将结果作为向量输出。

# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)

# Vector addition.
add.result <- v1+v2
print(add.result)

# Vector substraction.
sub.result <- v1-v2
print(sub.result)

# Vector multiplication.
multi.result <- v1*v2
print(multi.result)

# Vector division.
divi.result <- v1/v2
print(divi.result)

当我们执行上面的代码，它产生以下结果

[1]  7 19  4 13  1 13
[1] -1 -3  4 -3 -1  9
[1] 12 88  0 40  0 22
[1] 0.7500000 0.7272727       Inf 0.6250000 0.0000000 5.5000000

2.11.3.2 向量元素回收

如果我们对不等长的两个向量应用算术运算，则较短向量的元素被循环以完成操作。

v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)

add.result <- v1+v2
print(add.result)

sub.result <- v1-v2
print(sub.result)

当我们执行上面的代码，它产生以下结果

[1]  7 19  8 16  4 22
[1] -1 -3  0 -6 -4  0

2.11.3.3 向量元素排序

向量中的元素可以使用 sort() 函数排序。

v <- c(3,8,4,5,0,11, -9, 304)

# Sort the elements of the vector.
sort.result <- sort(v)
print(sort.result)

# Sort the elements in the reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

# Sorting character vectors.
v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)

# Sorting character vectors in reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

当我们执行上面的代码，它产生以下结果

[1]  -9   0   3   4   5   8  11 304
[1] 304  11   8   5   4   3   0  -9
[1] "Blue"   "Red"    "violet" "yellow"
[1] "yellow" "violet" "Red"    "Blue" 

2.12 R语言 列表

列表是 R语言 对象，它包含不同类型的元素，如数字，字符串，向量和其中的另一个列表。 列表还可以包含矩阵或函数作为其元素。 列表是使用 list() 函数创建的。

2.12.1 创建列表

以下是创建包含字符串，数字，向量和逻辑值的列表的示例

# Create a list containing strings, numbers, vectors and a logical values.
list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
print(list_data)

当我们执行上面的代码，它产生以下结果

[[1]]
[1] "Red"

[[2]]
[1] "Green"

[[3]]
[1] 21 32 11

[[4]]
[1] TRUE

[[5]]
[1] 51.23

[[6]]
[1] 119.1

2.12.2 命名列表元素

列表元素可以给出名称，并且可以使用这些名称访问它们。

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Show the list.
print(list_data)

当我们执行上面的代码，它产生以下结果

$`1st_Quarter`
[1] "Jan" "Feb" "Mar"

$A_Matrix
     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

$A_Inner_list
$A_Inner_list[[1]]
[1] "green"

$A_Inner_list[[2]]
[1] 12.3

2.12.3 访问列表元素

列表的元素可以通过列表中元素的索引访问。 在命名列表的情况下，它也可以使用名称来访问。

我们继续使用在上面的例子列表

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Access the first element of the list.
print(list_data[1])

# Access the thrid element. As it is also a list, all its elements will be printed.
print(list_data[3])

# Access the list element using the name of the element.
print(list_data$A_Matrix)

当我们执行上面的代码，它产生以下结果

$`1st_Quarter`
[1] "Jan" "Feb" "Mar"

$A_Inner_list
$A_Inner_list[[1]]
[1] "green"

$A_Inner_list[[2]]
[1] 12.3

     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

2.12.4 操控列表元素

我们可以添加，删除和更新列表元素，如下所示。 我们只能在列表的末尾添加和删除元素。 但我们可以更新任何元素。

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Add element at the end of the list.
list_data[4] <- "New element"
print(list_data[4])

# Remove the last element.
list_data[4] <- NULL

# Print the 4th Element.
print(list_data[4])

# Update the 3rd Element.
list_data[3] <- "updated element"
print(list_data[3])

当我们执行上面的代码，它产生以下结果

[[1]]
[1] "New element"

$
NULL

$`A Inner list`
[1] "updated element"

2.12.5 合并列表

通过将所有列表放在一个 list() 函数中，您可以将许多列表合并到一个列表中。

# Create two lists.
list1 <- list(1,2,3)
list2 <- list("Sun","Mon","Tue")

# Merge the two lists.
merged.list <- c(list1,list2)

# Print the merged list.
print(merged.list)

当我们执行上面的代码，它产生以下结果

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] "Sun"

[[5]]
[1] "Mon"

[[6]]
[1] "Tue"

2.12.6 将列表转换为向量

列表可以转换为向量，使得向量的元素可以用于进一步的操作。 可以在将列表转换为向量之后应用对向量的所有算术运算。 要做这个转换，我们使用 unlist() 函数。 它将列表作为输入并生成向量。

# Create lists.
list1 <- list(1:5)
print(list1)

list2 <-list(10:14)
print(list2)

# Convert the lists to vectors.
v1 <- unlist(list1)
v2 <- unlist(list2)

print(v1)
print(v2)

# Now add the vectors
result <- v1+v2
print(result)

当我们执行上面的代码，它产生以下结果

[[1]]
[1] 1 2 3 4 5

[[1]]
[1] 10 11 12 13 14

[1] 1 2 3 4 5
[1] 10 11 12 13 14
[1] 11 13 15 17 19

2.13 R语言 矩阵

矩阵是其中元素以二维矩形布局布置的R对象。 它们包含相同原子类型的元素。 虽然我们可以创建一个只包含字符或只包含逻辑值的矩阵，但它们没有太多用处。 我们使用包含数字元素的矩阵用于数学计算。

使用 matrix() 函数创建一个矩阵。

2.13.1 语法

在 R语言 中创建矩阵的基本语法是

matrix(data, nrow, ncol, byrow, dimnames)

以下是所使用的参数的说明

• 数据是成为矩阵的数据元素的输入向量。
• nrow 是要创建的行数。
• ncol 是要创建的列数。
• byrow 是一个逻辑线索。 如果为 TRUE，则输入向量元素按行排列。
• dimname 是分配给行和列的名称。

2.13.2 例

创建一个以数字向量作为输入的矩阵

# Elements are arranged sequentially by row.
M <- matrix(c(3:14), nrow = 4, byrow = TRUE)
print(M)

# Elements are arranged sequentially by column.
N <- matrix(c(3:14), nrow = 4, byrow = FALSE)
print(N)

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P)

当我们执行上面的代码，它产生以下结果

     [,1] [,2] [,3]
[1,]    3    4    5
[2,]    6    7    8
[3,]    9   10   11
[4,]   12   13   14
     [,1] [,2] [,3]
[1,]    3    7   11
[2,]    4    8   12
[3,]    5    9   13
[4,]    6   10   14
     col1 col2 col3
row1    3    4    5
row2    6    7    8
row3    9   10   11
row4   12   13   14

2.13.3 访问矩阵的元素

可以通过使用元素的列和行索引来访问矩阵的元素。 我们考虑上面的矩阵 P 找到下面的具体元素。

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

# Create the matrix.
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))

# Access the element at 3rd column and 1st row.
print(P[1,3])

# Access the element at 2nd column and 4th row.
print(P[4,2])

# Access only the  2nd row.
print(P[2,])

# Access only the 3rd column.
print(P[,3])

当我们执行上面的代码，它产生以下结果

[1] 5
[1] 13
col1 col2 col3 
   6    7    8 
row1 row2 row3 row4 
   5    8   11   14 

2.13.4 矩阵计算

使用 R 运算符对矩阵执行各种数学运算。 操作的结果也是一个矩阵。
对于操作中涉及的矩阵，维度（行数和列数）应该相同。

2.13.4.1 矩阵加法和减法

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Add the matrices.
result <- matrix1 + matrix2
cat("Result of addition","
")
print(result)

# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","
")
print(result)

当我们执行上面的代码，它产生以下结果

     [,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of addition 
     [,1] [,2] [,3]
[1,]    8   -1    5
[2,]   11   13   10
Result of subtraction 
     [,1] [,2] [,3]
[1,]   -2   -1   -1
[2,]    7   -5    2

2.13.4.2 矩阵乘法和除法

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Multiply the matrices.
result <- matrix1 * matrix2
cat("Result of multiplication","
")
print(result)

# Divide the matrices
result <- matrix1 / matrix2
cat("Result of division","
")
print(result)

当我们执行上面的代码，它产生以下结果

     [,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of multiplication 
     [,1] [,2] [,3]
[1,]   15    0    6
[2,]   18   36   24
Result of division 
     [,1]      [,2]      [,3]
[1,]  0.6      -Inf 0.6666667
[2,]  4.5 0.4444444 1.5000000

2.14 R语言 数组

数组是可以在两个以上维度中存储数据的R数据对象。 例如 - 如果我们创建一个维度(2，3，4)的数组，则它创建 4 个矩形矩阵，每个矩阵具有 2 行和 3 列。 数组只能存储数据类型。

使用 array() 函数创建数组。 它使用向量作为输入，并使用 dim 参数中的值创建数组。

2.14.1 例

以下示例创建一个由两个 3x3 矩阵组成的数组，每个矩阵具有 3 行和 3 列。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

当我们执行上面的代码，它产生以下结果

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

2.14.2 命名列和行

我们可以使用 dimnames 参数给数组中的行，列和矩阵命名。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
   matrix.names))
print(result)

当我们执行上面的代码，它产生以下结果

, , Matrix1

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

, , Matrix2

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

2.14.3 访问数组元素

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
   column.names, matrix.names))

# Print the third row of the second matrix of the array.
print(result[3,,2])

# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])

# Print the 2nd Matrix.
print(result[,,2])

当我们执行上面的代码，它产生以下结果

COL1 COL2 COL3 
   3   12   15 
[1] 13
     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

2.14.4 操作数组元素

由于数组由多维构成矩阵，所以对数组元素的操作通过访问矩阵的元素来执行。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
array1 <- array(c(vector1,vector2),dim = c(3,3,2))

# Create two vectors of different lengths.
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))

# create matrices from these arrays.
matrix1 <- array1[,,2]
matrix2 <- array2[,,2]

# Add the matrices.
result <- matrix1+matrix2
print(result)

当我们执行上面的代码，它产生以下结果

     [,1] [,2] [,3]
[1,]   10   20   26
[2,]   18   22   28
[3,]    6   24   30

2.14.5 跨数组元素的计算

我们可以使用 apply() 函数在数组中的元素上进行计算。

2.14.5.1 语法

apply(x, margin, fun)

以下是所使用的参数的说明

• x 是一个数组。
• margin 是所使用的数据集的名称。
• fun 是要应用于数组元素的函数。

2.14.5.2 例

我们使用下面的 apply() 函数计算所有矩阵中数组行中元素的总和。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
new.array <- array(c(vector1,vector2),dim = c(3,3,2))
print(new.array)

# Use apply to calculate the sum of the rows across all the matrices.
result <- apply(new.array, c(1), sum)
print(result)

当我们执行上面的代码，它产生以下结果

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

[1] 56 68 60

2.15 R语言 因子

因子是用于对数据进行分类并将其存储为级别的数据对象。 它们可以存储字符串和整数。 它们在具有有限数量的唯一值的列中很有用。 像 男性，女性 和 True，False 等。它们在统计建模的数据分析中很有用。

使用 factor() 函数通过将向量作为输入创建因子。

2.15.1 例

# Create a vector as input.
data <- c("East","West","East","North","North","East","West","West","West","East","North")

print(data)
print(is.factor(data))

# Apply the factor function.
factor_data <- factor(data)

print(factor_data)
print(is.factor(factor_data))

当我们执行上面的代码，它产生以下结果

 [1] "East"  "West"  "East"  "North" "North" "East"  "West"  "West"  "West"  "East" "North"
[1] FALSE
 [1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
[1] TRUE

2.15.2 数据帧的因子

在创建具有文本数据列的任何数据框时，R语言 将文本列视为分类数据并在其上创建因子。

# Create the vectors for data frame.
height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")

# Create the data frame.
input_data <- data.frame(height,weight,gender)
print(input_data)

# Test if the gender column is a factor.
print(is.factor(input_data$gender))

# Print the gender column so see the levels.
print(input_data$gender)

当我们执行上面的代码，它产生以下结果

  height weight gender
1    132     48   male
2    151     49   male
3    162     66 female
4    139     53 female
5    166     67   male
6    147     52 female
7    122     40   male
[1] TRUE
[1] male   male   female female male   female male  
Levels: female male

2.15.3 更改级别顺序

可以通过使用新的等级次序再次应用因子函数来改变因子中的等级的顺序。

data <- c("East","West","East","North","North","East","West","West","West","East","North")
# Create the factors
factor_data <- factor(data)
print(factor_data)

# Apply the factor function with required order of the level.
new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)

当我们执行上面的代码，它产生以下结果

 [1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
 [1] East  West  East  North North East  West  West  West  East  North
Levels: East West North

2.15.4 生成因子级别

我们可以使用 gl() 函数生成因子级别。 它需要两个整数作为输入，指示每个级别有多少级别和多少次。

2.15.4.1 语法

gl(n, k, labels)

以下是所使用的参数的说明:

• n 是给出级数的整数。
• k 是给出复制数目的整数。
• labels 是所得因子水平的标签向量。

2.15.4.2 例

v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
print(v)

当我们执行上面的代码，它产生以下结果

Tampa   Tampa   Tampa   Tampa   Seattle Seattle Seattle Seattle Boston 
[10] Boston  Boston  Boston 
Levels: Tampa Seattle Boston

2.16 R语言 数据帧

数据帧是表或二维阵列状结构，其中每一列包含一个变量的值，并且每一行包含来自每一列的一组值。

以下是数据帧的特性。

• 列名称应为非空。
• 行名称应该是唯一的。
• 存储在数据帧中的数据可以是数字，因子或字符类型。
• 每个列应包含相同数量的数据项。

2.16.1 创建数据帧

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the data frame.			
print(emp.data) 

当我们执行上面的代码，它产生以下结果

 emp_id    emp_name     salary     start_date
1     1     Rick        623.30     2012-01-01
2     2     Dan         515.20     2013-09-23
3     3     Michelle    611.00     2014-11-15
4     4     Ryan        729.00     2014-05-11
5     5     Gary        843.25     2015-03-27

2.16.2 获取数据帧的结构

通过使用 str() 函数可以看到数据帧的结构。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Get the structure of the data frame.
str(emp.data)

当我们执行上面的代码，它产生以下结果

'data.frame':   5 obs. of  4 variables:
 $ emp_id    : int  1 2 3 4 5
 $ emp_name  : chr  "Rick" "Dan" "Michelle" "Ryan" ...
 $ salary    : num  623 515 611 729 843
 $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...

2.16.3 数据框中的数据摘要

可以通过应用 summary() 函数获取数据的统计摘要和性质。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the summary.
print(summary(emp.data))  

当我们执行上面的代码，它产生以下结果

     emp_id    emp_name             salary        start_date        
 Min.   :1   Length:5           Min.   :515.2   Min.   :2012-01-01  
 1st Qu.:2   Class :character   1st Qu.:611.0   1st Qu.:2013-09-23  
 Median :3   Mode  :character   Median :623.3   Median :2014-05-11  
 Mean   :3                      Mean   :664.4   Mean   :2014-01-14  
 3rd Qu.:4                      3rd Qu.:729.0   3rd Qu.:2014-11-15  
 Max.   :5                      Max.   :843.2   Max.   :2015-03-27 

2.16.4 从数据帧提取数据

使用列名称从数据框中提取特定列。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract Specific columns.
result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)

当我们执行上面的代码，它产生以下结果

  emp.data.emp_name emp.data.salary
1              Rick          623.30
2               Dan          515.20
3          Michelle          611.00
4              Ryan          729.00
5              Gary          843.25

先提取前两行，然后提取所有列

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract first two rows.
result <- emp.data[1:2,]
print(result)

当我们执行上面的代码，它产生以下结果

  emp_id    emp_name   salary    start_date
1      1     Rick      623.3     2012-01-01
2      2     Dan       515.2     2013-09-23

用第 2 和第 4 列提取第 3 和第 5 行

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
	start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Extract 3rd and 5th row with 2nd and 4th column.
result <- emp.data[c(3,5),c(2,4)]
print(result)

当我们执行上面的代码，它产生以下结果

  emp_name start_date
3 Michelle 2014-11-15
5     Gary 2015-03-27

2.16.5 扩展数据帧

可以通过添加列和行来扩展数据帧。

2.16.5.1 添加列

只需使用新的列名称添加列向量。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Add the "dept" coulmn.
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)

当我们执行上面的代码，它产生以下结果

  emp_id   emp_name    salary    start_date       dept
1     1    Rick        623.30    2012-01-01       IT
2     2    Dan         515.20    2013-09-23       Operations
3     3    Michelle    611.00    2014-11-15       IT
4     4    Ryan        729.00    2014-05-11       HR
5     5    Gary        843.25    2015-03-27       Finance

2.16.5.2 添加行

要将更多行永久添加到现有数据帧，我们需要引入与现有数据帧相同结构的新行，并使用 rbind() 函数。
在下面的示例中，我们创建一个包含新行的数据帧，并将其与现有数据帧合并以创建最终数据帧。

# Create the first data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   dept = c("IT","Operations","IT","HR","Finance"),
   stringsAsFactors = FALSE
)

# Create the second data frame
emp.newdata <- 	data.frame(
   emp_id = c (6:8), 
   emp_name = c("Rasmi","Pranab","Tusar"),
   salary = c(578.0,722.5,632.8), 
   start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
   dept = c("IT","Operations","Fianance"),
   stringsAsFactors = FALSE
)

# Bind the two data frames.
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)

当我们执行上面的代码，它产生以下结果

  emp_id     emp_name    salary     start_date       dept
1      1     Rick        623.30     2012-01-01       IT
2      2     Dan         515.20     2013-09-23       Operations
3      3     Michelle    611.00     2014-11-15       IT
4      4     Ryan        729.00     2014-05-11       HR
5      5     Gary        843.25     2015-03-27       Finance
6      6     Rasmi       578.00     2013-05-21       IT
7      7     Pranab      722.50     2013-07-30       Operations
8      8     Tusar       632.80     2014-06-17       Fianance

1. R语言 外部资源

以下资源包含有关R语言编程的其他信息。 请使用它们获得有关此主题的更深入的知识。

1.1 R语言 编程的相关链接

• R 项目 - 官方 R 软件和文档。
• R 编程语言 - 维基百科解释 R 编程语言。
• R Studio - 强大的 R 编程 IDE。

1.2 R 上的编程有用的书籍

• 《THE ART OF R PROGRAMMING》
• 《Learning R》
• 《R IN ACTION》
• 《PRACTICAL DATA SCIENCE WITH R》
• 《Beginning R》
• 《R Cookbook》

2. R语言 相关讨论

R语言 是用于统计分析，图形表示和报告的编程语言和软件环境。 R 由 Ross Ihaka 和 Robert Gentleman 在新西兰奥克兰大学创建，目前由R开发核心团队开发。 R 在 GNU 通用公共许可证下免费提供，并为各种操作系统(如 Linux，Windows 和 Mac)提供预编译的二进制版本。 这种编程语言基于两个 R语言 作者(Robert Gentleman 和 Ross Ihaka)的名字的第一个字母命名为 R语言。

3. R语言 面试题

尊敬的读者，这些 R语言 面试题是专门设计的，以便您应对在 R语言 相关面试中可能会被问到的问题。 根据我的经验，良好的面试官几乎不打算在你的面试中问任何特定的问题，通常都是以如下的问题为开端进一步展开后继的问题。

什么是 R语言 编程?

R语言 是一种用于统计分析和为此目的创建图形的编程语言。不是数据类型，它具有用于计算的数据对象。它用于数据挖掘，回归分析，概率估计等领域，使用其中可用的许多软件包。

R语言 中的不同数据对象是什么?

它们是 R语言 中的 6 个数据对象。它们是向量，列表，数组，矩阵，数据框和表。

什么使 R语言 中的有效变量名?

有效的变量名称由字母，数字和点或下划线字符组成。变量名以字母或不以数字后跟的点开头。

数组和矩阵之间的主要区别是什么?

矩阵总是二维的，因为它只有行和列。但是阵列可以具有任何数量的维度，并且每个维度是矩阵。例如，3x3x2 阵列表示维度为 3x3 的 2 个矩阵。

R语言 中的哪个数据对象用于存储和处理分类数据?

R语言 中的因子数据对象用于存储和处理 R语言 中的分类数据。

如何在 R语言 中加载和使用 csv 文件?

可以使用 R语言 ead.csv 函数加载 csv 文件。 R语言在使用此函数读取 csv 文件时创建数据框。

如何获取R语言中当前工作目录的名称?

命令 getwd() 给出了R语言环境中的当前工作目录。

什么是R语言 Base包?

这是在 R语言 环境设置时默认加载的包。它提供了 R语言 环境中的基本功能，如输入/输出，算术计算等。

在逻辑回归中如何使用 R语言?

逻辑回归处理测量二元响应变量的概率。在 R语言 中，函数 glm() 用于创建逻辑回归。

如何访问名为 M 的矩阵的第 2 列和第 4 行中的元素?

表达式 M [4,2] 给出了第 4 行和第 2 列的元素。

什么是向量中元素的回收?举个例子。

当在操作中涉及不同长度的两个向量时，较短向量的元素被重用以完成操作。这被称为元素循环。示例 -v1 <-c(4,1,0,6)和 V2 <-c(2,4)，则 v1 * v2 给出(8,4,0,24)。重复元件 2 和 4。

在 R语言 中调用函数有什么不同的方法?

我们可以用 3 种方式在 R语言 中调用一个函数。第一种方法是通过使用参数的位置来调用。第二个方法 id 通过使用参数的名称来调用，第三个方法是通过默认参数调用。

什么是 R语言 中的延迟函数评估?

函数的延迟评估意味着，只有当它在函数体内部使用时，才会评估参数。如果没有对函数体中的参数的引用，则它被简单地忽略。

如何在 R语言 中安装软件包?

要在 R语言 中安装一个包，我们使用下面的命令。

install.packages("package Name")

命名用于读取 XML 文件的 R语言 包。
名为 “XML” 的包用于读取和处理 XML 文件。

我们可以更新和删除列表中的任何元素吗?

我们可以更新任何元素，但我们只能删除列表末尾的元素。

给一般表达式在 R语言 中创建一个矩阵。

在 R语言 中创建矩阵的一般表达式是: matrix(data，nrow，ncol，byrow，dimnames)

该函数用于在 R语言 中创建 boxplot 图形?

boxplot() 函数用于在 R语言 中创建箱线图。它使用公式和数据框作为输入创建箱线图。

在做时间序列分析时，在 ts() 函数中fR语言 equency = 6 是什么意思?

频率 6 表示时间序列数据的时间间隔是每 10 分钟一小时。

什么是 R语言 中的数据重塑?

在 R语言 中，数据对象可以从一种形式转换为另一种形式。例如，我们可以通过合并许多列表来创建数据框。这涉及一系列 R语言 命令，以将数据带入新格式。这被称为数据整形。

R语言 unif(4) 的输出是什么?

它生成 0 和 1 之间的 4 个随机数。

如何获得 R语言 中安装的所有软件包的列表?

使用命令

installed.packages()

运行命令 - strsplit(x，"e") 是什么意思?

它将向量 x 中的字符串拆分为字母 e 位置处的子字符串。

给一个 R 脚本从字符串中提取大写的所有唯一字 - “快速的棕色狐狸跳过懒惰的狗”。

x <- "快速的棕色狐狸跳过懒惰的狗"
split.string <- strsplit(x，"")
extract.words <- split.string [[1]]
result <- unique(tolower(extract.words))
print(result)

向量v是c(1,2,3,4)，列表x是列表(5：8)，v * x [1]的输出是什么?

v * x [1] 中的错误：二进制运算符的非数值参数

向量v是c(1,2,3,4)，列表x是列表(5：8)，v * x [[1]]的输出是什么?

[1] 5 12 21 32s

unlist() 是什么?

它将列表转换为向量。

给予 R语言 表达式，从使用 pbinom 的硬币 51 个硬币中得到 26 个或更少的头。

x <- pbinom(26,51,0.5)
print(x)
X是向量c(5,9.2,3,8.51，NA)，mean(x)的输出是什么?
NA

如何将 JSON 文件中的数据转换为数据框?

使用函数 as.data.frame()

在 R语言 中给出一个函数，用向量的元素的和代替向量 x 的所有缺失值?

function(x){x [is.na(x)] 

apply() 在 R语言 中的用途是什么?

它用于对数组中的每个元素应用相同的函数。例如，查找每行中行的平均值。

是数组称为矩阵还是矩阵称为数组?

每个矩阵可以称为数组，但不能相反。矩阵总是二维的，但数组可以是任何维度。

如何找到缺失值的帮助页面?

?NA

如何获得向量x的标准偏差?

sd(x,na.rm = TRUE)

如何在 R语言 中设置当前工作目录的路径?

setwd("Path")

"%%" 和 "%/%" 之间有什么区别?

"%%" 给出第一向量与第二向量的除法的余数，而 "%/%" 给出第一向量与第二向量的除法的商。

col.max(x)是什么?

查找该列具有每行的最大值。

给出创建直方图的命令。

hist()

如何从 R语言 工作区中删除向量?

rm(x)

列出包 “MASS” 中可用的数据集

data(package ="MASS")

列出所有可用软件包中可用的数据集。

data(package = .packages(all.available = TRUE))

什么是命令的使用 - install.packages(file.choose(),repos = NULL)?

它用于通过浏览和选择文件从本地目录安装 R语言 包。

给出命令以检查元素 15 是否存在于向量 x 中。

15% 在 %x

给出创建散点图矩阵的语法。

pairs(formula, data)

其中公式表示成对使用的变量系列，数据表示从中获取变量的数据集。

R语言 中的 subset() 函数和 sample() 函数有什么区别?

subset() 函数用于选择变量和观察值。 sample() 函数用于从数据集中选择大小为 n 的随机样本。

如何检查 “m” 是 R语言 中的矩阵数据对象?

is.matrix(m) 应该重新运行 TRUE。

下面的表达式 all(NA == NA) 的输出是什么?

[1] NA

如何获得矩阵在 R语言 中的转置?

函数 t() 用于转置矩阵。示例 t(m)，其中 m 是矩阵。

在 R语言 中使用 “next” 语句是什么?

当我们想要跳过循环的当前迭代而不终止它时，R 编程语言中的 “next” 语句是有用的。

1. R语言 CSV 文件

在 R语言 中，我们可以从存储在 R语言 环境外的文件中读取数据。 我们还可以将数据写入将被操作系统存储和访问的文件。 R语言 可以读取和写入各种文件格式，如 csv，excel，xml 等。

在本章中，我们将学习从 csv 文件读取数据，然后将数据写入 csv 文件。 该文件应该存在于当前工作目录中，以便 R语言 可以读取它。 当然我们也可以设置我们自己的目录并从那里读取文件。

1.1 获取和设置工作目录

您可以使用 getwd() 函数检查R语言工作区指向的目录。 您还可以使用 setwd() 函数设置新的工作目录。

# Get and print current working directory.
print(getwd())

# Set current working directory.
setwd("/web/com")

# Get and print current working directory.
print(getwd())

当我们执行上面的代码，它产生以下结果

[1] "/web/com/1441086124_2016"
[1] "/web/com"

此结果取决于您的操作系统和您当前工作的目录。

1.2 输入为 CSV 文件

csv 文件是一个文本文件，其中列中的值由逗号分隔。 让我们考虑名为 input.csv 的文件中出现的以下数据。
您可以通过复制和粘贴此数据使用 Windows 记事本创建此文件。 使用记事本中的保存为所有文件（*.*）选项将文件保存为 input.csv。

id,name,salary,start_date,dept
1,Rick,623.3,2012-01-01,IT
2,Dan,515.2,2013-09-23,Operations
3,Michelle,611,2014-11-15,IT
4,Ryan,729,2014-05-11,HR
 ,Gary,843.25,2015-03-27,Finance
6,Nina,578,2013-05-21,IT
7,Simon,632.8,2013-07-30,Operations
8,Guru,722.5,2014-06-17,Finance

1.3 读取 CSV 文件

以下是 read.csv() 函数的一个简单示例，用于读取当前工作目录中可用的 CSV 文件

data <- read.csv("input.csv")
print(data)

当我们执行上面的代码，它产生以下结果

      id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

1.4 分析 CSV 文件

默认情况下，read.csv() 函数将输出作为数据帧。 这可以容易地如下检查。 此外，我们可以检查列和行的数量。

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

print(is.data.frame(data))
print(ncol(data))
print(nrow(data))

当我们执行上面的代码，它产生以下结果

[1] TRUE
[1] 5
[1] 8

一旦我们读取数据帧中的数据，我们可以应用所有适用于数据帧的函数，如下一节所述。

1.4.1 获得最高工资

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)
print(sal)

当我们执行上面的代码，它产生以下结果

[1] 843.25

1.4.2 获取具有最高工资的人的详细信息

我们可以获取满足特定过滤条件的行，类似于 SQL where 子句。

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)

# Get the person detail having max salary.
retval <- subset(data, salary == max(salary))
print(retval)

当我们执行上面的代码，它产生以下结果

      id    name  salary  start_date    dept
5     NA    Gary  843.25  2015-03-27    Finance

1.4.3 获取所有的 IT 部门员工的信息

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset( data, dept == "IT")
print(retval)

当我们执行上面的代码，它产生以下结果

       id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT
6      6    Nina      578.0    2013-05-21   IT

1.4.4 获得工资大于 600 的 IT 部门的人员

# Create a data frame.
data <- read.csv("input.csv")

info <- subset(data, salary > 600 & dept == "IT")
print(info)

当我们执行上面的代码，它产生以下结果

       id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT

1.4.5 获得 2014 年或之后加入的人

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
print(retval)

当我们执行上面的代码，它产生以下结果

       id   name     salary   start_date    dept
3      3    Michelle 611.00   2014-11-15    IT
4      4    Ryan     729.00   2014-05-11    HR
5     NA    Gary     843.25   2015-03-27    Finance
8      8    Guru     722.50   2014-06-17    Finance

1.5 写入 CSV 文件

R语言 可以创建 csv 文件形式的现有数据帧。 write.csv() 函数用于创建 csv 文件。 此文件在工作目录中创建。

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv")
newdata <- read.csv("output.csv")
print(newdata)

当我们执行上面的代码，它产生以下结果

  X      id   name      salary   start_date    dept
1 3      3    Michelle  611.00   2014-11-15    IT
2 4      4    Ryan      729.00   2014-05-11    HR
3 5     NA    Gary      843.25   2015-03-27    Finance
4 8      8    Guru      722.50   2014-06-17    Finance

这里列 X 来自数据集 newper。 这可以在写入文件时使用附加参数删除。

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv", row.names = FALSE)
newdata <- read.csv("output.csv")
print(newdata)

当我们执行上面的代码，它产生以下结果

      id    name      salary   start_date    dept
1      3    Michelle  611.00   2014-11-15    IT
2      4    Ryan      729.00   2014-05-11    HR
3     NA    Gary      843.25   2015-03-27    Finance
4      8    Guru      722.50   2014-06-17    Finance

2. R语言 Excel 文件

Microsoft Excel 是最广泛使用的电子表格程序，以 .xls 或 .xlsx 格式存储数据。 R语言 可以直接从这些文件使用一些 excel 特定的包。 很少这样的包是 - XLConnect，xlsx，gdata 等。我们将使用 xlsx 包。 R语言 也可以使用这个包写入 excel 文件。

2.1 安装 xlsx 软件包

您可以在 R 控制台中使用以下命令来安装 xlsx 软件包。 它可能会要求安装一些额外的软件包这个软件包依赖。 按照具有所需软件包名称的同一命令安装其他软件包。

install.packages("xlsx")

2.2 验证并加载 xlsx 软件包

使用以下命令验证并加载 xlsx 软件包。

# Verify the package is installed.
any(grepl("xlsx",installed.packages()))

# Load the library into R workspace.
library("xlsx")

当脚本运行，我们得到以下输出。

[1] TRUE
Loading required package: rJava
Loading required package: methods
Loading required package: xlsxjars

2.3 输入为 xlsx 文件

打开 Microsoft Excel。 将以下数据复制并粘贴到名为 sheet1 的工作表中。

id	name      salary    start_date	dept
1	Rick	  623.3	    1/1/2012	IT
2	Dan       515.2     9/23/2013   Operations
3	Michelle  611	    11/15/2014	IT
4	Ryan	  729	    5/11/2014	HR
5	Gary	  843.25    3/27/2015	Finance
6	Nina	  578       5/21/2013	IT
7	Simon	  632.8	    7/30/2013	Operations
8	Guru	  722.5	    6/17/2014	Finance

还要将以下数据复制并粘贴到另一个工作表，并将此工作表重命名为 city。

name	 city
Rick	 Seattle
Dan      Tampa
Michelle Chicago
Ryan	 Seattle
Gary	 Houston
Nina	 Boston
Simon	 Mumbai
Guru	 Dallas

将 Excel 文件另存为 input.xlsx。 应将其保存在 R 工作区的当前工作目录中。

2.4 读取 Excel 文件

通过使用 read.xlsx() 函数读取 input.xlsx，如下所示。 结果作为数据帧存储在 R语言 环境中。

# Read the first worksheet in the file input.xlsx.
data <- read.xlsx("input.xlsx", sheetIndex = 1)
print(data)

当我们执行上面的代码，它产生以下结果

      id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

3. R语言 二进制文件

二进制文件是包含仅以位和字节（0 和 1）的形式存储的信息的文件。它们不是人类可读的，因为它中的字节转换为包含许多其他不可打印字符的字符和符号。尝试使用任何文本编辑器读取二进制文件将显示如 Ø 和 ð 的字符。

二进制文件必须由特定程序读取才能使用。例如，Microsoft Word 程序的二进制文件只能通过 Word 程序读取到人类可读的形式。这表示，除了人类可读的文本之外，还有更多的信息，例如字符和页码等的格式化，它们也与字母数字字符一起存储。最后一个二进制文件是一个连续的字节序列。我们在文本文件中看到的换行符是连接第一行到下一行的字符。

有时，由其他程序生成的数据需要由 R 作为二进制文件处理。另外，R语言是创建可以与其他程序共享的二进制文件所必需的。

R语言 有两个函数 WriteBin() 和 readBin() 来创建和读取二进制文件。

3.1 语法

writeBin(object, con)
readBin(con, what, n )

以下是所使用的参数的描述

• con 是读取或写入二进制文件的连接对象。
• object 是要写入的二进制文件。
• 什么是模式，如字符，整数等表示要读取的字节。
• n 是从二进制文件读取的字节数。

3.2 例

我们考虑 R语言 内置数据 mtcars。 首先，我们从它创建一个 csv 文件，并将其转换为二进制文件，并将其存储为操作系统文件。 接下来我们读取这个创建的二进制文件。

3.2.1 写入二进制文件

我们将数据帧 mtcars 读取为 csv 文件，然后将其作为二进制文件写入操作系统。

# Read the "mtcars" data frame as a csv file and store only the columns 
   "cyl", "am" and "gear".
write.table(mtcars, file = "mtcars.csv",row.names = FALSE, na = "", 
   col.names = TRUE, sep = ",")

# Store 5 records from the csv file as a new data frame.
new.mtcars <- read.table("mtcars.csv",sep = ",",header = TRUE,nrows = 5)

# Create a connection object to write the binary file using mode "wb".
write.filename = file("/web/com/binmtcars.dat", "wb")

# Write the column names of the data frame to the connection object.
writeBin(colnames(new.mtcars), write.filename)

# Write the records in each of the column to the file.
writeBin(c(new.mtcars$cyl,new.mtcars$am,new.mtcars$gear), write.filename)

# Close the file for writing so that it can be read by other program.
close(write.filename)

3.2.2 读取二进制文件

上面创建的二进制文件将所有数据存储为连续字节。 因此，我们将通过选择适当的列名称值和列值来读取它。

# Create a connection object to read the file in binary mode using "rb".
read.filename <- file("/web/com/binmtcars.dat", "rb")

# First read the column names. n = 3 as we have 3 columns.
column.names <- readBin(read.filename, character(),  n = 3)

# Next read the column values. n = 18 as we have 3 column names and 15 values.
read.filename <- file("/web/com/binmtcars.dat", "rb")
bindata <- readBin(read.filename, integer(),  n = 18)

# Print the data.
print(bindata)

# Read the values from 4th byte to 8th byte which represents "cyl".
cyldata = bindata[4:8]
print(cyldata)

# Read the values form 9th byte to 13th byte which represents "am".
amdata = bindata[9:13]
print(amdata)

# Read the values form 9th byte to 13th byte which represents "gear".
geardata = bindata[14:18]
print(geardata)

# Combine all the read values to a dat frame.
finaldata = cbind(cyldata, amdata, geardata)
colnames(finaldata) = column.names
print(finaldata)

当我们执行上面的代码，它产生以下结果和图表

 [1]    7108963 1728081249    7496037          6          6          4
 [7]          6          8          1          1          1          0
[13]          0          4          4          4          3          3

[1] 6 6 4 6 8

[1] 1 1 1 0 0

[1] 4 4 4 3 3

     cyl am gear
[1,]   6  1    4
[2,]   6  1    4
[3,]   4  1    4
[4,]   6  0    3
[5,]   8  0    3

正如我们所看到的，我们通过读取 R 中的二进制文件得到原始数据。

4. R语言 XML 文件

XML 是一种文件格式，它使用标准 ASCII 文本共享万维网，内部网和其他地方的文件格式和数据。 它代表可扩展标记语言（XML）。 类似于 HTML 它包含标记标签。 但是与 HTML 中的标记标记描述页面的结构不同，在 xml 中，标记标记描述了包含在文件中的数据的含义。

您可以使用 XML 包读取 R语言 中的 xml 文件。 此软件包可以使用以下命令安装。

install.packages("XML")

4.1 输入数据

通过将以下数据复制到文本编辑器（如记事本）中来创建 XML 文件。 使用 .xml 扩展名保存文件，并将文件类型选择为所有文件 (*.*)。

   
      1
      Rick
      623.3
      1/1/2012
      IT
   
	
   
      2
      Dan
      515.2
      9/23/2013
      Operations
   
   
   
      3
      Michelle
      611
      11/15/2014
      IT
   
   
   
      4
      Ryan
      729
      5/11/2014
      HR
   
   
   
      5
      Gary
      843.25
      3/27/2015
      Finance
   
   
   
      6
      Nina
      578
      5/21/2013
      IT
   
   
   
      7
      Simon
      632.8
      7/30/2013
      Operations
   
   
   
      8
      Guru
      722.5
      6/17/2014
      Finance
   
	

4.2 读取 XML 文件

xml 文件由 R语言 使用函数 xmlParse() 读取。 它作为列表存储在 R语言 中。

# Load the package required to read XML files.
library("XML")

# Also load the other required package.
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Print the result.
print(result)

当我们执行上面的代码，它产生以下结果

1
    Rick
    623.3
    1/1/2012
    IT
  
  
    2
    Dan
    515.2
    9/23/2013
    Operations
  
  
    3
    Michelle
    611
    11/15/2014
    IT
  
  
    4
    Ryan
    729
    5/11/2014
    HR
  
  
    5
    Gary
    843.25
    3/27/2015
    Finance
  
  
    6
    Nina
    578
    5/21/2013
    IT
  
  
    7
    Simon
    632.8
    7/30/2013
    Operations
  
  
    8
    Guru
    722.5
    6/17/2014
    Finance

4.2.1 获取 XML 文件中存在的节点数

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Find number of nodes in the root.
rootsize <- xmlSize(rootnode)

# Print the result.
print(rootsize)

当我们执行上面的代码，它产生以下结果

output
[1] 8

4.3 第一个节点的详细信息

让我们看看解析文件的第一条记录。 它将给我们一个关于存在于顶层节点中的各种元素的想法。

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Print the result.
print(rootnode[1])

当我们执行上面的代码，它产生以下结果

$EMPLOYEE
  1
  Rick
  623.3
  1/1/2012
  IT
 

attr(,"class")
[1] "XMLInternalNodeList" "XMLNodeList" 

4.3.1 获取节点的不同元素

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Get the first element of the first node.
print(rootnode[[1]][[1]])

# Get the fifth element of the first node.
print(rootnode[[1]][[5]])

# Get the second element of the third node.
print(rootnode[[3]][[2]])

当我们执行上面的代码，它产生以下结果

1 
IT 
Michelle 

4.4 XML 到数据帧

为了在大文件中有效地处理数据，我们将 XML 文件中的数据作为数据框读取。 然后处理数据帧以进行数据分析。

# Load the packages required to read XML files.
library("XML")
library("methods")

# Convert the input xml file to a data frame.
xmldataframe <- xmlToDataFrame("input.xml")
print(xmldataframe)

当我们执行上面的代码，它产生以下结果

      ID    NAME     SALARY    STARTDATE       DEPT 
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

由于数据现在可以作为数据帧，我们可以使用数据帧相关函数来读取和操作文件。

5. R语言 JSON 文件

JSON 文件以人类可读格式将数据存储为文本。 Json 代表 JavaScript Object Notation。 R 可以使用 rjson 包读取 JSON 文件。

5.1 安装 rjson 包

在 R语言 控制台中，您可以发出以下命令来安装 rjson 包。

install.packages("rjson")

5.2 输入数据

通过将以下数据复制到文本编辑器（如记事本）中来创建 JSON 文件。 使用 .json 扩展名保存文件，并将文件类型选择为所有文件 (*.*)。

{ 
   "ID":["1","2","3","4","5","6","7","8" ],
   "Name":["Rick","Dan","Michelle","Ryan","Gary","Nina","Simon","Guru" ],
   "Salary":["623.3","515.2","611","729","843.25","578","632.8","722.5" ],
   
   "StartDate":[ "1/1/2012","9/23/2013","11/15/2014","5/11/2014","3/27/2015","5/21/2013",
      "7/30/2013","6/17/2014"],
   "Dept":[ "IT","Operations","IT","HR","Finance","IT","Operations","Finance"]
}

5.3 读取 JSON 文件

JSON 文件由 R 使用来自 JSON() 的函数读取。 它作为列表存储在 R 中。

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Print the result.
print(result)

当我们执行上面的代码，它产生以下结果

$ID
[1] "1"   "2"   "3"   "4"   "5"   "6"   "7"   "8"

$Name
[1] "Rick"     "Dan"      "Michelle" "Ryan"     "Gary"     "Nina"     "Simon"    "Guru"

$Salary
[1] "623.3"  "515.2"  "611"    "729"    "843.25" "578"    "632.8"  "722.5"

$StartDate
[1] "1/1/2012"   "9/23/2013"  "11/15/2014" "5/11/2014"  "3/27/2015"  "5/21/2013"
   "7/30/2013"  "6/17/2014"

$Dept
[1] "IT"         "Operations" "IT"         "HR"         "Finance"    "IT"
   "Operations" "Finance"

5.4 将 JSON 转换为数据帧

我们可以使用 as.data.frame() 函数将上面提取的数据转换为 R语言 数据帧以进行进一步分析。

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Convert JSON file to a data frame.
json_data_frame <- as.data.frame(result)

print(json_data_frame)

当我们执行上面的代码，它产生以下结果

      id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

6. R语言 Web 数据

许多网站提供数据供其用户使用。 例如，世界卫生组织（WHO）以 CSV，txt 和 XML 文件的形式提供健康和医疗信息的报告。 使用 R语言 程序，我们可以从这些网站以编程方式提取特定数据。 R语言 中用于从网站中提取数据的一些包是 RCurl，XML 和 stringr，它们用于连接到 URL，识别文件所需的链接并将它们下载到本地环境。

6.1 安装 R语言 的包

处理 URL 和链接到文件需要以下的包。 如果它们在 R语言 环境中不可用，您可以使用以下命令安装它们。

install.packages("RCurl")
install.packages("XML")
install.packages("stringr")
install.packages("plyr")

6.2 输入数据

我们将访问 URL 天气数据，并使用 R 在 2015 年下载 CSV 文件。

6.3 例

我们将使用函数 getHTMLLinks() 来收集文件的 URL。 然后我们将使用函数 downlaod.file() 将文件保存到本地系统。 由于我们将对多个文件一次又一次地应用相同的代码，因此我们将创建一个被多次调用的函数。 文件名作为参数以 R 列表对象的形式传递到此函数。

# Read the URL.
url <- "http://www.geos.ed.ac.uk/~weather/jcmb_ws/"

# Gather the html links present in the webpage.
links <- getHTMLLinks(url)

# Identify only the links which point to the JCMB 2015 files. 
filenames <- links[str_detect(links, "JCMB_2015")]

# Store the file names as a list.
filenames_list <- as.list(filenames)

# Create a function to download the files by passing the URL and filename list.
downloadcsv <- function (mainurl,filename) {
   filedetails <- str_c(mainurl,filename)
   download.file(filedetails,filename)
}

# Now apply the l_ply function and save the files into the current R working directory.
l_ply(filenames,downloadcsv,mainurl = "http://www.geos.ed.ac.uk/~weather/jcmb_ws/")

6.4 验证文件下载

运行上述代码后，您可以在当前R语言工作目录中找到以下文件。

"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv"
   "JCMB_2015_Mar.csv"

7. R语言 数据库

数据是关系数据库系统以规范化格式存储。 因此，要进行统计计算，我们将需要非常先进和复杂的 Sql 查询。 但 R 语言 可以轻松地连接到许多关系数据库，如 MySql，Oracle，Sql 服务器等，并从它们获取记录作为数据框。 一旦数据在 R语言 环境中可用，它就变成正常的 R语言 数据集，并且可以使用所有强大的包和函数来操作或分析。

在本教程中，我们将使用 MySql 作为连接到 R语言 的参考数据库。

7.1 RMySQL 包

R语言 有一个名为 RMySQL 的内置包，它提供与 MySql 数据库之间的本地连接。 您可以使用以下命令在 R语言 环境中安装此软件包。

install.packages("RMySQL")

7.2 将 R 连接到 MySql

一旦安装了包，我们在 R 中创建一个连接对象以连接到数据库。 它使用用户名，密码，数据库名称和主机名作为输入。

# Create a connection Object to MySQL database.
# We will connect to the sampel database named "sakila" that comes with MySql installation.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
   host = 'localhost')

# List the tables available in this database.
 dbListTables(mysqlconnection)

当我们执行上面的代码，它产生以下结果 -

 [1] "actor"                      "actor_info"                
 [3] "address"                    "category"                  
 [5] "city"                       "country"                   
 [7] "customer"                   "customer_list"             
 [9] "film"                       "film_actor"                
[11] "film_category"              "film_list"                 
[13] "film_text"                  "inventory"                 
[15] "language"                   "nicer_but_slower_film_list"
[17] "payment"                    "rental"                    
[19] "sales_by_film_category"     "sales_by_store"            
[21] "staff"                      "staff_list"                
[23] "store"                     

7.3 查询表

我们可以使用函数 dbSendQuery() 查询 MySql 中的数据库表。 查询在 MySql 中执行，并使用 R语言 fetch() 函数返回结果集。 最后，它被存储为 R语言 中的数据帧。

# Query the "actor" tables to get all the rows.
result = dbSendQuery(mysqlconnection, "select * from actor")

# Store the result in a R data frame object. n = 5 is used to fetch first 5 rows.
data.frame = fetch(result, n = 5)
print(data.frame)

当我们执行上面的代码，它产生以下结果

        actor_id   first_name    last_name         last_update
1        1         PENELOPE      GUINESS           2006-02-15 04:34:33
2        2         NICK          WAHLBERG          2006-02-15 04:34:33
3        3         ED            CHASE             2006-02-15 04:34:33
4        4         JENNIFER      DAVIS             2006-02-15 04:34:33
5        5         JOHNNY        LOLLOBRIGIDA      2006-02-15 04:34:33

7.4 带过滤条件的查询

我们可以传递任何有效的 select 查询来获取结果。

result = dbSendQuery(mysqlconnection, "select * from actor where last_name = 'TORN'")

# Fetch all the records(with n = -1) and store it as a data frame.
data.frame = fetch(result, n = -1)
print(data)

当我们执行上面的代码，它产生以下结果

        actor_id    first_name     last_name         last_update
1        18         DAN            TORN              2006-02-15 04:34:33
2        94         KENNETH        TORN              2006-02-15 04:34:33
3       102         WALTER         TORN              2006-02-15 04:34:33

7.5 更新表中的行

我们可以通过将更新查询传递给 dbSendQuery() 函数来更新 Mysql 表中的行。

dbSendQuery(mysqlconnection, "update mtcars set disp = 168.5 where hp = 110")

在执行上面的代码后，我们可以看到在 MySql 环境中更新的表。

7.6 将数据插入表中

dbSendQuery(mysqlconnection,
   "insert into mtcars(row_names, mpg, cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb)
   values('New Mazda RX4 Wag', 21, 6, 168.5, 110, 3.9, 2.875, 17.02, 0, 1, 4, 4)"
)

在执行上面的代码后，我们可以看到插入到 MySql 环境中的表中的行。

7.7 在 MySql 中创建表

我们可以在 MySql 中使用函数 dbWriteTable() 创建表。 如果表已经存在，它将覆盖该表，并将数据帧用作输入。

# Create the connection object to the database where we want to create the table.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila', 
   host = 'localhost')

# Use the R data frame "mtcars" to create the table in MySql.
# All the rows of mtcars are taken inot MySql.
dbWriteTable(mysqlconnection, "mtcars", mtcars[, ], overwrite = TRUE)

执行上面的代码后，我们可以看到在 MySql 环境中创建的表。

7.8 删除 MySql 中的表

我们可以删除 MySql 数据库中的表，将 drop table 语句传递到 dbSendQuery() 中，就像我们使用它查询表中的数据一样。

dbSendQuery(mysqlconnection, 'drop table if exists mtcars')

执行上面的代码后，我们可以看到表在 MySql 环境中被删除。

1. R语言 条形图

条形图表示矩形条中的数据，条的长度与变量的值成比例。 R语言 使用函数 barplot() 创建条形图。 R语言 可以在条形图中绘制垂直和水平条。 在条形图中，每个条可以给予不同的颜色。

1.1 语法

在 R语言 中创建条形图的基本语法是

barplot(H, xlab, ylab, main, names.arg, col)

以下是所使用的参数的描述

• H 是包含在条形图中使用的数值的向量或矩阵。
• xlab 是 x 轴的标签。
• ylab 是 y 轴的标签。
• main 是条形图的标题。
• names.arg 是在每个条下出现的名称的向量。
• col 用于向图中的条形提供颜色。

1.2 例

使用输入向量和每个条的名称创建一个简单的条形图。

以下脚本将创建并保存当前 R语言 工作目录中的条形图。

# Create the data for the chart.
H <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "barchart.png")

# Plot the bar chart.
barplot(H)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K7h49BX4-1670571435895)(http://p8cg9782i.bkt.clouddn.com/R-barchart.png)]

1.3 条形图标签，标题和颜色

可以通过添加更多参数来扩展条形图的功能。 主要参数用于添加标题。 col 参数用于向条形添加颜色。 args.name 是具有与输入向量相同数量的值的向量，以描述每个条的含义。

1.3.1 例

以下脚本将在当前R语言工作目录中创建并保存条形图。

# Create the data for the chart.
H <- c(7,12,28,3,41)
M <- c("Mar","Apr","May","Jun","Jul")

# Give the chart file a name.
png(file = "barchart_months_revenue.png")

# Plot the bar chart.
barplot(H,names.arg = M,xlab = "Month",ylab = "Revenue",col = "blue",
main = "Revenue chart",border = "red")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bulU5izd-1670571435895)(http://p8cg9782i.bkt.clouddn.com/R-barchart-months-revenue.png)]

1.4 组合条形图和堆积条形图

我们可以使用矩阵作为输入值，在每个条中创建条形图和堆叠组的条形图。

超过两个变量表示为用于创建组合条形图和堆叠条形图的矩阵。

# Create the input vectors.
colors <- c("green","orange","brown")
months <- c("Mar","Apr","May","Jun","Jul")
regions <- c("East","West","North")

# Create the matrix of the values.
Values <- matrix(c(2,9,3,11,9,4,8,7,3,12,5,2,8,10,11),nrow = 3,ncol = 5,byrow = TRUE)

# Give the chart file a name.
png(file = "barchart_stacked.png")

# Create the bar chart.
barplot(Values,main = "total revenue",names.arg = months,xlab = "month",ylab = "revenue",
   col = colors)

# Add the legend to the chart.
legend("topleft", regions, cex = 1.3, fill = colors)

# Save the file.
dev.off()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BSh1gBU2-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-barchart-stacked.png)]

2. R语言 箱线图

箱线图是数据集中的数据分布良好的度量。 它将数据集分成三个四分位数。 此图表表示数据集中的最小值，最大值，中值，第一四分位数和第三四分位数。 它还可用于通过绘制每个数据集的箱线图来比较数据集之间的数据分布。

R语言 中使用 boxplot() 函数来创建箱线图。

2.1 语法

在 R语言 中创建箱线图的基本语法是

boxplot(x, data, notch, varwidth, names, main)

以下是所使用的参数的描述

• x 是向量或公式。
• 数据是数据帧。
• notch 是逻辑值。 设置为 TRUE 以绘制凹口。
• varwidth 是一个逻辑值。 设置为 true 以绘制与样本大小成比例的框的宽度。
• names 是将打印在每个箱线图下的组标签。
• main 用于给图表标题。

2.2 例

我们使用 R语言 环境中可用的数据集 mtcars 来创建基本箱线图。 让我们看看 mtcars 中的列 mpg 和 cyl。

input <- mtcars[,c('mpg','cyl')]
print(head(input))

当我们执行上面的代码，它会产生以下结果

                   mpg  cyl
Mazda RX4         21.0   6
Mazda RX4 Wag     21.0   6
Datsun 710        22.8   4
Hornet 4 Drive    21.4   6
Hornet Sportabout 18.7   8
Valiant           18.1   6

2.3 创建箱线图

以下脚本将为 mpg（英里/加仑）和 cyl（气缸数）之间的关系创建箱线图。

# Give the chart file a name.
png(file = "boxplot.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon", main = "Mileage Data")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8SsHD2UZ-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-boxplot.png)]

2.4 带槽的箱线图

我们可以绘制带槽的箱线图，以了解不同数据组的中值如何相互匹配。

以下脚本将为每个数据组创建一个带缺口的箱线图。

# Give the chart file a name.
png(file = "boxplot_with_notch.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, 
   xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon", 
   main = "Mileage Data",
   notch = TRUE, 
   varwidth = TRUE, 
   col = c("green","yellow","purple"),
   names = c("High","Medium","Low")
)
# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tUB49Z9z-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-boxplot-with-notch.png)]

3. R语言 直方图

直方图表示被存储到范围中的变量的值的频率。 直方图类似于条形图，但不同之处在于将值分组为连续范围。 直方图中的每个柱表示该范围中存在的值的数量的高度。

R语言 使用 hist() 函数创建直方图。 此函数使用向量作为输入，并使用一些更多的参数来绘制直方图。

3.1 语法

使用 R语言 创建直方图的基本语法是

hist(v,main,xlab,xlim,ylim,breaks,col,border)

以下是所使用的参数的描述

• v 是包含直方图中使用的数值的向量。
• main 表示图表的标题。
• col 用于设置条的颜色。
• border 用于设置每个条的边框颜色。
• xlab 用于给出 x 轴的描述。
• xlim 用于指定 x 轴上的值的范围。
• ylim 用于指定 y 轴上的值的范围。
• break 用于提及每个条的宽度。

3.2 例

使用输入 vector，label，col 和边界参数创建一个简单的直方图。

下面给出的脚本将创建并保存当前 R语言 工作目录中的直方图。

# Create data for the graph.
v <-  c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "yellow",border = "blue")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nCQTueQt-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-histogram.png)]

3.3 X 和 Y 值的范围

要指定 X 轴和 Y 轴允许的值的范围，我们可以使用 xlim 和 ylim 参数。

每个条的宽度可以通过使用间隔来确定。

# Create data for the graph.
v <- c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram_lim_breaks.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "green",border = "red", xlim = c(0,40), ylim = c(0,5),
   breaks = 5)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Op9aep22-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-histogram-lim-breaks.png)]

4. R语言 拆线图

折线图是通过在它们之间绘制线段来连接一系列点的图。 这些点在它们的坐标（通常是 x 坐标）值之一中排序。 折线图通常用于识别数据中的趋势。

R语言 中的 plot() 函数用于创建折线图。

4.1 语法

在 R语言 中创建折线图的基本语法是

plot(v,type,col,xlab,ylab)

以下是所使用的参数的描述

• v 是包含数值的向量。
• 类型采用值 p 仅绘制点， l 仅绘制线和 o 绘制点和线。
• xlab 是 x 轴的标签。
• ylab 是 y 轴的标签。
• main 是图表的标题。
• col 用于给点和线的颜色。

4.2 例

使用输入向量和类型参数 O 创建简单的折线图。 以下脚本将在当前 R 工作目录中创建并保存折线图。

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart.jpg")

# Plot the bar chart. 
plot(v,type = "o")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oIKhltuH-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-line-chart.jpg)]

4.3 折线图标题，颜色和标签

线图的特征可以通过使用附加参数来扩展。 我们向点和线添加颜色，为图表添加标题，并向轴添加标签。

4.3.1 例

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart_label_colored.jpg")

# Plot the bar chart.
plot(v,type = "o", col = "red", xlab = "Month", ylab = "Rain fall",
   main = "Rain fall chart")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9HCuNNik-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-line-chart-label-colored.jpg)]

4.4 多线型折线图

通过使用 lines() 函数，可以在同一个图表上绘制多条线。

在绘制第一行之后，lines() 函数可以使用一个额外的向量作为输入来绘制图表中的第二行。

# Create the data for the chart.
v <- c(7,12,28,3,41)
t <- c(14,7,6,19,3)

# Give the chart file a name.
png(file = "line_chart_2_lines.jpg")

# Plot the bar chart.
plot(v,type = "o",col = "red", xlab = "Month", ylab = "Rain fall", 
   main = "Rain fall chart")

lines(t, type = "o", col = "blue")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ykxnSGO-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-line-chart-2-lines.jpg)]

5. R语言 散点图

散点图显示在笛卡尔平面中绘制的许多点。 每个点表示两个变量的值。 在水平轴上选择一个变量，在垂直轴上选择另一个变量。

使用 plot() 函数创建简单散点图。

5.1 语法

在 R语言 中创建散点图的基本语法是

plot(x, y, main, xlab, ylab, xlim, ylim, axes)

以下是所使用的参数的描述

• x 是其值为水平坐标的数据集。
• y 是其值是垂直坐标的数据集。
• main 要是图形的图块。
• xlab 是水平轴上的标签。
• ylab 是垂直轴上的标签。
• xlim 是用于绘图的 x 的值的极限。
• ylim 是用于绘图的 y 的值的极限。
• axes 指示是否应在绘图上绘制两个轴。

5.2 例

我们使用 R语言 环境中可用的数据集 mtcars 来创建基本散点图。 让我们使用 mtcars 中的 wt 和 mpg 列。

input <- mtcars[,c('wt','mpg')]
print(head(input))

当我们执行上面的代码，它产生以下结果

                    wt      mpg
Mazda RX4           2.620   21.0
Mazda RX4 Wag       2.875   21.0
Datsun 710          2.320   22.8
Hornet 4 Drive      3.215   21.4
Hornet Sportabout   3.440   18.7
Valiant             3.460   18.1

5.3 创建散点图

以下脚本将为 wt（重量）和 mpg（英里/加仑）之间的关系创建一个散点图。

# Get the input values.
input <- mtcars[,c('wt','mpg')]

# Give the chart file a name.
png(file = "scatterplot.png")

# Plot the chart for cars with weight between 2.5 to 5 and mileage between 15 and 30.
plot(x = input$wt,y = input$mpg,
   xlab = "Weight",
   ylab = "Milage",
   xlim = c(2.5,5),
   ylim = c(15,30),		 
   main = "Weight vs Milage"
)
	 
# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GXTHX7KB-1670571435896)(http://p8cg9782i.bkt.clouddn.com/R-scatterplot.png)]

5.4 散点图矩阵

当我们有两个以上的变量，我们想找到一个变量和其余变量之间的相关性，我们使用散点图矩阵。 我们使用 pairs() 函数创建散点图的矩阵。

5.4.1 语法

在 R 中创建散点图矩阵的基本语法是

pairs(formula, data)

以下是所使用的参数的描述

• formula 表示成对使用的一系列变量。
• data 表示将从其获取变量的数据集。

5.4.2 例

每个变量与每个剩余变量配对。 为每对绘制散点图。

# Give the chart file a name.
png(file = "scatterplot_matrices.png")

# Plot the matrices between 4 variables giving 12 plots.

# One variable with 3 others and total 4 variables.

pairs(~wt+mpg+disp+cyl,data = mtcars,
   main = "Scatterplot Matrix")

# Save the file.
dev.off()

当执行上面的代码中，我们得到以下输出。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6p2YEBZv-1670571435897)(http://p8cg9782i.bkt.clouddn.com/R-scatterplot-matrices.png)]

6. R语言 饼状图

R 编程语言有许多库来创建图表和图表。 饼图是将值表示为具有不同颜色的圆的切片。 切片被标记，并且对应于每个片的数字也在图表中表示。

在 R语言 中，饼图是使用 pie() 函数创建的，它使用正数作为向量输入。 附加参数用于控制标签，颜色，标题等。

6.1 语法

使用 R语言 创建饼图的基本语法是

pie(x, labels, radius, main, col, clockwise)

以下是所使用的参数的描述

• x 是包含饼图中使用的数值的向量。
• labels 用于给出切片的描述。
• radius 表示饼图圆的半径（值 -1 和 +1 之间）。
• main 表示图表的标题。
• col 表示调色板。
• clockwise 是指示片段是顺时针还是逆时针绘制的逻辑值。

6.2 例

使用输入向量和标签创建一个非常简单的饼图。 以下脚本将创建并保存当前 R语言 工作目录中的饼图。

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city.jpg")

# Plot the chart.
pie(x,labels)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OqBoSDCQ-1670571435897)(http://p8cg9782i.bkt.clouddn.com/R-city.jpg)]

6.3 饼图标题和颜色

我们可以通过向函数中添加更多参数来扩展图表的功能。 我们将使用参数 main 向图表添加标题，另一个参数是 col，它将在绘制图表时使用彩虹色板。 托盘的长度应与图表中的值的数量相同。 因此，我们使用 length(x)。

6.4 例

以下脚本将创建并保存当前 R语言 工作目录中的饼图。

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city_title_colours.jpg")

# Plot the chart with title and rainbow color pallet.
pie(x, labels, main = "City pie chart", col = rainbow(length(x)))

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9cNaNjJU-1670571435897)(http://p8cg9782i.bkt.clouddn.com/R-city-title-colours.jpg)]

6.5 切片百分比和图表图例

我们可以通过创建其他图表变量来添加切片百分比和图表图例。

# Create data for the graph.
x <-  c(21, 62, 10,53)
labels <-  c("London","New York","Singapore","Mumbai")

piepercent<- round(100*x/sum(x), 1)

# Give the chart file a name.
png(file = "city_percentage_legends.jpg")

# Plot the chart.
pie(x, labels = piepercent, main = "City pie chart",col = rainbow(length(x)))
legend("topright", c("London","New York","Singapore","Mumbai"), cex = 0.8,
   fill = rainbow(length(x)))

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yvXr3aX9-1670571435897)(http://p8cg9782i.bkt.clouddn.com/R-city-percentage-legends.jpg)]

6.6 3D 饼图

可以使用其他软件包绘制具有 3 个维度的饼图。 软件包 plotrix 有一个名为 pie3D() 的函数，用于此。

# Get the library.
library(plotrix)

# Create data for the graph.
x <-  c(21, 62, 10,53)
lbl <-  c("London","New York","Singapore","Mumbai")

# Give the chart file a name.
png(file = "3d_pie_chart.jpg")

# Plot the chart.
pie3D(x,labels = lbl,explode = 0.1, main = "Pie Chart of Countries ")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q8DLYODI-1670571435897)(http://p8cg9782i.bkt.clouddn.com/R-3d-pie-chart.jpg)]

1. R语言 平均值，中位数和模式

R 中的统计分析通过使用许多内置函数来执行。 这些函数大多数是 R 基础包的一部分。 这些函数将 R 向量作为输入和参数，并给出结果。

我们在本章中讨论的功能是平均值，中位数和模式。

1.1 Mean 平均值

通过求出数据集的和再除以求和数的总量得到平均值

函数 mean() 用于在 R语言 中计算平均值。

1.2 语法

用于计算 R 中的平均值的基本语法是

mean(x, trim = 0, na.rm = FALSE, ...)

以下是所使用的参数的描述

• x 是输入向量。
• trim 用于从排序向量的两端丢弃一些观察结果。
• na.rm 用于从输入向量中删除缺失值。

1.3 例

# Create a vector. 
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <- mean(x)
print(result.mean)

当我们执行上面的代码，它产生以下结果

[1] 8.22

1.4 应用修剪选项

当提供 trim 参数时，向量中的值被排序，然后从计算平均值中减去所需的观察值。

当 trim = 0.3 时，来自每端的 3 个值将从计算中减去以找到均值。

在这种情况下，排序的向量是（-21,-5,2,3,4.2,7,8,12,18,54），并且从用于计算平均值的向量中移除的值是（-21,-5,2） 从左边和（12,18,54）从右边。

# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <-  mean(x,trim = 0.3)
print(result.mean)

当我们执行上面的代码，它产生以下结果

[1] 5.55

1.5 应用 NA 选项

如果有缺失值，则平均函数返回 NA。

要从计算中删除缺少的值，请使用 na.rm = TRUE。 这意味着去除 NA 值。

# Create a vector. 
x <- c(12,7,3,4.2,18,2,54,-21,8,-5,NA)

# Find mean.
result.mean <-  mean(x)
print(result.mean)

# Find mean dropping NA values.
result.mean <-  mean(x,na.rm = TRUE)
print(result.mean)

当我们执行上面的代码，它产生以下结果

[1] NA
[1] 8.22

1.6 Median 中位数

数据系列中的最中间值称为中值。 在 R语言 中使用 median() 函数来计算此值。

1.6.1 语法

计算 R语言 中位数的基本语法是

median(x, na.rm = FALSE)

以下是所使用的参数的描述

• x 是输入向量。
• na.rm 用于从输入向量中删除缺失值。

例

# Create the vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find the median.
median.result <- median(x)
print(median.result)

当我们执行上面的代码，它产生以下结果

[1] 5.6

1.7 Mode 模式

模式是一组数据中出现次数最多的值。 Unike 平均值和中位数，模式可以同时包含数字和字符数据。

R语言 没有标准的内置函数来计算模式。 因此，我们创建一个用户函数来计算 R语言 中的数据集的模式。该函数将向量作为输入，并将模式值作为输出。

例

# Create the function.
getmode <- function(v) {
   uniqv <- unique(v)
   uniqv[which.max(tabulate(match(v, uniqv)))]
}

# Create the vector with numbers.
v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)

# Calculate the mode using the user function.
result <- getmode(v)
print(result)

# Create the vector with characters.
charv <- c("o","it","the","it","it")

# Calculate the mode using the user function.
result <- getmode(charv)
print(result)

当我们执行上面的代码，它产生以下结果

[1] 2
[1] "it"

2. R语言 线性回归

回归分析是一种非常广泛使用的统计工具，用于建立两个变量之间的关系模型。 这些变量之一称为预测变量，其值通过实验收集。 另一个变量称为响应变量，其值从预测变量派生。

在线性回归中，这两个变量通过方程相关，其中这两个变量的指数（幂）为 1. 数学上，线性关系表示当绘制为曲线图时的直线。 任何变量的指数不等于1的非线性关系将创建一条曲线。

线性回归的一般数学方程为

y = ax + b

以下是所使用的参数的描述:

• y 是响应变量。
• x 是预测变量。
• a 和 b 被称为系数常数。

2.1 建立回归的步骤

回归的简单例子是当人的身高已知时预测人的体重。 为了做到这一点，我们需要有一个人的身高和体重之间的关系。

创建关系的步骤是

• 进行收集高度和相应重量的观测值的样本的实验。
• 使用 R语言 中的 lm() 函数创建关系模型。
• 从创建的模型中找到系数，并使用这些创建数学方程
• 获得关系模型的摘要以了解预测中的平均误差。 也称为残差。
• 为了预测新人的体重，使用 R 中的 predict() 函数。

2.1.1 输入数据

下面是代表观察的样本数据

# Values of height
151, 174, 138, 186, 128, 136, 179, 163, 152, 131

# Values of weight.
63, 81, 56, 91, 47, 57, 76, 72, 62, 48

2.2 LM() 函数

此函数创建预测变量和响应变量之间的关系模型。

2.1.1 语法

线性回归中 lm() 函数的基本语法是

lm(formula,data)

以下是所使用的参数的说明

• 公式是表示 x 和 y 之间的关系的符号。
• 数据是应用公式的向量。

2.1.2 创建关系模型并获取系数

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(relation)

当我们执行上面的代码，它产生以下结果

Call:
lm(formula = y ~ x)

Coefficients:
(Intercept)            x  
   -38.4551          0.6746 

2.1.3 获取相关的摘要

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(summary(relation))

当我们执行上面的代码，它产生以下结果

Call:
lm(formula = y ~ x)

Residuals:
    Min      1Q     Median      3Q     Max 
-6.3002    -1.6629  0.0412    1.8944  3.9775 

Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept) -38.45509    8.04901  -4.778  0.00139 ** 
x             0.67461    0.05191  12.997 1.16e-06 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 3.253 on 8 degrees of freedom
Multiple R-squared:  0.9548,    Adjusted R-squared:  0.9491 
F-statistic: 168.9 on 1 and 8 DF,  p-value: 1.164e-06

2.2 predict() 函数

2.2.1 语法

线性回归中的 predict() 的基本语法是

predict(object, newdata)

以下是所使用的参数的描述

• object 是已使用 lm() 函数创建的公式。
• newdata 是包含预测变量的新值的向量。

2.2.2 预测新人的体重

# The predictor vector.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)

# The resposne vector.
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

# Find weight of a person with height 170.
a <- data.frame(x = 170)
result <-  predict(relation,a)
print(result)

当我们执行上面的代码，它产生以下结果

       1 
76.22869 

2.2.3 以图形方式可视化回归

# Create the predictor and response variable.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
relation <- lm(y~x)

# Give the chart file a name.
png(file = "linearregression.png")

# Plot the chart.
plot(y,x,col = "blue",main = "Height & Weight Regression",
abline(lm(x~y)),cex = 1.3,pch = 16,xlab = "Weight in Kg",ylab = "Height in cm")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6BhOBMbl-1670571435897)(http://p8cg9782i.bkt.clouddn.com/R-linearregression.png)]

3. R语言 多重回归

多元回归是线性回归到两个以上变量之间的关系的延伸。 在简单线性关系中，我们有一个预测变量和一个响应变量，但在多元回归中，我们有多个预测变量和一个响应变量。

多元回归的一般数学方程为

y = a + b1x1 + b2x2 +...bnxn

以下是所使用的参数的描述

• y 是响应变量。
• a，b1，b2 … bn 是系数。
• x1，x2，… xn 是预测变量。

我们使用 R语言 中的 lm() 函数创建回归模型。模型使用输入数据确定系数的值。 接下来，我们可以使用这些系数来预测给定的一组预测变量的响应变量的值。

3.1 lm() 函数

此函数创建预测变量和响应变量之间的关系模型。

3.1.1 语法

lm() 函数在多元回归中的基本语法是

lm(y ~ x1+x2+x3...,data)

以下是所使用的参数的描述

• 公式是表示响应变量和预测变量之间的关系的符号。
• 数据是应用公式的向量。

3.1.2 例

3.1.2.1 输入数据

考虑在 R语言 环境中可用的数据集 mtcars。 它给出了每加仑里程（mpg），气缸排量（disp），马力（hp），汽车重量（wt）和一些其他参数的不同汽车模型之间的比较。

模型的目标是建立 mpg 作为响应变量与 disp，hp 和 wt 作为预测变量之间的关系。 为此，我们从 mtcars 数据集中创建这些变量的子集。

input <- mtcars[,c("mpg","disp","hp","wt")]
print(head(input))

当我们执行上面的代码，它产生以下结果

                   mpg   disp   hp    wt
Mazda RX4          21.0  160    110   2.620
Mazda RX4 Wag      21.0  160    110   2.875
Datsun 710         22.8  108     93   2.320
Hornet 4 Drive     21.4  258    110   3.215
Hornet Sportabout  18.7  360    175   3.440
Valiant            18.1  225    105   3.460

3.1.2.2 创建关系模型并获取系数

input <- mtcars[,c("mpg","disp","hp","wt")]

# Create the relationship model.
model <- lm(mpg~disp+hp+wt, data = input)

# Show the model.
print(model)

# Get the Intercept and coefficients as vector elements.
cat("# # # # The Coefficient Values # # # ","
")

a <- coef(model)[1]
print(a)

Xdisp <- coef(model)[2]
Xhp <- coef(model)[3]
Xwt <- coef(model)[4]

print(Xdisp)
print(Xhp)
print(Xwt)

当我们执行上面的代码，它产生以下结果

Call:
lm(formula = mpg ~ disp + hp + wt, data = input)

Coefficients:
(Intercept)         disp           hp           wt  
  37.105505      -0.000937        -0.031157    -3.800891  

# # # # The Coefficient Values # # # 
(Intercept) 
   37.10551 
         disp 
-0.0009370091 
         hp 
-0.03115655 
       wt 
-3.800891 

3.1.2.3 创建回归模型的方程

基于上述截距和系数值，我们创建了数学方程。

Y = a+Xdisp.x1+Xhp.x2+Xwt.x3
or
Y = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3

3.1.2.4 应用方程预测新值

当提供一组新的位移，马力和重量值时，我们可以使用上面创建的回归方程来预测里程数。
对于 disp = 221，hp = 102 和 wt = 2.91 的汽车，预测里程为:

Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.7104

4. R语言 逻辑回归

逻辑回归是回归模型，其中响应变量（因变量）具有诸如 True / False 或 0/1 的分类值。 它实际上基于将其与预测变量相关的数学方程测量二元响应的概率作为响应变量的值。

逻辑回归的一般数学方程为

y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))

以下是所使用的参数的描述:

• y 是响应变量。
• x 是预测变量。
• a 和 b 是作为数字常数的系数。

用于创建回归模型的函数是 glm() 函数。

4.1 语法

逻辑回归中 glm() 函数的基本语法是

glm(formula,data,family)

以下是所使用的参数的描述

• formula 是表示变量之间的关系的符号。
• data 是给出这些变量的值的数据集。
• family 是 R语言 对象来指定模型的细节。 它的值是二项逻辑回归。

4.2 例

内置数据集 mtcars 描述具有各种发动机规格的汽车的不同型号。 在 mtcars 数据集中，传输模式（自动或手动）由 am 列描述，它是一个二进制值（0或1）。 我们可以在列 am 和其他 3 列（hp，wt 和 cyl）之间创建逻辑回归模型。

# Select some columns form mtcars.
input <- mtcars[,c("am","cyl","hp","wt")]

print(head(input))

当我们执行上面的代码，它产生以下结果

                  am   cyl  hp    wt
Mazda RX4          1   6    110   2.620
Mazda RX4 Wag      1   6    110   2.875
Datsun 710         1   4     93   2.320
Hornet 4 Drive     0   6    110   3.215
Hornet Sportabout  0   8    175   3.440
Valiant            0   6    105   3.460

4.3 创建回归模型

我们使用 glm() 函数创建回归模型，并得到其摘要进行分析。

input <- mtcars[,c("am","cyl","hp","wt")]

am.data = glm(formula = am ~ cyl + hp + wt, data = input, family = binomial)

print(summary(am.data))

当我们执行上面的代码，它产生以下结果

Call:
glm(formula = am ~ cyl + hp + wt, family = binomial, data = input)

Deviance Residuals: 
     Min        1Q      Median        3Q       Max  
-2.17272     -0.14907  -0.01464     0.14116   1.27641  

Coefficients:
            Estimate Std. Error z value Pr(>|z|)  
(Intercept) 19.70288    8.11637   2.428   0.0152 *
cyl          0.48760    1.07162   0.455   0.6491  
hp           0.03259    0.01886   1.728   0.0840 .
wt          -9.14947    4.15332  -2.203   0.0276 *
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for binomial family taken to be 1)

    Null deviance: 43.2297  on 31  degrees of freedom
Residual deviance:  9.8415  on 28  degrees of freedom
AIC: 17.841

Number of Fisher Scoring iterations: 8

4.4 结论

在总结中，对于变量 cyl 和 hp，最后一列中的 p 值大于 0.05，我们认为它们对变量 am 的值有贡献是无关紧要的。 只有重量(wt)影响该回归模型中的 am 值。

5. R语言 标准分布

在来自独立源的数据的随机集合中，通常观察到数据的分布是正常的。 这意味着，在绘制水平轴上的变量值和垂直轴上的值的计数的图形时，我们得到钟形曲线。 曲线的中心表示数据集的平均值。 在图中，50% 的值位于平均值的左侧，另外 50% 位于图表的右侧。 这在统计学中被称为正态分布。

R语言 有四个内置函数来产生正态分布。 它们描述如下。

dnorm(x, mean, sd)
pnorm(x, mean, sd)
qnorm(p, mean, sd)
rnorm(n, mean, sd)

以下是在上述功能中使用的参数的描述

• x 是数字的向量。
• p 是概率的向量。
• n 是观察的数量（样本大小）。
• mean 是样本数据的平均值。 它的默认值为零。
• sd 是标准偏差。 它的默认值为 1。

5.1 dnorm()

该函数给出给定平均值和标准偏差在每个点的概率分布的高度。

# Create a sequence of numbers between -10 and 10 incrementing by 0.1.
x <- seq(-10, 10, by = .1)

# Choose the mean as 2.5 and standard deviation as 0.5.
y <- dnorm(x, mean = 2.5, sd = 0.5)

# Give the chart file a name.
png(file = "dnorm.png")

plot(x,y)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T3wZUTpt-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-dnorm.png)]

5.2 pnorm()

该函数给出正态分布随机数的概率小于给定数的值。 它也被称为 “累积分布函数”。

# Create a sequence of numbers between -10 and 10 incrementing by 0.2.
x <- seq(-10,10,by = .2)
 
# Choose the mean as 2.5 and standard deviation as 2. 
y <- pnorm(x, mean = 2.5, sd = 2)

# Give the chart file a name.
png(file = "pnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9LJOYk3D-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-pnorm.png)]

5.3 qnorm()

该函数采用概率值，并给出累积值与概率值匹配的数字。

# Create a sequence of probability values incrementing by 0.02.
x <- seq(0, 1, by = 0.02)

# Choose the mean as 2 and standard deviation as 3.
y <- qnorm(x, mean = 2, sd = 1)

# Give the chart file a name.
png(file = "qnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h3w4nS3K-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-qnorm.png)]

5.4 rnorm()

此函数用于生成分布正常的随机数。 它将样本大小作为输入，并生成许多随机数。 我们绘制一个直方图来显示生成的数字的分布。

# Create a sample of 50 numbers which are normally distributed.
y <- rnorm(50)

# Give the chart file a name.
png(file = "rnorm.png")

# Plot the histogram for this sample.
hist(y, main = "Normal DIstribution")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oLPTQLOq-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-rnorm.png)]

6. R语言 二项分布

二项分布模型处理在一系列实验中仅发现两个可能结果的事件的成功概率。 例如，掷硬币总是给出头或尾。 在二项分布期间估计在 10 次重复抛掷硬币中精确找到 3 个头的概率。

R语言 有四个内置函数来生成二项分布。 它们描述如下。

dbinom(x, size, prob)
pbinom(x, size, prob)
qbinom(p, size, prob)
rbinom(n, size, prob)

以下是所使用的参数的描述

• x 是数字的向量。
• p 是概率向量。
• n 是观察的数量。
• size 是试验的数量。
• prob 是每个试验成功的概率。

6.1 dbinom()

该函数给出每个点的概率密度分布。

# Create a sample of 50 numbers which are incremented by 1.
x <- seq(0,50,by = 1)

# Create the binomial distribution.
y <- dbinom(x,50,0.5)

# Give the chart file a name.
png(file = "dbinom.png")

# Plot the graph for this sample.
plot(x,y)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4CZwFrPn-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-dbinom.png)]

6.2 pbinom()

此函数给出事件的累积概率。 它是表示概率的单个值。

# Probability of getting 26 or less heads from a 51 tosses of a coin.
x <- pbinom(26,51,0.5)

print(x)

当我们执行上面的代码，它产生以下结果

[1] 0.610116

6.3 qbinom()

该函数采用概率值，并给出累积值与概率值匹配的数字。

# How many heads will have a probability of 0.25 will come out when a coin is tossed 51 times.
x <- qbinom(0.25,51,1/2)

print(x)

当我们执行上面的代码，它产生以下结果

[1] 23

6.4 rbinom()

该函数从给定样本产生给定概率的所需数量的随机值。

# Find 8 random values from a sample of 150 with probability of 0.4.
x <- rbinom(8,150,.4)

print(x)

当我们执行上面的代码，它产生以下结果

[1] 58 61 59 66 55 60 61 67

7. R语言 泊松回归

泊松回归包括回归模型，其中响应变量是计数而不是分数的形式。 例如，足球比赛系列中的出生次数或胜利次数。 此外，响应变量的值遵循泊松分布。

泊松回归的一般数学方程为

log(y) = a + b1x1 + b2x2 + bnxn.....

以下是所使用的参数的描述

• y 是响应变量。
• a 和 b 是数字系数。
• x 是预测变量。

用于创建泊松回归模型的函数是 glm() 函数。

7.1 语法

在泊松回归中 glm() 函数的基本语法是

glm(formula,data,family)

以下是在上述功能中使用的参数的描述

• formula 是表示变量之间的关系的符号。
• data 是给出这些变量的值的数据集。
• family 是 R语言 对象来指定模型的细节。 它的值是 “泊松” 的逻辑回归。

7.2 例

我们有内置的数据集 “warpbreaks”，其描述了羊毛类型（A 或 B）和张力（低，中或高）对每个织机的经纱断裂数量的影响。 让我们考虑 “休息” 作为响应变量，它是休息次数的计数。 羊毛 “类型” 和 “张力” 作为预测变量。

7.3 输入数据

input <- warpbreaks
print(head(input))

当我们执行上面的代码，它产生以下结果

      breaks   wool  tension
1     26       A     L
2     30       A     L
3     54       A     L
4     25       A     L
5     70       A     L
6     52       A     L

7.4 创建回归模型

output <-glm(formula = breaks ~ wool+tension, 
                   data = warpbreaks, 
                 family = poisson)
print(summary(output))

当我们执行上面的代码，它产生以下结果

Call:
glm(formula = breaks ~ wool + tension, family = poisson, data = warpbreaks)

Deviance Residuals: 
    Min       1Q     Median       3Q      Max  
  -3.6871  -1.6503  -0.4269     1.1902   4.2616  

Coefficients:
            Estimate Std. Error z value Pr(>|z|)    
(Intercept)  3.69196    0.04541  81.302  < 2e-16 ***
woolB       -0.20599    0.05157  -3.994 6.49e-05 ***
tensionM    -0.32132    0.06027  -5.332 9.73e-08 ***
tensionH    -0.51849    0.06396  -8.107 5.21e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for poisson family taken to be 1)

    Null deviance: 297.37  on 53  degrees of freedom
Residual deviance: 210.39  on 50  degrees of freedom
AIC: 493.06

Number of Fisher Scoring iterations: 4

在摘要中，我们查找最后一列中的 p 值小于 0.05，以考虑预测变量对响应变量的影响。 如图所示，具有张力类型 M 和 H 的羊毛类型 B 对断裂计数有影响。

8. R语言 协方差分析

我们使用回归分析创建模型，描述变量在预测变量对响应变量的影响。 有时，如果我们有一个类别变量，如 Yes / No 或 Male / Female 等。简单的回归分析为分类变量的每个值提供多个结果。 在这种情况下，我们可以通过将分类变量与预测变量一起使用并比较分类变量的每个级别的回归线来研究分类变量的效果。 这样的分析被称为协方差分析，也称为 ANCOVA。

8.1 例

考虑在数据集 mtcars 中内置的 R语言。 在其中我们观察到字段 “am” 表示传输的类型（自动或手动）。 它是值为 0 和 1 的分类变量。汽车的每加仑英里数（mpg）也可以取决于马力（“hp”）的值。

我们研究 “am” 的值对 “mpg” 和 “hp” 之间回归的影响。 它是通过使用 aov() 函数，然后使用 anova() 函数来比较多个回归来完成的。

8.2 输入数据

从数据集 mtcars 创建一个包含字段 “mpg”，“hp” 和 “am” 的数据框。 这里我们取 “mpg” 作为响应变量，“hp” 作为预测变量，“am” 作为分类变量。

input <- mtcars[,c("am","mpg","hp")]
print(head(input))

当我们执行上面的代码，它产生以下结果

                   am   mpg   hp
Mazda RX4          1    21.0  110
Mazda RX4 Wag      1    21.0  110
Datsun 710         1    22.8   93
Hornet 4 Drive     0    21.4  110
Hornet Sportabout  0    18.7  175
Valiant            0    18.1  105

8.3 协方差分析

我们创建一个回归模型，以 “hp” 作为预测变量，“mpg” 作为响应变量，考虑 “am” 和 “hp” 之间的相互作用。

8.3.1 模型与分类变量和预测变量之间的相互作用

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp*am,data = input)
print(summary(result))

当我们执行上面的代码，它产生以下结果

            Df Sum Sq Mean Sq F value   Pr(>F)    
hp           1  678.4   678.4  77.391 1.50e-09 ***
am           1  202.2   202.2  23.072 4.75e-05 ***
hp:am        1    0.0     0.0   0.001    0.981    
Residuals   28  245.4     8.8                     
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

这个结果表明，马力和传输类型对每加仑的英里有显着的影响，因为两种情况下的 p 值都小于 0.05。 但是这两个变量之间的相互作用不显着，因为 p 值大于 0.05。

8.3.2 没有分类变量和预测变量之间相互作用的模型

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp+am,data = input)
print(summary(result))

当我们执行上面的代码，它产生以下结果

            Df  Sum Sq  Mean Sq   F value   Pr(>F)    
hp           1  678.4   678.4   80.15 7.63e-10 ***
am           1  202.2   202.2   23.89 3.46e-05 ***
Residuals   29  245.4     8.5                     
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

这个结果表明，马力和传输类型对每加仑的英里有显着的影响，因为两种情况下的 p 值都小于 0.05。

8.4 比较两个模型

现在我们可以比较两个模型来得出结论，变量的相互作用是否真正重要。 为此，我们使用 anova() 函数。

# Get the dataset.
input <- mtcars

# Create the regression models.
result1 <- aov(mpg~hp*am,data = input)
result2 <- aov(mpg~hp+am,data = input)

# Compare the two models.
print(anova(result1,result2))

当我们执行上面的代码，它产生以下结果

Model 1: mpg ~ hp * am
Model 2: mpg ~ hp + am
  Res.Df    RSS Df  Sum of Sq     F Pr(>F)
1     28 245.43                           
2     29 245.44 -1 -0.0052515 6e-04 0.9806

由于 p 值大于 0.05，我们得出结论，马力和传播类型之间的相互作用不显着。 因此，在汽车和手动变速器模式下，每加仑的里程将以类似的方式取决于汽车的马力。

9. R语言 时间序列分析

时间序列是一系列数据点，其中每个数据点与时间戳相关联。 一个简单的例子是股票在某一天的不同时间点的股票价格。 另一个例子是一个地区在一年中不同月份的降雨量。

R语言 使用许多函数来创建，操作和绘制时间序列数据。 时间序列的数据存储在称为时间序列对象的R对象中。 它也是一个 R语言 数据对象，如矢量或数据帧。

使用 ts() 函数创建时间序列对象。

9.1 语法

时间序列分析中 ts() 函数的基本语法是

timeseries.object.name <-  ts(data, start, end, frequency)

以下是所使用的参数的描述

• data 是包含在时间序列中使用的值的向量或矩阵。
• start 以时间序列指定第一次观察的开始时间。
• end 指定时间序列中最后一次观测的结束时间。
• frequency 指定每单位时间的观测数。

除了参数 “data”，所有其他参数是可选的。

9.2 例

考虑从 2012 年 1 月开始的一个地方的年降雨量细节。我们创建一个 R 时间序列对象为期 12 个月并绘制它。

# Get the data points in form of a R vector.
rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)

# Convert it to a time series object.
rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall.png")

# Plot a graph of the time series.
plot(rainfall.timeseries)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果及图表

Jan    Feb    Mar    Apr    May     Jun    Jul    Aug    Sep
2012  799.0  1174.8  865.1  1334.6  635.4  918.5  685.5  998.6  784.2
        Oct    Nov    Dec
2012  985.0  882.8 1071.0

时间序列图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-69cZVKuG-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-rainfall.png)]

9.3 不同的时间间隔

ts() 函数中的频率参数值决定了测量数据点的时间间隔。 值为 12 表示时间序列为 12 个月。 其他值及其含义如下

• 频率= 12 指定一年中每个月的数据点。
• 频率= 4 每年的每个季度的数据点。
• 频率= 6 每小时的 10 分钟的数据点。
• 频率= 24 * 6将一天的每 10 分钟的数据点固定。

9.4 多时间序列

我们可以通过将两个系列组合成一个矩阵，在一个图表中绘制多个时间序列。

# Get the data points in form of a R vector.
rainfall1 <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)
rainfall2 <- 
           c(655,1306.9,1323.4,1172.2,562.2,824,822.4,1265.5,799.6,1105.6,1106.7,1337.8)

# Convert them to a matrix.
combined.rainfall <-  matrix(c(rainfall1,rainfall2),nrow = 12)

# Convert it to a time series object.
rainfall.timeseries <- ts(combined.rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall_combined.png")

# Plot a graph of the time series.
plot(rainfall.timeseries, main = "Multiple Time Series")

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果及图表

           Series 1  Series 2
Jan 2012    799.0    655.0
Feb 2012   1174.8   1306.9
Mar 2012    865.1   1323.4
Apr 2012   1334.6   1172.2
May 2012    635.4    562.2
Jun 2012    918.5    824.0
Jul 2012    685.5    822.4
Aug 2012    998.6   1265.5
Sep 2012    784.2    799.6
Oct 2012    985.0   1105.6
Nov 2012    882.8   1106.7
Dec 2012   1071.0   1337.8

多时间序列图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bw8k4KQ2-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-rainfall-combined.png)]

10. R语言 非线性最小二乘

当模拟真实世界数据用于回归分析时，我们观察到，很少情况下，模型的方程是给出线性图的线性方程。大多数时候，真实世界数据模型的方程涉及更高程度的数学函数，如 3 的指数或 sin 函数。在这种情况下，模型的图给出了曲线而不是线。线性和非线性回归的目的是调整模型参数的值，以找到最接近您的数据的线或曲线。在找到这些值时，我们将能够以良好的精确度估计响应变量。

在最小二乘回归中，我们建立了一个回归模型，其中来自回归曲线的不同点的垂直距离的平方和被最小化。我们通常从定义的模型开始，并假设系数的一些值。然后我们应用 R语言 的 nls() 函数获得更准确的值以及置信区间。

10.1 语法

在 R语言 中创建非线性最小二乘测试的基本语法是

nls(formula, data, start)

以下是所使用的参数的描述

• formula 是包括变量和参数的非线性模型公式。
• data 是用于计算公式中变量的数据框。
• start 是起始估计的命名列表或命名数字向量。

10.2 例

我们将考虑一个假设其系数的初始值的非线性模型。 接下来，我们将看到这些假设值的置信区间是什么，以便我们可以判断这些值在模型中有多好。

所以让我们考虑下面的方程为这个目的

a = b1*x^2+b2

让我们假设初始系数为 1 和 3，并将这些值拟合到 nls() 函数中。

xvalues <- c(1.6,2.1,2,2.23,3.71,3.25,3.4,3.86,1.19,2.21)
yvalues <- c(5.19,7.43,6.94,8.11,18.75,14.88,16.06,19.12,3.21,7.58)

# Give the chart file a name.
png(file = "nls.png")


# Plot these values.
plot(xvalues,yvalues)


# Take the assumed values and fit into the model.
model <- nls(yvalues ~ b1*xvalues^2+b2,start = list(b1 = 1,b2 = 3))

# Plot the chart with new data by fitting it to a prediction from 100 data points.
new.data <- data.frame(xvalues = seq(min(xvalues),max(xvalues),len = 100))
lines(new.data$xvalues,predict(model,newdata = new.data))

# Save the file.
dev.off()

# Get the sum of the squared residuals.
print(sum(resid(model)^2))

# Get the confidence intervals on the chosen values of the coefficients.
print(confint(model))

当我们执行上面的代码，它产生以下结果

[1] 1.081935
Waiting for profiling to be done...
       2.5%    97.5%
b1 1.137708 1.253135
b2 1.497364 2.496484

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M09NEqHP-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-nls.png)]

我们可以得出结论，b1 的值更接近 1，而 b2 的值更接近 2 而不是 3。

11. R语言 决策树

决策树是以树的形式表示选择及其结果的图。图中的节点表示事件或选择，并且图的边缘表示决策规则或条件。它主要用于使用R的机器学习和数据挖掘应用程序。

决策树的使用的例子是 - 预测电子邮件是垃圾邮件或非垃圾邮件，预测肿瘤癌变，或者基于这些因素预测贷款的信用风险。通常，使用观测数据（也称为训练数据）来创建模型。然后使用一组验证数据来验证和改进模型。 R 具有用于创建和可视化决策树的包。对于新的预测变量集合，我们使用此模型来确定 R 包 “party” 用于创建决策树。

11.1 安装 R语言 包

在 R语言 控制台中使用以下命令安装软件包。您还必须安装相关软件包（如果有）。

install.packages("party")

“party” 包具有用于创建和分析决策树的函数 ctree()。

11.2 语法

在 R 中创建决策树的基本语法是

ctree(formula, data)

以下是所使用的参数的描述

• formula 是描述预测变量和响应变量的公式。
• data 是所使用的数据集的名称。

11.3 输入数据

我们将使用名为 readingSkills 的 R 内置数据集来创建决策树。 它描述了某人的 readingSkills 的分数，如果我们知道变量 “年龄”，“shoesize”，“分数”，以及该人是否为母语者。

这里是示例数据。

# Load the party package. It will automatically load other dependent packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

当我们执行上面的代码，它产生以下结果及图表

  nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

11.4 例

我们将使用 ctree() 函数创建决策树并查看其图形。

# Load the party package. It will automatically load other dependent packages.
library(party)

# Create the input data frame.
input.dat <- readingSkills[c(1:105),]

# Give the chart file a name.
png(file = "decision_tree.png")

# Create the tree.
  output.tree <- ctree(
  nativeSpeaker ~ age + shoeSize + score, 
  data = input.dat)

# Plot the tree.
plot(output.tree)

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果

null device 
          1 
Loading required package: methods
Loading required package: grid
Loading required package: mvtnorm
Loading required package: modeltools
Loading required package: stats4
Loading required package: strucchange
Loading required package: zoo

Attaching package: ‘zoo’

The following objects are masked from ‘package:base’:

    as.Date, as.Date.numeric

Loading required package: sandwich

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dMGgjusa-1670571435898)(http://p8cg9782i.bkt.clouddn.com/R-decision-tree.png)]

11.5 结论

从上面显示的决策树，我们可以得出结论，其 readingSkills 分数低于 38.3 和年龄超过 6 的人不是一个母语者。

12. R语言 随机森林算法

在随机森林方法中，创建大量的决策树。 每个观察被馈入每个决策树。 每个观察的最常见的结果被用作最终输出。 新的观察结果被馈入所有的树并且对每个分类模型取多数投票。

对构建树时未使用的情况进行错误估计。 这称为 OOB（袋外）误差估计，其被提及为百分比。

R语言 包 “randomForest” 用于创建随机森林。

12.1 安装 R 包

在 R语言 控制台中使用以下命令安装软件包。 您还必须安装相关软件包（如果有）。

install.packages("randomForest)

包 “randomForest” 具有函数 randomForest()，用于创建和分析随机森林。

12.2 语法

在 R语言 中创建随机森林的基本语法是

randomForest(formula, data)

以下是所使用的参数的描述

• formula 是描述预测变量和响应变量的公式。
• data 是所使用的数据集的名称。

12.3 输入数据

我们将使用名为 readingSkills 的 R语言 内置数据集来创建决策树。 它描述了某人的 readingSkills 的分数，如果我们知道变量 “age”，“shoesize”，“score”，以及该人是否是母语。

以下是示例数据。

# Load the party package. It will automatically load other required packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

当我们执行上面的代码，它产生以下结果及图表

  nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

12.4 例

我们将使用 randomForest() 函数来创建决策树并查看它的图。

# Load the party package. It will automatically load other required packages.
library(party)
library(randomForest)

# Create the forest.
output.forest <- randomForest(nativeSpeaker ~ age + shoeSize + score, 
           data = readingSkills)

# View the forest results.
print(output.forest) 

# Importance of each predictor.
print(importance(fit,type = 2)) 

当我们执行上面的代码，它产生以下结果

Call:
 randomForest(formula = nativeSpeaker ~ age + shoeSize + score,     
                 data = readingSkills)
               Type of random forest: classification
                     Number of trees: 500
No. of variables tried at each split: 1

        OOB estimate of  error rate: 1%
Confusion matrix:
    no yes class.error
no  99   1        0.01
yes  1  99        0.01
         MeanDecreaseGini
age              13.95406
shoeSize         18.91006
score            56.73051

12.5 结论

从上面显示的随机森林，我们可以得出结论，鞋码和成绩是决定如果某人是母语者或不是母语的重要因素。 此外，该模型只有 1% 的误差，这意味着我们可以预测精度为 99%。

13. R语言 生存分析

生存分析处理预测特定事件将要发生的时间。 它也被称为故障时间分析或分析死亡时间。 例如，预测患有癌症的人将存活的天数或预测机械系统将失败的时间。

命名为 survival 的 R语言 包用于进行生存分析。 此包包含函数 Surv()，它将输入数据作为 R语言 公式，并在选择的变量中创建一个生存对象用于分析。 然后我们使用函数 survfit() 创建一个分析图。

13.1 安装软件包

install.packages("survival")

13.2 语法

在 R语言 中创建生存分析的基本语法是

Surv(time,event)
survfit(formula)

以下是所使用的参数的描述

• time 是直到事件发生的跟踪时间。
• event 指示预期事件的发生的状态。
• formula 是预测变量之间的关系。

13.3 例

我们将考虑在上面安装的生存包中存在的名为 “pbc” 的数据集。 它描述了关于受肝原发性胆汁性肝硬化（PBC）影响的人的生存数据点。 在数据集中存在的许多列中，我们主要关注字段 “time” 和 “status”。 时间表示在接受肝移植或患者死亡的患者的登记和事件的较早之间的天数。

# Load the library.
library("survival")

# Print first few rows.
print(head(pbc))

当我们执行上面的代码，它产生以下结果及图表

  id time status trt      age sex ascites hepato spiders edema bili chol
1  1  400      2   1 58.76523   f       1      1       1   1.0 14.5  261
2  2 4500      0   1 56.44627   f       0      1       1   0.0  1.1  302
3  3 1012      2   1 70.07255   m       0      0       0   0.5  1.4  176
4  4 1925      2   1 54.74059   f       0      1       1   0.5  1.8  244
5  5 1504      1   2 38.10541   f       0      1       1   0.0  3.4  279
6  6 2503      2   2 66.25873   f       0      1       0   0.0  0.8  248
  albumin copper alk.phos    ast trig platelet protime stage
1    2.60    156   1718.0 137.95  172      190    12.2     4
2    4.14     54   7394.8 113.52   88      221    10.6     3
3    3.48    210    516.0  96.10   55      151    12.0     4
4    2.54     64   6121.8  60.63   92      183    10.3     4
5    3.53    143    671.0 113.15   72      136    10.9     3
6    3.98     50    944.0  93.00   63       NA    11.0     3

从上述数据，我们正在考虑分析的时间和状态。

13.4 应用 Surv() 和 survfit() 函数

现在我们继续应用 Surv() 函数到上面的数据集，并创建一个将显示趋势图。

# Load the library.
library("survival")

# Create the survival object. 
survfit(Surv(pbc$time,pbc$status == 2)~1)

# Give the chart file a name.
png(file = "survival.png")

# Plot the graph. 
plot(survfit(Surv(pbc$time,pbc$status == 2)~1))

# Save the file.
dev.off()

当我们执行上面的代码，它产生以下结果及图表

Call: survfit(formula = Surv(pbc$time, pbc$status == 2) ~ 1)

      n  events  median 0.95LCL 0.95UCL 
    418     161    3395    3090    3853 

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LUt1h6jn-1670571435899)(http://p8cg9782i.bkt.clouddn.com/R-survival.png)]

上图中的趋势有助于我们预测在特定天数结束时的生存概率。

14. R语言 卡方检验

卡方检验是一种确定两个分类变量之间是否存在显着相关性的统计方法。 这两个变量应该来自相同的人口，他们应该是类似 - 是/否，男/女，红/绿等。

例如，我们可以建立一个观察人们的冰淇淋购买模式的数据集，并尝试将一个人的性别与他们喜欢的冰淇淋的味道相关联。 如果发现相关性，我们可以通过了解访问的人的性别的数量来计划适当的味道库存。

14.1 语法

用于执行卡方检验的函数是 chisq.test()。

在 R语言 中创建卡方检验的基本语法是

chisq.test(data)

以下是所使用的参数的描述

• data 是以包含观察中变量的计数值的表的形式的数据。

14.2 例

我们将在 “MASS” 图书馆中获取 Cars93 数据，该图书馆代表 1993 年不同型号汽车的销售额。

library("MASS")
print(str(Cars93))

当我们执行上面的代码，它产生以下结果

'data.frame':   93 obs. of  27 variables: 
 $ Manufacturer      : Factor w/ 32 levels "Acura","Audi",..: 1 1 2 2 3 4 4 4 4 5 ... 
 $ Model             : Factor w/ 93 levels "100","190E","240",..: 49 56 9 1 6 24 54 74 73 35 ... 
 $ Type              : Factor w/ 6 levels "Compact","Large",..: 4 3 1 3 3 3 2 2 3 2 ... 
 $ Min.Price         : num  12.9 29.2 25.9 30.8 23.7 14.2 19.9 22.6 26.3 33 ... 
 $ Price             : num  15.9 33.9 29.1 37.7 30 15.7 20.8 23.7 26.3 34.7 ... 
 $ Max.Price         : num  18.8 38.7 32.3 44.6 36.2 17.3 21.7 24.9 26.3 36.3 ... 
 $ MPG.city          : int  25 18 20 19 22 22 19 16 19 16 ... 
 $ MPG.highway       : int  31 25 26 26 30 31 28 25 27 25 ... 
 $ AirBags           : Factor w/ 3 levels "Driver & Passenger",..: 3 1 2 1 2 2 2 2 2 2 ... 
 $ DriveTrain        : Factor w/ 3 levels "4WD","Front",..: 2 2 2 2 3 2 2 3 2 2 ... 
 $ Cylinders         : Factor w/ 6 levels "3","4","5","6",..: 2 4 4 4 2 2 4 4 4 5 ... 
 $ EngineSize        : num  1.8 3.2 2.8 2.8 3.5 2.2 3.8 5.7 3.8 4.9 ... 
 $ Horsepower        : int  140 200 172 172 208 110 170 180 170 200 ... 
 $ RPM               : int  6300 5500 5500 5500 5700 5200 4800 4000 4800 4100 ... 
 $ Rev.per.mile      : int  2890 2335 2280 2535 2545 2565 1570 1320 1690 1510 ... 
 $ Man.trans.avail   : Factor w/ 2 levels "No","Yes": 2 2 2 2 2 1 1 1 1 1 ... 
 $ Fuel.tank.capacity: num  13.2 18 16.9 21.1 21.1 16.4 18 23 18.8 18 ... 
 $ Passengers        : int  5 5 5 6 4 6 6 6 5 6 ... 
 $ Length            : int  177 195 180 193 186 189 200 216 198 206 ... 
 $ Wheelbase         : int  102 115 102 106 109 105 111 116 108 114 ... 
 $ Width             : int  68 71 67 70 69 69 74 78 73 73 ... 
 $ Turn.circle       : int  37 38 37 37 39 41 42 45 41 43 ... 
 $ Rear.seat.room    : num  26.5 30 28 31 27 28 30.5 30.5 26.5 35 ... 
 $ Luggage.room      : int  11 15 14 17 13 16 17 21 14 18 ... 
 $ Weight            : int  2705 3560 3375 3405 3640 2880 3470 4105 3495 3620 ... 
 $ Origin            : Factor w/ 2 levels "USA","non-USA": 2 2 2 2 2 1 1 1 1 1 ... 
 $ Make              : Factor w/ 93 levels "Acura Integra",..: 1 2 4 3 5 6 7 9 8 10 ... 

上述结果表明数据集有很多因素变量，可以被认为是分类变量。 对于我们的模型，我们将考虑变量 “AirBags” 和 “Type”。 在这里，我们的目标是找出所售的汽车类型和安全气囊类型之间的任何显着的相关性。 如果观察到相关性，我们可以估计哪种类型的汽车可以更好地卖什么类型的气囊。

# Load the library.
library("MASS")

# Create a data frame from the main data set.
car.data <- data.frame(Cars93$AirBags, Cars93$Type)

# Create a table with the needed variables.
car.data = table(Cars93$AirBags, Cars93$Type) 
print(car.data)

# Perform the Chi-Square test.
print(chisq.test(car.data))

当我们执行上面的代码，它产生以下结果

                     Compact Large Midsize Small Sporty Van
  Driver & Passenger       2     4       7     0      3   0
  Driver only              9     7      11     5      8   3
  None                     5     0       4    16      3   6

        Pearson's Chi-squared test

data:  car.data
X-squared = 33.001, df = 10, p-value = 0.0002723

Warning message:
In chisq.test(car.data) : Chi-squared approximation may be incorrect

14.3 结论

结果显示 p 值小于 0.05，这表明字符串相关。