- R 教程
- R - 首页
- R - 概述
- R - 环境设置
- R - 基本语法
- R - 数据类型
- R - 变量
- R - 运算符
- R - 决策
- R - 循环
- R - 函数
- R - 字符串
- R - 向量
- R - 列表
- R - 矩阵
- R - 数组
- R - 因子
- R - 数据框
- R - 包
- R - 数据重塑
R - 快速指南
R - 概述
R 是一种用于统计分析、图形表示和报告的编程语言和软件环境。R 由新西兰奥克兰大学的 Ross Ihaka 和 Robert Gentleman 创建，目前由 R 开发核心团队开发。
R 的核心是一种解释型计算机语言，它允许分支和循环，以及使用函数进行模块化编程。为了提高效率，R 允许与用 C、C++、.Net、Python 或 FORTRAN 语言编写的过程集成。
R 在 GNU 通用公共许可证下免费提供，并且为各种操作系统（如 Linux、Windows 和 Mac）提供了预编译的二进制版本。
R 是在 GNU 风格的版权声明下分发的自由软件，并且是称为GNU S的 GNU 项目的正式组成部分。
R 的发展历程
R 最初由新西兰奥克兰大学统计系Ross Ihaka和Robert Gentleman编写。R 于 1993 年首次出现。
一大批个人通过发送代码和错误报告为 R 做出了贡献。
自 1997 年年中以来，一直有一个核心小组（“R 核心团队”）可以修改 R 源代码档案。
R 的特点
如前所述，R 是一种用于统计分析、图形表示和报告的编程语言和软件环境。以下是 R 的重要特性：
R 是一种完善的、简单有效的编程语言，包括条件语句、循环语句、用户定义的递归函数以及输入输出功能。
R 具有有效的数据处理和存储功能。
R 提供了一套用于对数组、列表、向量和矩阵进行计算的运算符。
R 提供了大量连贯且集成的用于数据分析的工具。
R 提供了用于数据分析和显示的图形功能，可以直接在计算机上显示或打印到纸张上。
总之，R 是世界上使用最广泛的统计编程语言。它是数据科学家的首选，并得到一个充满活力且才华横溢的贡献者社区的支持。R 在大学中教授，并部署在关键业务应用程序中。本教程将通过简单易懂的步骤，结合合适的示例，教你学习 R 编程。
R - 环境设置
本地环境设置
如果你仍然希望为 R 设置你的环境，你可以按照以下步骤操作。
Windows 安装
你可以从R-3.2.2 for Windows (32/64 bit)下载 R 的 Windows 安装程序版本，并将其保存到本地目录中。
因为它是一个名为“R-version-win.exe”的 Windows 安装程序 (.exe)。你可以双击并运行安装程序，接受默认设置。如果你的 Windows 是 32 位版本，它将安装 32 位版本。但如果你的 Windows 是 64 位版本，则它将安装 32 位和 64 位版本。
安装后，你可以在 Windows 程序文件下的“R\R3.2.2\bin\i386\Rgui.exe”目录结构中找到运行程序的图标。单击此图标将显示 R-GUI，它是用于执行 R 编程的 R 控制台。
Linux 安装
R 可作为许多 Linux 版本的二进制文件，位于R 二进制文件。
安装 Linux 的说明因发行版而异。这些步骤在上述链接中每个类型的 Linux 版本下都有说明。但是，如果你很着急，可以使用yum命令安装 R，如下所示：
$ yum install R
以上命令将安装 R 编程的核心功能以及标准包，如果你仍然需要其他包，则可以启动 R 提示符，如下所示：
$ R R version 3.2.0 (2015-04-16) -- "Full of Ingredients" Copyright (C) 2015 The R Foundation for Statistical Computing Platform: x86_64-redhat-linux-gnu (64-bit) R is free software and comes with ABSOLUTELY NO WARRANTY. You are welcome to redistribute it under certain conditions. Type 'license()' or 'licence()' for distribution details. R is a collaborative project with many contributors. Type 'contributors()' for more information and 'citation()' on how to cite R or R packages in publications. Type 'demo()' for some demos, 'help()' for on-line help, or 'help.start()' for an HTML browser interface to help. Type 'q()' to quit R. >
现在，你可以在 R 提示符下使用 install 命令安装所需的包。例如，以下命令将安装plotrix包，该包是 3D 图表所需的。
> install.packages("plotrix")
R - 基本语法
按照惯例，我们将通过编写一个“Hello, World！”程序开始学习 R 编程。根据需要，你可以在 R 命令提示符下编程，也可以使用 R 脚本文件编写程序。让我们逐一检查两者。
R 命令提示符
一旦你设置了 R 环境，只需在你的命令提示符下键入以下命令即可轻松启动 R 命令提示符：
$ R
这将启动 R 解释器，你将获得一个提示符>，你可以在其中开始键入程序，如下所示：
> myString <- "Hello, World!" > print ( myString) [1] "Hello, World!"
这里第一条语句定义了一个字符串变量 myString，我们为其赋值一个字符串“Hello, World！”，然后下一条语句 print() 用于打印存储在变量 myString 中的值。
R 脚本文件
通常，你将通过在脚本文件中编写程序来进行编程，然后在命令提示符下使用称为Rscript的 R 解释器执行这些脚本。因此，让我们从在名为 test.R 的文本文件中编写以下代码开始：
# My first program in R Programming myString <- "Hello, World!" print ( myString)
将以上代码保存到文件 test.R 中，并在 Linux 命令提示符下执行，如下所示。即使你使用 Windows 或其他系统，语法也将保持不变。
$ Rscript test.R
当我们运行以上程序时，它会产生以下结果。
[1] "Hello, World!"
注释
注释就像 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)
[1] "Hello, World!"
虽然以上注释将由 R 解释器执行，但它们不会干扰你的实际程序。你应该将此类注释放在单引号或双引号内。
R - 数据类型
通常，在任何编程语言中进行编程时，都需要使用各种变量来存储各种信息。变量只不过是保留的内存位置，用于存储值。这意味着，当你创建变量时，会在内存中保留一些空间。
你可能希望存储各种数据类型的信息，如字符、宽字符、整数、浮点数、双精度浮点数、布尔值等。根据变量的数据类型，操作系统会分配内存并决定在保留的内存中可以存储什么。
与其他编程语言（如 C 和 Java）不同，在 R 中，变量不会被声明为某种数据类型。变量被赋予 R 对象，R 对象的数据类型成为变量的数据类型。R 对象有很多类型。常用的有：
- 向量
- 列表
- 矩阵
- 数组
- 因子
- 数据框
其中最简单的对象是向量对象，这些原子向量有六种数据类型，也称为六类向量。其他 R 对象是建立在原子向量之上的。
| 数据类型 | 示例 | 验证 |
|---|---|---|
| 逻辑型 | TRUE, FALSE |
v <- TRUE print(class(v)) 它会产生以下结果： [1] "logical" |
| 数值型 | 12.3, 5, 999 |
v <- 23.5 print(class(v)) 它会产生以下结果： [1] "numeric" |
| 整数型 | 2L, 34L, 0L |
v <- 2L print(class(v)) 它会产生以下结果： [1] "integer" |
| 复数型 | 3 + 2i |
v <- 2+5i print(class(v)) 它会产生以下结果： [1] "complex" |
| 字符型 | 'a' , '"good", "TRUE", '23.4' |
v <- "TRUE" print(class(v)) 它会产生以下结果： [1] "character" |
| 原始型 | "Hello" 存储为 48 65 6c 6c 6f |
v <- charToRaw("Hello")
print(class(v))
它会产生以下结果： [1] "raw" |
在 R 编程中，最基本的数据类型是称为向量的 R 对象，它可以保存不同类别的元素，如上所示。请注意，在 R 中，类别的数量不仅限于以上六种类型。例如，我们可以使用许多原子向量并创建一个数组，其类别将成为数组。
向量
当你想创建一个包含多个元素的向量时，应该使用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"
列表
列表是 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")
矩阵
矩阵是一个二维的矩形数据集。它可以使用向量输入到矩阵函数中创建。
# 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"
数组
虽然矩阵仅限于两个维度，但数组可以是任意数量的维度。array 函数采用一个 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"
因子
因子是使用向量创建的 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 green Levels: green red yellow [1] 3
数据框
数据框是表格数据对象。与矩阵不同，在数据框中，每一列可以包含不同的数据模式。第一列可以是数值型，而第二列可以是字符型，第三列可以是逻辑型。它是一个长度相等的向量的列表。
数据框使用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
R - 变量
变量为我们的程序提供了可操作的命名存储。R中的变量可以存储原子向量、原子向量的组或许多R对象的组合。有效的变量名由字母、数字以及点或下划线字符组成。变量名以字母或点开头，后面不跟着数字。
| 变量名 | 有效性 | 原因 |
|---|---|---|
| var_name2. | 有效 | 包含字母、数字、点和下划线 |
| var_name% | 无效 | 包含字符'%'。仅允许点(.)和下划线。 |
| 2var_name | 无效 | 以数字开头 |
.var_name, var.name |
有效 | 可以以点(.)开头，但点(.)后面不能跟着数字。 |
| .2var_name | 无效 | 起始点后跟着数字，使其无效。 |
| _var_name | 无效 | 以_开头，无效 |
变量赋值
可以使用左向、右向和等于运算符为变量赋值。可以使用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 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")
当我们执行以上代码时，它会产生以下结果：
[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。
变量的数据类型
在R中，变量本身没有声明任何数据类型，而是获取分配给它的R对象的类型。因此R被称为动态类型语言，这意味着我们可以在程序中使用同一个变量时，反复更改变量的数据类型。
var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"\n")
var_x <- 34.5
cat(" Now the class of var_x is ",class(var_x),"\n")
var_x <- 27L
cat(" Next the class of var_x becomes ",class(var_x),"\n")
当我们执行以上代码时，它会产生以下结果：
The class of var_x is character
Now the class of var_x is numeric
Next the class of var_x becomes integer
查找变量
要了解当前工作空间中所有可用的变量，我们使用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"
以点(.)开头的变量是隐藏的，可以使用"all.names = TRUE"参数传递给ls()函数来列出它们。
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"
删除变量
可以使用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)
R - 运算符
运算符是告诉编译器执行特定数学或逻辑操作的符号。R语言富含内置运算符，并提供以下类型的运算符。
运算符类型
R编程中包含以下类型的运算符：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 赋值运算符
- 其他运算符
算术运算符
下表显示了R语言支持的算术运算符。运算符作用于向量的每个元素。
| 运算符 | 描述 | 示例 |
|---|---|---|
| + | 将两个向量相加 |
v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v+t) 它会产生以下结果： [1] 10.0 8.5 10.0 |
| − | 从第一个向量中减去第二个向量 |
v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v-t) 它会产生以下结果： [1] -6.0 2.5 2.0 |
| * | 将两个向量相乘 |
v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v*t) 它会产生以下结果： [1] 16.0 16.5 24.0 |
| / | 将第一个向量除以第二个向量 |
v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v/t) 当我们执行以上代码时，它会产生以下结果： [1] 0.250000 1.833333 1.500000 |
| %% | 第一个向量除以第二个向量的余数 |
v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v%%t) 它会产生以下结果： [1] 2.0 2.5 2.0 |
| %/% | 第一个向量除以第二个向量的结果（商） |
v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v%/%t) 它会产生以下结果： [1] 0 1 1 |
| ^ | 第一个向量以第二个向量为指数的幂 |
v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v^t) 它会产生以下结果： [1] 256.000 166.375 1296.000 |
关系运算符
下表显示了R语言支持的关系运算符。第一个向量的每个元素都与第二个向量的对应元素进行比较。比较结果为布尔值。
| 运算符 | 描述 | 示例 |
|---|---|---|
| > | 检查第一个向量的每个元素是否大于第二个向量的对应元素。 |
v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v>t) 它会产生以下结果： [1] FALSE TRUE FALSE FALSE |
| < | 检查第一个向量的每个元素是否小于第二个向量的对应元素。 |
v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v < t) 它会产生以下结果： [1] TRUE FALSE TRUE FALSE |
| == | 检查第一个向量的每个元素是否等于第二个向量的对应元素。 |
v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v == t) 它会产生以下结果： [1] FALSE FALSE FALSE TRUE |
| <= | 检查第一个向量的每个元素是否小于或等于第二个向量的对应元素。 |
v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v<=t) 它会产生以下结果： [1] TRUE FALSE TRUE TRUE |
| >= | 检查第一个向量的每个元素是否大于或等于第二个向量的对应元素。 |
v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v>=t) 它会产生以下结果： [1] FALSE TRUE FALSE TRUE |
| != | 检查第一个向量的每个元素是否不等于第二个向量的对应元素。 |
v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v!=t) 它会产生以下结果： [1] TRUE TRUE TRUE FALSE |
逻辑运算符
下表显示了R语言支持的逻辑运算符。它仅适用于逻辑、数值或复数类型的向量。所有大于1的数字都被视为逻辑值TRUE。
第一个向量的每个元素都与第二个向量的对应元素进行比较。比较结果为布尔值。
| 运算符 | 描述 | 示例 |
|---|---|---|
| & | 称为逐元素逻辑与运算符。它将第一个向量的每个元素与第二个向量的对应元素组合，如果两个元素都为TRUE，则输出TRUE。 |
v <- c(3,1,TRUE,2+3i) t <- c(4,1,FALSE,2+3i) print(v&t) 它会产生以下结果： [1] TRUE TRUE FALSE TRUE |
| | | 称为逐元素逻辑或运算符。它将第一个向量的每个元素与第二个向量的对应元素组合，如果其中一个元素为TRUE，则输出TRUE。 |
v <- c(3,0,TRUE,2+2i) t <- c(4,0,FALSE,2+3i) print(v|t) 它会产生以下结果： [1] TRUE FALSE TRUE TRUE |
| ! | 称为逻辑非运算符。获取向量的每个元素并给出相反的逻辑值。 |
v <- c(3,0,TRUE,2+2i) print(!v) 它会产生以下结果： [1] FALSE TRUE FALSE FALSE |
逻辑运算符&&和||仅考虑向量的第一个元素，并输出单个元素的向量。
| 运算符 | 描述 | 示例 |
|---|---|---|
| && | 称为逻辑与运算符。获取两个向量的第一个元素，并且只有当两者都为TRUE时才输出TRUE。 |
v <- c(3,0,TRUE,2+2i) t <- c(1,3,TRUE,2+3i) print(v&&t) 它会产生以下结果： [1] TRUE |
| || | 称为逻辑或运算符。获取两个向量的第一个元素，如果其中一个为TRUE，则输出TRUE。 |
v <- c(0,0,TRUE,2+2i) t <- c(0,3,TRUE,2+3i) print(v||t) 它会产生以下结果： [1] FALSE |
赋值运算符
这些运算符用于为向量赋值。
| 运算符 | 描述 | 示例 |
|---|---|---|
|
<− 或 = 或 <<− |
称为左赋值 |
v1 <- c(3,1,TRUE,2+3i) v2 <<- c(3,1,TRUE,2+3i) v3 = c(3,1,TRUE,2+3i) print(v1) print(v2) print(v3) 它会产生以下结果： [1] 3+0i 1+0i 1+0i 2+3i [1] 3+0i 1+0i 1+0i 2+3i [1] 3+0i 1+0i 1+0i 2+3i |
|
-> 或 ->> |
称为右赋值 |
c(3,1,TRUE,2+3i) -> v1 c(3,1,TRUE,2+3i) ->> v2 print(v1) print(v2) 它会产生以下结果： [1] 3+0i 1+0i 1+0i 2+3i [1] 3+0i 1+0i 1+0i 2+3i |
其他运算符
这些运算符用于特定目的，而不是一般的数学或逻辑计算。
| 运算符 | 描述 | 示例 |
|---|---|---|
| : | 冒号运算符。它为向量创建一系列按顺序排列的数字。 |
v <- 2:8 print(v) 它会产生以下结果： [1] 2 3 4 5 6 7 8 |
| %in% | 此运算符用于识别元素是否属于向量。 |
v1 <- 8 v2 <- 12 t <- 1:10 print(v1 %in% t) print(v2 %in% t) 它会产生以下结果： [1] TRUE [1] FALSE |
| %*% | 此运算符用于将矩阵与其转置相乘。 |
M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE) t = M %*% t(M) print(t) 它会产生以下结果： [,1] [,2] [1,] 65 82 [2,] 82 117 |
R - 决策
决策结构要求程序员指定一个或多个条件供程序评估或测试，以及如果条件确定为true则要执行的语句，以及可选地，如果条件确定为false则要执行的其他语句。
以下是大多数编程语言中常见决策结构的一般形式：
R提供以下类型的决策语句。单击以下链接以查看其详细信息。
| 序号 | 语句和描述 |
|---|---|
| 1 |
if语句
if语句由一个布尔表达式后跟一个或多个语句组成。 |
| 2 |
if...else语句
if语句后可以跟一个可选的else语句，当布尔表达式为false时执行。 |
| 3 |
switch语句
switch语句允许将变量与其值列表进行相等性测试。 |
R - 循环
可能存在需要多次执行代码块的情况。通常，语句按顺序执行。函数中的第一个语句首先执行，然后是第二个语句，依此类推。
编程语言提供各种控制结构，允许更复杂的执行路径。
循环语句允许我们将语句或语句组执行多次，以下是在大多数编程语言中循环语句的一般形式：
R编程语言提供以下几种循环来处理循环需求。单击以下链接以查看其详细信息。
| 序号 | 循环类型和描述 |
|---|---|
| 1 |
repeat循环
多次执行一系列语句，并缩写管理循环变量的代码。 |
| 2 |
while循环
当给定条件为true时重复语句或语句组。它在执行循环体之前测试条件。 |
| 3 |
for循环
类似于while语句，只是它在循环体结束时测试条件。 |
循环控制语句
循环控制语句更改执行的正常顺序。当执行离开作用域时，在该作用域中创建的所有自动对象都会被销毁。
R支持以下控制语句。单击以下链接以查看其详细信息。
R - 函数
函数是一组组织在一起以执行特定任务的语句。R有大量内置函数，用户可以创建自己的函数。
在R中，函数是一个对象，因此R解释器能够将控制权传递给函数，以及函数完成操作可能需要的参数。
然后，函数执行其任务并将控制权以及任何可能存储在其他对象中的结果返回给解释器。
函数定义
R函数是使用关键字function创建的。R函数定义的基本语法如下：
function_name <- function(arg_1, arg_2, ...) {
Function body
}
函数组件
函数的不同部分是：
函数名 - 这是函数的实际名称。它作为具有此名称的对象存储在R环境中。
参数 - 参数是一个占位符。当调用函数时，您将值传递给参数。参数是可选的；也就是说，函数可能不包含任何参数。参数也可以具有默认值。
函数体 - 函数体包含定义函数功能的一系列语句。
返回值 - 函数的返回值是函数体中最后一个要计算的表达式。
R有很多内置函数，可以在程序中直接调用，而无需先定义它们。我们还可以创建和使用我们自己的函数，称为用户定义函数。
内置函数
内置函数的简单示例有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
用户定义函数
我们可以在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)
}
}
调用函数
# 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
无参数调用函数
# 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
带参数值调用函数（按位置和按名称）
函数调用的参数可以按函数中定义的相同顺序提供，也可以按不同的顺序提供，但分配给参数的名称。
# 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
使用默认参数调用函数
我们可以在函数定义中定义参数的值，并在调用函数时不提供任何参数来获取默认结果。但是我们也可以通过提供参数的新值来调用此类函数并获取非默认结果。
# 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
函数的惰性求值
函数的参数是惰性求值的，这意味着它们仅在函数体需要时才进行求值。
# 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
R - 字符串
在 R 中，任何用单引号或双引号括起来的值都被视为字符串。在内部，即使您使用单引号创建字符串，R 也会将每个字符串存储在双引号中。
字符串构造规则
字符串开头和结尾的引号必须都是双引号或都是单引号。它们不能混合使用。
双引号可以插入到以单引号开头和结尾的字符串中。
单引号可以插入到以双引号开头和结尾的字符串中。
双引号不能插入到以双引号开头和结尾的字符串中。
单引号不能插入到以单引号开头和结尾的字符串中。
有效字符串示例
以下示例阐明了在 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"
无效字符串示例
e <- 'Mixed quotes" print(e) f <- 'Single quote ' inside single quote' print(f) g <- "Double quotes " inside double quotes" print(g)
当我们运行脚本时，它会失败并给出以下结果。
Error: unexpected symbol in: "print(e) f <- 'Single" Execution halted
字符串操作
连接字符串 - paste() 函数
R 中的许多字符串都是使用 **paste()** 函数组合在一起的。它可以接受任意数量的参数，并将它们组合在一起。
语法
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? "
格式化数字和字符串 - format() 函数
可以使用 **format()** 函数将数字和字符串格式化为特定样式。
语法
format 函数的基本语法如下：
format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))
以下是所用参数的描述：
**x** 是向量输入。
**digits** 是显示的数字总数。
**nsmall** 是小数点右侧的最小位数。
**scientific** 设置为 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 "
计算字符串中字符的数量 - nchar() 函数
此函数计算字符串中字符的数量，包括空格。
语法
nchar() 函数的基本语法如下：
nchar(x)
以下是所用参数的描述：
**x** 是向量输入。
示例
result <- nchar("Count the number of characters")
print(result)
当我们执行以上代码时，它会产生以下结果：
[1] 30
更改大小写 - 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"
提取字符串的部分 - substring() 函数
此函数提取字符串的部分。
语法
substring() 函数的基本语法如下：
substring(x,first,last)
以下是所用参数的描述：
**x** 是字符向量输入。
**first** 是要提取的第一个字符的位置。
**last** 是要提取的最后一个字符的位置。
示例
# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)
当我们执行以上代码时，它会产生以下结果：
[1] "act"
R - 向量
向量是 R 中最基本的数据对象，共有六种原子向量类型。它们分别是逻辑型、整型、双精度型、复数型、字符型和原始型。
向量创建
单元素向量
即使您在 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
多元素向量
对数值数据使用冒号运算符
# 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
使用序列 (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
使用 c() 函数
如果元素之一是字符，则非字符值将强制转换为字符类型。
# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)
当我们执行以上代码时，它会产生以下结果：
[1] "apple" "red" "5" "TRUE"
访问向量元素
使用索引访问向量的元素。**[ ] 方括号** 用于索引。索引从位置 1 开始。在索引中给出负值会从结果中删除该元素。**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"
向量操作
向量算术
可以将两个相同长度的向量相加、相减、相乘或相除，结果为向量输出。
# 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 subtraction. 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
向量元素循环
如果我们将算术运算应用于两个长度不相等的向量，则较短向量的元素将被循环使用以完成运算。
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
向量元素排序
可以使用 **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"
R - 列表
列表是 R 对象，其中包含不同类型的元素，例如：数字、字符串、向量以及其内部的另一个列表。列表还可以包含矩阵或函数作为其元素。列表是使用 **list()** 函数创建的。
创建列表
以下是一个创建包含字符串、数字、向量和逻辑值的列表的示例。
# 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
命名列表元素
可以为列表元素命名，并且可以使用这些名称访问它们。
# 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
访问列表元素
可以通过列表中元素的索引访问列表的元素。对于命名列表，也可以使用名称访问它。
我们继续使用上面示例中的列表：
# 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
操作列表元素
我们可以添加、删除和更新列表元素，如下所示。我们只能在列表的末尾添加和删除元素。但我们可以更新任何元素。
# 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" $<NA> NULL $`A Inner list` [1] "updated element"
合并列表
您可以通过将所有列表放在一个 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"
将列表转换为向量
可以将列表转换为向量，以便可以将向量的元素用于进一步操作。在将列表转换为向量后，可以应用所有向量上的算术运算。要进行此转换，我们使用 **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
R - 矩阵
矩阵是 R 对象，其中元素以二维矩形布局排列。它们包含相同原子类型的元素。虽然我们可以创建一个仅包含字符或仅包含逻辑值的矩阵，但它们没有太大用处。我们使用包含数值元素的矩阵用于数学计算。
矩阵是使用 **matrix()** 函数创建的。
语法
在 R 中创建矩阵的基本语法如下：
matrix(data, nrow, ncol, byrow, dimnames)
以下是所用参数的描述：
**data** 是输入向量，它成为矩阵的数据元素。
**nrow** 是要创建的行数。
**ncol** 是要创建的列数。
**byrow** 是一个逻辑线索。如果为 TRUE，则输入向量元素按行排列。
**dimname** 是分配给行和列的名称。
示例
创建一个以数字向量作为输入的矩阵。
# 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
访问矩阵的元素
可以使用元素的列和行索引访问矩阵的元素。我们考虑上面的矩阵 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
矩阵计算
使用 R 运算符对矩阵执行各种数学运算。运算结果也是一个矩阵。
参与运算的矩阵的维度（行数和列数）必须相同。
矩阵加法和减法
# 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","\n")
print(result)
# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","\n")
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
矩阵乘法和除法
# 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","\n")
print(result)
# Divide the matrices
result <- matrix1 / matrix2
cat("Result of division","\n")
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
R - 数组
数组是 R 数据对象，可以存储多于两个维度的数。例如：如果我们创建一个维度为 (2, 3, 4) 的数组，则它将创建 4 个矩形矩阵，每个矩阵都有 2 行和 3 列。数组只能存储一种数据类型。
数组是使用 **array()** 函数创建的。它以向量作为输入，并使用 **dim** 参数中的值来创建数组。
示例
以下示例创建了一个包含两个 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
命名列和行
我们可以使用 **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
访问数组元素
# 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
操作数组元素
由于数组由多维矩阵组成，因此对数组元素的操作是通过访问矩阵的元素来执行的。
# 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
跨数组元素的计算
我们可以使用 **apply()** 函数对数组中的元素进行计算。
语法
apply(x, margin, fun)
以下是所用参数的描述：
**x** 是一个数组。
**margin** 是所用数据集的名称。
**fun** 是要应用于数组元素的函数。
示例
我们在下面使用 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
R - 因子
因子是用于对数据进行分类并将其存储为级别的数。它们可以存储字符串和整数。它们在具有有限数量唯一值的列中很有用。例如“男性”、“女性”和“真”、“假”等。它们在数据分析中对于统计建模很有用。
因子是使用 **factor ()** 函数创建的，它以向量作为输入。
示例
# 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
数据框中的因子
在创建任何包含文本数据列的数据框时，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
更改级别的顺序
可以通过再次应用 factor 函数并使用级别的新的顺序来更改因子中级别的顺序。
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
生成因子级别
我们可以使用 **gl()** 函数生成因子级别。它以两个整数作为输入，分别指示有多少个级别以及每个级别重复多少次。
语法
gl(n, k, labels)
以下是所用参数的描述：
**n** 是一个整数，表示级别的数量。
**k** 是一个整数，表示重复次数。
**labels** 是结果因子级别的标签向量。
示例
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
R - 数据框
数据框是表或二维数组状结构，其中每列包含一个变量的值，每行包含来自每列的一组值。
以下是数据框的特征。
- 列名必须非空。
- 行名必须唯一。
- 存储在数据框中的数据可以是数值型、因子型或字符型。
- 每列必须包含相同数量的数据项。
创建数据框
# 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
获取数据框的结构
可以使用 **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" ...
数据框中数据的摘要
可以通过应用 **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
从数据框中提取数据
使用列名从数据框中提取特定列。
# 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
提取第 3 行和第 5 行以及第 2 列和第 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 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
扩展数据框
可以通过添加列和行来扩展数据框。
添加列
只需使用新的列名添加列向量即可。
# 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
添加行
要将更多行永久添加到现有数据框中，我们需要以与现有数据框相同的结构引入新行，并使用 **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
R - 包
R 包是一组 R 函数、编译代码和示例数据。它们存储在 R 环境中名为“library”的目录下。默认情况下，R 在安装过程中会安装一组包。稍后，当需要用于某些特定目的时，会添加更多包。当我们启动 R 控制台时，默认情况下只有默认包可用。其他已安装的包必须显式加载才能被将要使用它们的 R 程序使用。
R 语言中所有可用的包都列在R 包。
以下是用于检查、验证和使用 R 包的命令列表。
检查可用的 R 包
获取包含 R 包的库位置
.libPaths()
当我们执行上述代码时，它会产生以下结果。它可能会因您电脑的本地设置而异。
[2] "C:/Program Files/R/R-3.2.2/library"
获取所有已安装包的列表
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
datasets The R Datasets Package
foreign Read Data Stored by 'Minitab', 'S', 'SAS',
'SPSS', 'Stata', 'Systat', 'Weka', 'dBase', ...
graphics The R Graphics Package
grDevices The R Graphics Devices and Support for Colours
and Fonts
grid The Grid Graphics Package
KernSmooth Functions for Kernel Smoothing Supporting Wand
& Jones (1995)
lattice Trellis Graphics for R
MASS Support Functions and Datasets for Venables and
Ripley's MASS
Matrix Sparse and Dense Matrix Classes and Methods
methods Formal Methods and Classes
mgcv Mixed GAM Computation Vehicle with GCV/AIC/REML
Smoothness Estimation
nlme Linear and Nonlinear Mixed Effects Models
nnet Feed-Forward Neural Networks and Multinomial
Log-Linear Models
parallel Support for Parallel computation in R
rpart Recursive Partitioning and Regression Trees
spatial Functions for Kriging and Point Pattern
Analysis
splines Regression Spline Functions and Classes
stats The R Stats Package
stats4 Statistical Functions using S4 Classes
survival Survival Analysis
tcltk Tcl/Tk Interface
tools Tools for Package Development
utils The R Utils Package
获取当前加载到 R 环境中的所有包
search()
当我们执行上述代码时，它会产生以下结果。它可能会因您电脑的本地设置而异。
[1] ".GlobalEnv" "package:stats" "package:graphics" [4] "package:grDevices" "package:utils" "package:datasets" [7] "package:methods" "Autoloads" "package:base"
安装新包
有两种方法可以添加新的 R 包。一种是从 CRAN 目录直接安装，另一种是将包下载到本地系统并手动安装。
从 CRAN 直接安装
以下命令直接从 CRAN 网页获取包并在 R 环境中安装包。系统可能会提示您选择最近的镜像。选择适合您所在位置的镜像。
install.packages("Package Name")
# Install the package named "XML".
install.packages("XML")
手动安装包
访问链接R 包下载所需的包。将包保存为本地系统中合适位置的.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")
加载包到库
在代码中使用包之前，必须将其加载到当前 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")
R - 数据重塑
R 中的数据重塑是关于更改数据在行和列中组织方式的过程。大多数情况下，R 中的数据处理是通过将输入数据作为数据框来完成的。从数据框的行和列中提取数据很容易，但有些情况下我们需要数据框采用与我们接收到的格式不同的格式。R 有许多函数可以拆分、合并和更改数据框中的行到列，反之亦然。
在数据框中连接列和行
我们可以使用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\n")
# 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\n")
# 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\n")
# 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
合并数据框
我们可以使用merge()函数合并两个数据框。数据框必须具有相同的列名，合并以此为基础。
在下面的示例中，我们考虑了“MASS”库中提供的关于皮马印第安妇女糖尿病的数据集。我们根据血压("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
熔化和铸造
R 编程最有趣的一方面是关于分多个步骤更改数据形状以获得所需形状。用于执行此操作的函数称为melt()和cast()。
我们考虑名为“MASS”库中名为ships的数据集。
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 ............ ............
熔化数据
现在我们熔化数据以对其进行组织，将除类型和年份之外的所有列转换为多行。
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 ........... ...........
铸造熔化后的数据
我们可以将熔化后的数据转换为新形式，其中创建了每种类型的船舶在每年的总和。这是使用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
R - CSV 文件
在 R 中，我们可以读取存储在 R 环境外部的文件中的数据。我们还可以将数据写入文件，这些文件将由操作系统存储和访问。R 可以读取和写入各种文件格式，例如 csv、excel、xml 等。
在本章中，我们将学习如何从 csv 文件中读取数据，然后将数据写入 csv 文件。该文件应位于当前工作目录中，以便 R 可以读取它。当然，我们也可以设置自己的目录并从那里读取文件。
获取和设置工作目录
您可以使用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"
此结果取决于您的操作系统以及您当前正在工作的目录。
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 5,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
读取 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
分析 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
一旦我们将数据读入数据框，我们就可以应用适用于数据框的所有函数，如后续部分所述。
获取最大工资
# 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
获取工资最高的人员的详细信息
我们可以获取满足特定筛选条件的行，类似于 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
获取所有在 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
获取 IT 部门中工资高于 600 的人员
# 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
获取 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
写入 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
R - Excel 文件
Microsoft Excel 是最广泛使用的电子表格程序，它以 .xls 或 .xlsx 格式存储数据。R 可以使用一些特定于 Excel 的包直接从这些文件读取。一些这样的包有 - XLConnect、xlsx、gdata 等。我们将使用 xlsx 包。R 也可以使用此包写入 Excel 文件。
安装 xlsx 包
您可以在 R 控制台中使用以下命令来安装“xlsx”包。它可能会要求安装此包依赖的一些其他包。使用所需的包名称重复相同的命令以安装其他包。
install.packages("xlsx")
验证并加载“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
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 43.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 工作区的当前工作目录中。
读取 Excel 文件
input.xlsx 通过使用read.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
R - 二进制文件
二进制文件是一个仅包含以位和字节（0 和 1）形式存储的信息的文件。它们不是人类可读的，因为其中的字节会转换为包含许多其他不可打印字符的字符和符号。尝试使用任何文本编辑器读取二进制文件将显示如 Ø 和 ð 之类的字符。
二进制文件必须由特定程序读取才能使用。例如，Microsoft Word 程序的二进制文件只能由 Word 程序读取为人类可读的形式。这表明，除了人类可读的文本外，还有许多其他信息，例如字符格式和页码等，也与字母数字字符一起存储。最后，二进制文件是连续的字节序列。我们在文本文件中看到的换行符是一个将第一行连接到下一行的字符。
有时，其他程序生成的数据需要作为二进制文件由 R 处理。R 还需要创建可以与其他程序共享的二进制文件。
R 有两个函数WriteBin()和readBin()用于创建和读取二进制文件。
语法
writeBin(object, con) readBin(con, what, n )
以下是所用参数的描述：
con是读取或写入二进制文件的连接对象。
object是要写入的二进制文件。
what是模式，例如字符、整数等，表示要读取的字节。
n是要从二进制文件中读取的字节数。
示例
我们考虑 R 内置数据“mtcars”。首先，我们从中创建一个 csv 文件，并将其转换为二进制文件，并将其存储为操作系统文件。接下来，我们将创建的此二进制文件读入 R。
写入二进制文件
我们将数据框“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)
读取二进制文件
上面创建的二进制文件将所有数据存储为连续的字节。因此，我们将通过选择列名以及列值的适当值来读取它。
# 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 中读取二进制文件，获得了原始数据。
R - XML 文件
XML 是一种文件格式，它使用标准 ASCII 文本在万维网、内部网和其他地方共享文件格式和数据。它代表可扩展标记语言 (XML)。类似于 HTML，它包含标记标签。但与 HTML 中标记标签描述页面结构不同，在 xml 中，标记标签描述文件包含的数据的含义。
您可以使用“XML”包在 R 中读取 xml 文件。可以使用以下命令安装此包。
install.packages("XML")
输入数据
通过将以下数据复制到记事本等文本编辑器中来创建 XML 文件。将文件保存为.xml扩展名，并选择文件类型为所有文件（*.*）。
<RECORDS>
<EMPLOYEE>
<ID>1</ID>
<NAME>Rick</NAME>
<SALARY>623.3</SALARY>
<STARTDATE>1/1/2012</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>2</ID>
<NAME>Dan</NAME>
<SALARY>515.2</SALARY>
<STARTDATE>9/23/2013</STARTDATE>
<DEPT>Operations</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>3</ID>
<NAME>Michelle</NAME>
<SALARY>611</SALARY>
<STARTDATE>11/15/2014</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>4</ID>
<NAME>Ryan</NAME>
<SALARY>729</SALARY>
<STARTDATE>5/11/2014</STARTDATE>
<DEPT>HR</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>5</ID>
<NAME>Gary</NAME>
<SALARY>843.25</SALARY>
<STARTDATE>3/27/2015</STARTDATE>
<DEPT>Finance</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>6</ID>
<NAME>Nina</NAME>
<SALARY>578</SALARY>
<STARTDATE>5/21/2013</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>7</ID>
<NAME>Simon</NAME>
<SALARY>632.8</SALARY>
<STARTDATE>7/30/2013</STARTDATE>
<DEPT>Operations</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>8</ID>
<NAME>Guru</NAME>
<SALARY>722.5</SALARY>
<STARTDATE>6/17/2014</STARTDATE>
<DEPT>Finance</DEPT>
</EMPLOYEE>
</RECORDS>
读取 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
获取 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
第一个节点的详细信息
让我们看一下解析文件的第一个记录。它将使我们了解顶级节点中存在的各种元素。
# 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"
获取节点的不同元素
# 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
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
由于数据现在以数据框的形式提供，因此我们可以使用与数据框相关的函数来读取和操作文件。
R - JSON 文件
JSON文件以人类可读的格式将数据存储为文本。Json 代表 JavaScript 对象表示法。R 可以使用 rjson 包读取 JSON 文件。
安装 rjson 包
在 R 控制台中，您可以发出以下命令来安装 rjson 包。
install.packages("rjson")
输入数据
通过将以下数据复制到记事本等文本编辑器中来创建 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"]
}
读取 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"
将 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
R - 网络数据
许多网站为其用户提供数据以供使用。例如，世界卫生组织 (WHO) 以 CSV、txt 和 XML 文件的形式提供有关健康和医疗信息的报告。使用 R 程序，我们可以以编程方式从这些网站提取特定数据。R 中用于从 Web 抓取数据的某些包是 - “RCurl”、“XML”和“stringr”。它们用于连接 URL、识别文件所需的链接并将它们下载到本地环境。
安装 R 包
处理 URL 和文件链接需要以下包。如果您的 R 环境中没有它们，您可以使用以下命令安装它们。
install.packages("RCurl")
install.packages("XML")
install.packages("stringr")
install.packages("plyr")
输入数据
我们将访问 URL 天气数据 并使用 R 下载 2015 年的 CSV 文件。
示例
我们将使用getHTMLLinks()函数收集文件的 URL。然后，我们将使用download.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/")
验证文件下载
运行上述代码后，您可以在当前 R 工作目录中找到以下文件。
"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv" "JCMB_2015_Mar.csv"
R - 数据库
数据在关系数据库系统中以规范化的格式存储。因此，为了进行统计计算，我们将需要非常高级和复杂的 Sql 查询。但是 R 可以轻松连接到许多关系数据库，如 MySql、Oracle、Sql Server 等，并将其中的记录作为数据框提取。一旦数据在 R 环境中可用，它就成为一个普通的 R 数据集，可以使用所有强大的包和函数进行操作或分析。
在本教程中，我们将使用 MySql 作为我们连接到 R 的参考数据库。
RMySQL 包
R 有一个名为“RMySQL”的内置包，它提供与 MySql 数据库的本机连接。您可以使用以下命令在 R 环境中安装此包。
install.packages("RMySQL")
将 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"
查询表
我们可以使用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.fame)
当我们执行以上代码时，它会产生以下结果：
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
带过滤子句的查询
我们可以传递任何有效的 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
更新表中的行
我们可以通过将 update 查询传递给 dbSendQuery() 函数来更新 MySql 表中的行。
dbSendQuery(mysqlconnection, "update mtcars set disp = 168.5 where hp = 110")
执行上述代码后，我们可以看到 MySql 环境中更新的表。
将数据插入表中
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 环境中插入表中的行。
在 MySql 中创建表
我们可以使用dbWriteTable()函数在 MySql 中创建表。如果表已存在，它会覆盖表，并以数据框作为输入。
# 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 环境中创建的表。
删除 MySql 中的表
我们可以通过将 drop table 语句传递到 dbSendQuery() 中来删除 MySql 数据库中的表，就像我们用于从表中查询数据一样。
dbSendQuery(mysqlconnection, 'drop table if exists mtcars')
执行上述代码后，我们可以看到 MySql 环境中已删除的表。
R - 饼图
R 编程语言有许多库可以创建图表和图形。饼图是以不同颜色表示圆形切片的数值表示。切片被标记，并且每个切片对应的数字也在图表中表示。
在 R 中，饼图是使用pie()函数创建的，该函数以正数作为向量输入。其他参数用于控制标签、颜色、标题等。
语法
使用 R 创建饼图的基本语法为 -
pie(x, labels, radius, main, col, clockwise)
以下是所用参数的描述：
x是包含饼图中使用的数值的向量。
labels用于为切片提供描述。
radius表示饼图圆形的半径。（值介于 -1 和 +1 之间）。
main表示图表的标题。
col表示调色板。
clockwise是一个逻辑值，指示切片是顺时针绘制还是逆时针绘制。
示例
一个非常简单的饼图是仅使用输入向量和标签创建的。以下脚本将在当前 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.png")
# Plot the chart.
pie(x,labels)
# Save the file.
dev.off()
当我们执行以上代码时，它会产生以下结果：
饼图标题和颜色
我们可以通过向函数添加更多参数来扩展图表的特征。我们将使用参数main向图表添加标题，另一个参数是col，它将在绘制图表时使用彩虹色调色板。调色板的长度应与我们为图表提供的数值数量相同。因此，我们使用 length(x)。
示例
以下脚本将在当前 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()
当我们执行以上代码时，它会产生以下结果：
切片百分比和图表图例
我们可以通过创建额外的图表变量来添加切片百分比和图表图例。
# 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()
当我们执行以上代码时，它会产生以下结果：
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()
当我们执行以上代码时，它会产生以下结果：
R - 条形图
条形图以矩形条的形式表示数据，条形的长度与变量的值成正比。R 使用barplot()函数创建条形图。R 可以在条形图中绘制垂直和水平条。在条形图中，每个条都可以赋予不同的颜色。
语法
在 R 中创建条形图的基本语法为 -
barplot(H,xlab,ylab,main, names.arg,col)
以下是所用参数的描述：
- H是包含条形图中使用的数值的向量或矩阵。
- xlab是 x 轴的标签。
- ylab是 y 轴的标签。
- main是条形图的标题。
- names.arg是每个条形下方显示的名称的向量。
- col用于为图形中的条形赋予颜色。
示例
一个简单的条形图是仅使用输入向量和每个条形的名称创建的。
以下脚本将在当前 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()
当我们执行上述代码时，它会产生以下结果 -
条形图标签、标题和颜色
可以通过添加更多参数来扩展条形图的特征。main参数用于添加标题。col参数用于向条形添加颜色。args.name是一个向量，其值数量与输入向量相同，用于描述每个条形的含义。
示例
以下脚本将在当前 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()
当我们执行上述代码时，它会产生以下结果 -
分组条形图和堆叠条形图
我们可以通过使用矩阵作为输入值来创建带有条形组和每个条形中堆栈的条形图。
多个变量表示为矩阵，用于创建分组条形图和堆叠条形图。
# 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()
R - 箱线图
箱线图是衡量数据集中数据分布程度的指标。它将数据集分成三个四分位数。此图形表示数据集中的最小值、最大值、中位数、第一四分位数和第三四分位数。它也有助于通过为每个数据集绘制箱线图来比较跨数据集的数据分布。
箱线图是在 R 中使用boxplot()函数创建的。
语法
在 R 中创建箱线图的基本语法为 -
boxplot(x, data, notch, varwidth, names, main)
以下是所用参数的描述：
x是向量或公式。
data是数据框。
notch是逻辑值。设置为 TRUE 以绘制凹口。
varwidth是逻辑值。设置为 true 以绘制与样本量成比例的框宽度。
names是将在每个箱线图下方打印的组标签。
main用于为图形指定标题。
示例
我们使用 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
创建箱线图
以下脚本将为 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()
当我们执行以上代码时，它会产生以下结果：
带凹口的箱线图
我们可以绘制带凹口的箱线图，以找出不同数据组的中位数如何相互匹配。
以下脚本将为每个数据组创建一个带凹口的箱线图。
# 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()
当我们执行以上代码时，它会产生以下结果：
R - 直方图
直方图表示变量值的频率，这些值被分成范围。直方图类似于条形图，但区别在于它将值分组到连续范围内。直方图中的每个条形都表示该范围内存在的数值的高度。
R 使用 **hist()** 函数创建直方图。此函数以向量作为输入，并使用一些其他参数来绘制直方图。
语法
使用 R 创建直方图的基本语法如下：
hist(v,main,xlab,xlim,ylim,breaks,col,border)
以下是所用参数的描述：
**v** 是一个包含直方图中使用的数值的向量。
**main** 指示图表标题。
**col** 用于设置条形的颜色。
**border** 用于设置每个条形的边框颜色。
**xlab** 用于给出 x 轴的描述。
**xlim** 用于指定 x 轴上的值范围。
**ylim** 用于指定 y 轴上的值范围。
**breaks** 用于指定每个条形的宽度。
示例
可以使用输入向量、标签、颜色和边框参数创建一个简单的直方图。
下面给出的脚本将在当前 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()
当我们执行以上代码时，它会产生以下结果：
X 和 Y 值的范围
要指定 X 轴和 Y 轴允许的值范围，可以使用 xlim 和 ylim 参数。
每个条形的宽度可以通过使用 breaks 来决定。
# 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()
当我们执行以上代码时，它会产生以下结果：
R - 线形图
折线图是一种通过在点之间绘制线段来连接一系列点的图形。这些点按其中一个坐标（通常是 x 坐标）的值排序。折线图通常用于识别数据中的趋势。
R 中的 **plot()** 函数用于创建折线图。
语法
在 R 中创建折线图的基本语法如下：
plot(v,type,col,xlab,ylab)
以下是所用参数的描述：
**v** 是一个包含数值的向量。
**type** 取值 "p" 表示仅绘制点，"l" 表示仅绘制线，"o" 表示绘制点和线。
xlab是 x 轴的标签。
ylab是 y 轴的标签。
**main** 是图表的标题。
**col** 用于给点和线着色。
示例
可以使用输入向量并将 type 参数设置为 "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()
当我们执行以上代码时，它会产生以下结果：
折线图标题、颜色和标签
可以通过使用其他参数来扩展折线图的功能。我们可以为点和线添加颜色，为图表添加标题，并为轴添加标签。
示例
# 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()
当我们执行以上代码时，它会产生以下结果：
折线图中的多条线
可以通过使用 **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()
当我们执行以上代码时，它会产生以下结果：
R - 散点图
散点图显示在笛卡尔平面上绘制的许多点。每个点表示两个变量的值。一个变量选择在横轴上，另一个变量选择在纵轴上。
简单的散点图使用 **plot()** 函数创建。
语法
在 R 中创建散点图的基本语法如下：
plot(x, y, main, xlab, ylab, xlim, ylim, axes)
以下是所用参数的描述：
**x** 是其值为横坐标的数据集。
**y** 是其值为纵坐标的数据集。
**main** 是图形的标题。
**xlab** 是横轴上的标签。
**ylab** 是纵轴上的标签。
**xlim** 是用于绘图的 x 值的限制。
**ylim** 是用于绘图的 y 值的限制。
**axes** 指示是否应在绘图上绘制两个轴。
示例
我们使用 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
创建散点图
以下脚本将为 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()
当我们执行以上代码时，它会产生以下结果：
散点图矩阵
当我们有多个变量并且我们想找到一个变量与其余变量之间的相关性时，我们使用散点图矩阵。我们使用 **pairs()** 函数创建散点图矩阵。
语法
在 R 中创建散点图矩阵的基本语法如下：
pairs(formula, data)
以下是所用参数的描述：
**formula** 表示成对使用的变量序列。
**data** 表示将从中获取变量的数据集。
示例
每个变量都与其余每个变量配对。为每对绘制一个散点图。
# 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()
执行上述代码后，我们将得到以下输出。
R - 均值、中位数和众数
R 中的统计分析是通过使用许多内置函数来执行的。大多数这些函数都是 R 基础包的一部分。这些函数将 R 向量作为输入以及参数，并给出结果。
我们在本章中讨论的函数是均值、中位数和众数。
均值
它是通过将值之和除以数据系列中的值个数来计算的。
**mean()** 函数用于在 R 中计算它。
语法
在 R 中计算均值的基本语法如下：
mean(x, trim = 0, na.rm = FALSE, ...)
以下是所用参数的描述：
**x** 是输入向量。
**trim** 用于从排序向量的两端删除一些观察值。
**na.rm** 用于从输入向量中删除缺失值。
示例
# 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
应用 Trim 选项
当提供 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
应用 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
中位数
数据系列中最中间的值称为中位数。**median()** 函数用于在 R 中计算此值。
语法
在 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
众数
众数是在一组数据中出现次数最多的值。与均值和中位数不同，众数可以具有数值数据和字符数据。
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"
R - 线性回归
回归分析是一种非常广泛使用的统计工具，用于建立两个变量之间的关系模型。其中一个变量称为预测变量，其值是通过实验收集的。另一个变量称为响应变量，其值是从预测变量导出的。
在线性回归中，这两个变量通过一个方程相关联，其中这两个变量的指数（幂）为 1。从数学上讲，线性关系在绘制成图形时表示一条直线。非线性关系中任何变量的指数都不等于 1，会产生曲线。
线性回归的一般数学方程为：
y = ax + b
以下是所用参数的描述：
**y** 是响应变量。
**x** 是预测变量。
**a** 和 **b** 是常数，称为系数。
建立回归的步骤
回归的一个简单示例是预测一个人的体重，已知他的身高。为此，我们需要了解身高和体重之间的关系。
创建关系的步骤如下：
进行实验以收集身高和相应体重的观察值的样本。
使用 R 中的 **lm()** 函数创建关系模型。
从创建的模型中找到系数，并使用这些系数创建数学方程
获取关系模型的摘要以了解预测中的平均误差。也称为 **残差**。
要预测新人的体重，请使用 R 中的 **predict()** 函数。
输入数据
以下是表示观察值的样本数据：
# 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
lm() 函数
此函数创建预测变量和响应变量之间的关系模型。
语法
线性回归中 **lm()** 函数的基本语法如下：
lm(formula,data)
以下是所用参数的描述：
**formula** 是一个表示 x 和 y 之间关系的符号。
**data** 是将对公式应用的向量。
创建关系模型并获取系数
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
获取关系的摘要
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
predict() 函数
语法
线性回归中 predict() 的基本语法如下：
predict(object, newdata)
以下是所用参数的描述：
**object** 是使用 lm() 函数已创建的公式。
**newdata** 是包含预测变量新值的向量。
预测新人的体重
# 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
以图形方式可视化回归
# 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()
当我们执行以上代码时，它会产生以下结果：
R - 多元回归
多元回归是线性回归扩展到两个以上变量之间关系的扩展。在简单的线性关系中，我们有一个预测变量和一个响应变量，但在多元回归中，我们有多个预测变量和一个响应变量。
多元回归的一般数学方程为：
y = a + b1x1 + b2x2 +...bnxn
以下是所用参数的描述：
**y** 是响应变量。
**a，b1，b2...bn** 是系数。
**x1，x2，...xn** 是预测变量。
我们使用 R 中的 **lm()** 函数创建回归模型。该模型使用输入数据确定系数的值。接下来，我们可以使用这些系数预测给定一组预测变量时响应变量的值。
lm() 函数
此函数创建预测变量和响应变量之间的关系模型。
语法
多元回归中 **lm()** 函数的基本语法如下：
lm(y ~ x1+x2+x3...,data)
以下是所用参数的描述：
**formula** 是一个表示响应变量和预测变量之间关系的符号。
**data** 是将对公式应用的向量。
示例
输入数据
考虑 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
创建关系模型并获取系数
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 # # # ","\n")
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
创建回归模型方程
根据上述截距和系数值，我们创建数学方程。
Y = a+Xdisp.x1+Xhp.x2+Xwt.x3 or Y = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3
应用方程预测新值
我们可以使用上面创建的回归方程来预测当提供排量、马力和重量的新值集时的里程数。
对于一辆 disp = 221、hp = 102 和 wt = 2.91 的汽车，预测的里程数为：
Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.7104
R - Logistic 回归
逻辑回归是一种回归模型，其中响应变量（因变量）具有分类值，例如真/假或 0/1。它实际上是根据将响应变量与其预测变量相关联的数学方程，测量二元响应的概率作为响应变量的值。
逻辑回归的一般数学方程为：
y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))
以下是所用参数的描述：
**y** 是响应变量。
**x** 是预测变量。
**a** 和 **b** 是数值常数系数。
用于创建回归模型的函数是glm()函数。
语法
逻辑回归中glm()函数的基本语法如下：
glm(formula,data,family)
以下是所用参数的描述：
formula是表示变量之间关系的符号。
data是提供这些变量值的数据集。
family是R对象，用于指定模型的详细信息。对于逻辑回归，其值为binomial。
示例
内置数据集“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
创建回归模型
我们使用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
结论
在摘要中，由于最后一列中变量“cyl”和“hp”的p值大于0.05，因此我们认为它们对变量“am”的值贡献不显著。只有重量(wt)会影响此回归模型中的“am”值。
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。
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()
当我们执行以上代码时，它会产生以下结果：
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()
当我们执行以上代码时，它会产生以下结果：
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()
当我们执行以上代码时，它会产生以下结果：
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()
当我们执行以上代码时，它会产生以下结果：
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是每次试验成功的概率。
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()
当我们执行以上代码时，它会产生以下结果：
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
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
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
R - 泊松回归
泊松回归涉及响应变量以计数形式而不是分数形式表示的回归模型。例如，出生人数或足球比赛系列中获胜次数的计数。此外，响应变量的值遵循泊松分布。
泊松回归的一般数学方程为：
log(y) = a + b1x1 + b2x2 + bnxn.....
以下是所用参数的描述：
**y** 是响应变量。
a和b是数值系数。
**x** 是预测变量。
用于创建泊松回归模型的函数是glm()函数。
语法
泊松回归中glm()函数的基本语法如下：
glm(formula,data,family)
以下是上述函数中使用的参数的描述：
formula是表示变量之间关系的符号。
data是提供这些变量值的数据集。
family是R对象，用于指定模型的详细信息。对于逻辑回归，其值为“Poisson”。
示例
我们有内置数据集“warpbreaks”，它描述了羊毛类型（A或B）和张力（低、中或高）对每台织布机断纱次数的影响。让我们将“breaks”视为响应变量，它是断纱次数的计数。羊毛“type”和“tension”被视为预测变量。
输入数据
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
创建回归模型
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会影响断纱次数。
R - 协方差分析
我们使用回归分析来创建模型，这些模型描述了预测变量变化对响应变量的影响。有时，如果我们有一个分类变量，其值如是/否或男/女等。简单的回归分析会为分类变量的每个值提供多个结果。在这种情况下，我们可以通过将分类变量与预测变量一起使用并比较分类变量每个水平的回归线来研究分类变量的影响。这种分析被称为协方差分析，也称为ANCOVA。
示例
考虑R内置数据集mtcars。在其中，我们观察到字段“am”表示传输类型（自动或手动）。它是一个分类变量，其值为0和1。汽车的每加仑英里数(mpg)除了马力("hp")的值外，也可能取决于它。
我们研究“am”的值对“mpg”和“hp”之间回归的影响。这是通过使用aov()函数，然后使用anova()函数来比较多个回归来完成的。
输入数据
创建一个包含数据集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
ANCOVA分析
我们创建一个回归模型，将“hp”作为预测变量，将“mpg”作为响应变量，并考虑“am”和“hp”之间的交互作用。
具有分类变量和预测变量之间交互作用的模型
# 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。
没有分类变量和预测变量之间交互作用的模型
# 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。
比较两个模型
现在我们可以比较这两个模型，以得出变量的交互作用是否确实不显著的结论。为此，我们使用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，因此我们得出结论，马力和传输类型之间的交互作用不显著。因此，在自动和手动传输模式下，每加仑英里数将以类似的方式取决于汽车的马力。
R - 时间序列分析
时间序列是一系列数据点，其中每个数据点都与一个时间戳相关联。一个简单的例子是股票市场中某只股票在给定日期的不同时间点的价格。另一个例子是某一地区不同月份的降雨量。R语言使用许多函数来创建、操作和绘制时间序列数据。时间序列的数据存储在一个称为时间序列对象的R对象中。它也是一个R数据对象，如向量或数据框。
时间序列对象是通过使用ts()函数创建的。
语法
时间序列分析中ts()函数的基本语法如下：
timeseries.object.name <- ts(data, start, end, frequency)
以下是所用参数的描述：
data是包含时间序列中使用的值的向量或矩阵。
start指定时间序列中第一个观测值的开始时间。
end指定时间序列中最后一个观测值的结束时间。
frequency指定每个单位时间的观测值数量。
除了参数“data”之外，所有其他参数都是可选的。
示例
考虑从2012年1月开始某地的年降雨量详细信息。我们为期12个月创建一个R时间序列对象并绘制它。
# 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
时间序列图表：
不同的时间间隔
ts()函数中frequency参数的值决定了测量数据点的时段。值为12表示时间序列为12个月。其他值及其含义如下：
frequency = 12将数据点固定在每年的每个月。
frequency = 4将数据点固定在每年的每个季度。
frequency = 6将数据点固定在每小时的每10分钟。
frequency = 24*6将数据点固定在每天的每10分钟。
多个时间序列
我们可以通过将两个序列组合成一个矩阵，在一个图表中绘制多个时间序列。
# 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
多个时间序列图表：
R - 非线性最小二乘法
在对回归分析的现实世界数据进行建模时，我们观察到模型的方程很少是线性方程，给出线性图。大多数情况下，现实世界数据的模型方程涉及更高次方的数学函数，如3的指数或正弦函数。在这种情况下，模型的图给出的是曲线而不是直线。线性回归和非线性回归的目标都是调整模型参数的值，以找到最接近数据的直线或曲线。找到这些值后，我们将能够以良好的精度估计响应变量。
在最小二乘回归中，我们建立一个回归模型，其中不同点到回归曲线的垂直距离的平方和最小化。我们通常从一个定义的模型开始，并为系数假设一些值。然后，我们应用R的nls()函数来获得更准确的值以及置信区间。
语法
在R中创建非线性最小二乘检验的基本语法如下：
nls(formula, data, start)
以下是所用参数的描述：
formula是非线性模型公式，包括变量和参数。
data是用于评估公式中变量的数据框。
start是起始估计的命名列表或命名数值向量。
示例
我们将考虑一个非线性模型，并假设其系数的初始值。接下来，我们将了解这些假设值的置信区间是什么，以便我们可以判断这些值与模型的拟合程度。
因此，让我们考虑以下方程以达到此目的：
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
我们可以得出结论，b1的值更接近1，而b2的值更接近2而不是3。
R - 决策树
决策树是一个图形，用于以树的形式表示选择及其结果。图中的节点表示事件或选择，图的边表示决策规则或条件。它主要用于使用R的机器学习和数据挖掘应用程序。
决策树的应用示例包括：预测电子邮件是否为垃圾邮件，预测肿瘤是否为癌性，或根据贷款的相关因素预测贷款信用风险的好坏。通常，模型是使用观察到的数据（也称为训练数据）创建的。然后，使用一组验证数据来验证和改进模型。R 拥有用于创建和可视化决策树的包。对于新的预测变量集，我们使用此模型来确定数据的类别（是/否，垃圾邮件/非垃圾邮件）。
R 包 "party" 用于创建决策树。
安装 R 包
在 R 控制台中使用以下命令安装该包。如有任何依赖包，您也需要安装它们。
install.packages("party")
包 "party" 包含函数 ctree()，用于创建和分析决策树。
语法
在 R 中创建决策树的基本语法如下：
ctree(formula, data)
以下是所用参数的描述：
formula 是一个描述预测变量和响应变量的公式。
data 是所用数据集的名称。
输入数据
我们将使用名为 readingSkills 的 R 内置数据集来创建决策树。如果我们知道变量“age”（年龄），“shoesize”（鞋码），“score”（分数）以及该人是否为母语人士，它描述了某人阅读技能分数。
以下是样本数据。
# 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 ............................... ...............................
示例
我们将使用 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
结论
从上面显示的决策树中，我们可以得出结论，任何阅读技能分数小于 38.3 且年龄大于 6 的人都不是母语人士。
R - 随机森林
在随机森林方法中，会创建大量的决策树。每个观察值都会输入到每个决策树中。每个观察值最常见的输出用作最终输出。将新的观察值输入到所有树中，并对每个分类模型进行多数投票。
对构建树时未使用的案例进行误差估计。这称为 OOB（袋外） 误差估计，以百分比表示。
R 包 "randomForest" 用于创建随机森林。
安装 R 包
在 R 控制台中使用以下命令安装该包。如有任何依赖包，您也需要安装它们。
install.packages("randomForest)
包 "randomForest" 包含函数 randomForest()，用于创建和分析随机森林。
语法
在 R 中创建随机森林的基本语法如下：
randomForest(formula, data)
以下是所用参数的描述：
formula 是一个描述预测变量和响应变量的公式。
data 是所用数据集的名称。
输入数据
我们将使用名为 readingSkills 的 R 内置数据集来创建决策树。它描述了某人阅读技能的分数，如果我们知道变量“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 ............................... ...............................
示例
我们将使用 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
结论
从上面显示的随机森林中，我们可以得出结论，鞋码和分数是决定某人是否为母语人士的重要因素。此外，模型只有 1% 的误差，这意味着我们可以以 99% 的准确率进行预测。
R - 生存分析
生存分析涉及预测特定事件将发生的时间。它也称为失效时间分析或死亡时间分析。例如，预测癌症患者的生存天数或预测机械系统何时会发生故障。
名为 survival 的 R 包用于执行生存分析。此包包含函数 Surv()，它将输入数据作为 R 公式，并在选定的变量之间创建一个生存对象以进行分析。然后，我们使用函数 survfit() 为分析创建图表。
安装包
install.packages("survival")
语法
在 R 中创建生存分析的基本语法如下：
Surv(time,event) survfit(formula)
以下是所用参数的描述：
time 是事件发生前的随访时间。
event 指示预期事件发生的状态。
formula 是预测变量之间的关系。
示例
我们将考虑名为“pbc”的数据集，该数据集存在于上面安装的 survival 包中。它描述了患有原发性胆汁性肝硬化 (PBC) 的患者的生存数据点。在数据集中存在的许多列中，我们主要关注“time”和“status”字段。Time 表示患者注册和患者接受肝移植或患者死亡之间较早事件之间的时间（以天为单位）。
# 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
从上述数据中，我们正在考虑时间和状态进行分析。
应用 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
上图中的趋势有助于我们预测在一定天数结束时生存的概率。
R - 卡方检验
卡方检验是一种统计方法，用于确定两个分类变量之间是否存在显着的相关性。这两个变量都应来自同一总体，并且应为分类变量，例如：是/否，男/女，红/绿等。
例如，我们可以构建一个包含人们冰淇淋购买模式观察值的数据集，并尝试将一个人的性别与其偏好的冰淇淋口味相关联。如果发现相关性，我们可以通过了解访客的性别数量来计划相应口味的库存。
语法
执行卡方检验的函数为 chisq.test()。
在 R 中创建卡方检验的基本语法如下：
chisq.test(data)
以下是所用参数的描述：
data 是表格形式的数据，包含观察中变量的计数值。
示例
我们将使用 "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
结论
结果显示 p 值小于 0.05，表明存在强相关性。