R语言是用于统计分析，图形表示和报告的编程语言和软件环境。 R语言由Ross Ihaka和Robert Gentleman在新西兰奥克兰大学创建，目前由R语言开发核心团队开发。
R语言的核心是解释计算机语言，其允许分支和循环以及使用函数的模块化编程。 R语言允许与以C，C ++，.Net，Python或FORTRAN语言编写的过程集成以提高效率。
R语言在GNU通用公共许可证下免费提供，并为各种操作系统（如Linux，Windows和Mac）提供预编译的二进制版本。
R是一个在GNU风格的副本左侧的自由软件，GNU项目的官方部分叫做GNU S.
R语言最初是由新西兰奥克兰奥克兰大学统计系的Ross Ihaka和Robert Gentleman写的。 R语言于1993年首次亮相。
一大群人通过发送代码和错误报告对R做出了贡献。
自1997年年中以来，已经有一个核心组（“R核心团队”）可以修改R源代码归档。
如前所述，R语言是用于统计分析，图形表示和报告的编程语言和软件环境。 以下是R语言的重要特点：
R语言是一种开发良好，简单有效的编程语言，包括条件，循环，用户定义的递归函数以及输入和输出设施。
R语言具有有效的数据处理和存储设施，
R语言提供了一套用于数组，列表，向量和矩阵计算的运算符。
R语言为数据分析提供了大型，一致和集成的工具集合。
R语言提供直接在计算机上或在纸张上打印的图形设施用于数据分析和显示。
作为结论，R语言是世界上最广泛使用的统计编程语言。 它是数据科学家的第一选择，并由一个充满活力和有才华的贡献者社区支持。 R语言在大学教授并部署在关键业务应用程序中。 本教程将教您R编程与适当的例子在简单和容易的步骤。
如果你愿意为本地设置R语言环境，你可以按照下面的步骤。
去 R 语言下载的镜像站点的列表下载
选择版本进行下载
点击运行 
进入安装界面 
一路默认，安装完毕！ 
R语言适用于多版本的Linux系统。
各版本Linux的各有不同。具体的安装步骤在上述资源中有对应的教程。但是，如果你是在赶时间，那么你可以用yum命令，如下所示的安装指令
安装R
$ yum install R
以上命令将安装R编程的核心功能与标准包，额外的包需要另外安装，而后你可以按如下提示启动R。
$ RR version 3.2.0 (2015-04-16) -- "Full of Ingredients" Copyright (C) 2015 The R Foundation for Statistical ComputingPlatform: 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命令安装所需的软件包。 例如，以下命令将安装为3D图表所需的plotrix软件包。
> install.packages("plotrix")我们将开始学习R语言编程，首先编写一个“你好，世界！ 的程序。 根据需要，您可以在R语言命令提示符处编程，也可以使用R语言脚本文件编写程序。 让我们逐个体验不同之处。
如果你已经配置好R语言环境，那么你只需要按一下的命令便可轻易开启命令提示符
$ R
这将启动R语言解释器，你会得到一个提示 > 在那里你可以开始输入你的程序，具体如下。
> myString <- "Hello, World!"> print ( myString)[1] "Hello, World!"
在这里，第一个语句先定义一个字符串变量myString，并将“Hello，World！”赋值其中，第二句则使用print()语句将变量myString的内容进行打印。
通常，您将通过在脚本文件中编写程序来执行编程，然后在命令提示符下使用R解释器（称为Rscript）来执行这些脚本。 所以让我们开始在一个命名为test.R的文本文件中编写下面的代码
# My first program in R ProgrammingmyString <- "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)虽然上面的注释将由R解释器执行，但它们不会干扰您的实际程序。 但是你必须为内容加上单引号或双引号。
通常，在使用任何编程语言进行编程时，您需要使用各种变量来存储各种信息。 变量只是保留值的存储位置。 这意味着，当你创建一个变量，你必须在内存中保留一些空间来存储它们。
您可能想存储各种数据类型的信息，如字符，宽字符，整数，浮点，双浮点，布尔等。基于变量的数据类型，操作系统分配内存并决定什么可以存储在保留内存中。
与其他编程语言（如 C 中的 C 和 java）相反，变量不会声明为某种数据类型。 变量分配有 R 对象，R 对象的数据类型变为变量的数据类型。尽管有很多类型的 R 对象，但经常使用的是：
这些对象中最简单的是向量对象，并且这些原子向量有六种数据类型，也称为六类向量。 其他 R 对象建立在原子向量之上。
| 数据类型 | 例 | 校验 |
|---|---|---|
| Logical（逻辑型） | TRUE, FALSE | v <- TRUE print(class(v)) 它产生以下结果 - [1] "logical" |
| Numeric（数字） | 12.3，5，999 | v <- 23.5print(class(v)) 它产生以下结果 - [1] "numeric" |
| Integer（整型） | 2L，34L，0L | v <- 2Lprint(class(v)) 它产生以下结果 - [1] "integer" |
| Complex（复合型） | 3 + 2i | v <- 2+5iprint(class(v)) 它产生以下结果 - [1] "complex" |
| Character（字符） | 'a' , "good", "TRUE", '23.4' | v <- "TRUE"print(class(v)) 它产生以下结果 - [1] "character" |
| Raw（原型） | "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"
虽然矩阵被限制为二维，但阵列可以具有任何数量的维度。 数组函数使用一个 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"
# 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# applying the nlevels function we can know the number of distinct values[1] 3
# 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 Age1 Male 152.0 81 422 Male 171.5 93 383 Female 165.0 78 26
变量为我们提供了我们的程序可以操作的命名存储。 R语言中的变量可以存储原子向量，原子向量组或许多Robject的组合。 有效的变量名称由字母，数字和点或下划线字符组成。 变量名以字母或不以数字后跟的点开头。
| 变量名 | 合法性 | 原因 |
|---|---|---|
| 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 ,"")cat ("var.2 is ", var.2 ,"")cat ("var.3 is ", var.3 ,"")当我们执行上面的代码，它产生以下结果 -
[1] 0 1 2 3var.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),"")var_x <- 34.5cat(" Now the class of var_x is ",class(var_x),"")var_x <- 27Lcat(" Next the class of var_x becomes ",class(var_x),"")当我们执行上面的代码，它产生以下结果 -
The class of var_x is character Now the class of var_x is numeric Next the class of var_x becomes integer
要知道工作空间中当前可用的所有变量，我们使用ls()函数。 ls()函数也可以使用模式来匹配变量名。
print(ls())
当我们执行上面的代码，它产生以下结果 -
[1] "my var" "my_new_var" "my_var" "var.1" [5] "var.2" "var.3" "var.name" "var_name2."[9] "var_x" "varname"
注意 - 它是一个示例输出，取决于在您的环境中声明的变量。
ls()函数可以使用模式来匹配变量名。
# List the variables starting with the pattern "var".print(ls(pattern = "var"))
当我们执行上面的代码，它产生以下结果 -
[1] "my var" "my_new_var" "my_var" "var.1" [5] "var.2" "var.3" "var.name" "var_name2."[9] "var_x" "varname"
以点(.)开头的变量被隐藏，它们可以使用ls()函数的“all.names = TRUE”参数列出。
print(ls(all.name = TRUE))
当我们执行上面的代码，它产生以下结果 -
[1] ".cars" ".Random.seed" ".var_name" ".varname" ".varname2" [6] "my var" "my_new_var" "my_var" "var.1" "var.2" [11]"var.3" "var.name" "var_name2." "var_x"
可以使用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语言支持的算术运算符。 操作符对向量的每个元素起作用。
| 运算符 | 描述 | 例 |
|---|---|---|
| + | 两个向量相加 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v+t) 它产生以下结果 - 10.0 8.5 10.0 |
| - | 两个向量相减 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v-t) 它产生以下结果 - -6.0 2.5 2.0 |
| * | 两个向量相乘 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v*t) 它产生以下结果 - 16.0 16.5 24.0 |
| / | 将第一个向量与第二个向量相除 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v/t) 当我们执行上面的代码，它产生以下结果 - 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) 它产生以下结果 - FALSE TRUE FALSE FALSE |
| < | 检查第一个向量的每个元素是否小于第二个向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v < t) 它产生以下结果 - TRUE FALSE TRUE FALSE |
| == | 检查第一个向量的每个元素是否等于第二个向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v == t) 它产生以下结果 - FALSE FALSE FALSE TRUE |
| <= | 检查第一向量的每个元素是否小于或等于第二向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v<=t) 它产生以下结果 - TRUE FALSE TRUE TRUE |
| > = | 检查第一向量的每个元素是否大于或等于第二向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v>=t) 它产生以下结果 - FALSE TRUE FALSE TRUE |
| != | 检查第一个向量的每个元素是否不等于第二个向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v!=t) 它产生以下结果 - TRUE TRUE TRUE FALSE |
| 运算符 | 描述 | 例 |
|---|---|---|
| & | 它被称为元素逻辑AND运算符。 它将第一向量的每个元素与第二向量的相应元素组合，并且如果两个元素都为TRUE，则给出输出TRUE。 | v <- c(3,1,TRUE,2+3i)t <- c(4,1,FALSE,2+3i)print(v&t) 它产生以下结果 - TRUE TRUE FALSE TRUE |
| | | 它被称为元素逻辑或运算符。 它将第一向量的每个元素与第二向量的相应元素组合，并且如果元素为真，则给出输出TRUE。 | v <- c(3,0,TRUE,2+2i)t <- c(4,0,FALSE,2+3i)print(v|t) 它产生以下结果 - TRUE FALSE TRUE TRUE |
| ! | 它被称为逻辑非运算符。 取得向量的每个元素，并给出相反的逻辑值。 | v <- c(3,0,TRUE,2+2i)print(!v) 它产生以下结果 - FALSE TRUE FALSE FALSE |
逻辑运算符&&和|| 只考虑向量的第一个元素，给出单个元素的向量作为输出。
| 运算符 | 描述 | 例 |
|---|---|---|
| && | 称为逻辑AND运算符。 取两个向量的第一个元素，并且只有两个都为TRUE时才给出TRUE。 | v <- c(3,0,TRUE,2+2i)t <- c(1,3,TRUE,2+3i)print(v&&t) 它产生以下结果 - TRUE |
| || | 称为逻辑OR运算符。 取两个向量的第一个元素，如果其中一个为TRUE，则给出TRUE。 | v <- c(0,0,TRUE,2+2i)t <- c(0,3,TRUE,2+3i)print(v||t) 它产生以下结果 - FALSE |
这些运算符用于向向量赋值。
| 运算符 | 描述 | 例 |
|---|---|---|
<− or = or <<−
| 称为左分配 | 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) 它产生以下结果 - 3+0i 1+0i 1+0i 2+3i3+0i 1+0i 1+0i 2+3i3+0i 1+0i 1+0i 2+3i |
-> or ->>
| 称为右分配 | c(3,1,TRUE,2+3i) -> v1c(3,1,TRUE,2+3i) ->> v2 print(v1)print(v2) 它产生以下结果 - 3+0i 1+0i 1+0i 2+3i3+0i 1+0i 1+0i 2+3i |
这些运算符用于特定目的，而不是一般的数学或逻辑计算。
| 运算符 | 描述 | 例 |
|---|---|---|
| : | 冒号运算符。 它为向量按顺序创建一系列数字。 | v <- 2:8print(v) 它产生以下结果 - 2 3 4 5 6 7 8 |
| %in% | 此运算符用于标识元素是否属于向量。 | v1 <- 8v2 <- 12t <- 1:10print(v1 %in% t) print(v2 %in% t) 它产生以下结果 - TRUEFALSE |
| %*% | 此运算符用于将矩阵与其转置相乘。 | 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提供以下类型的决策语句。 单击以下链接以检查其详细信息。
| Sr.No. | 声明和描述 |
|---|---|
| 1 | if语句 if语句由一个布尔表达式后跟一个或多个语句组成。 |
| 2 | if ... else语句 if语句后面可以有一个可选的else语句，当布尔表达式为false时执行。 |
| 3 | switch语句 switch语句允许根据值列表测试变量的相等性。 |
R语言的包是R函数，编译代码和样本数据的集合。 它们存储在R语言环境中名为“library”的目录下。 默认情况下，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 Packageboot Bootstrap Functions (Originally by Angelo Canty for S)class Functions for Classificationcluster "Finding Groups in Data": Cluster Analysis Extended Rousseeuw et al.codetools Code Analysis Tools for Rcompiler The R Compiler Package
获取当前在R环境中加载的所有包
search()
当我们执行上述代码时，它产生了以下结果。它会根据你的个人电脑的本地设置而异。
[1] ".GlobalEnv" "package:stats" "package:graphics" [4] "package:grDevices" "package:utils" "package:datasets" [7] "package:methods" "Autoloads" "package:base"
有两种方法来添加新的R包。 一个是直接从CRAN目录安装，另一个是将软件包下载到本地系统并手动安装它。
以下命令直接从CRAN网页获取软件包，并将软件包安装在R环境中。 可能会提示您选择最近的镜像。 根据您的位置选择一个。
install.packages("Package Name") # Install the package named "XML". install.packages("XML")
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编程语言提供以下种类的循环来处理循环需求。 单击以下链接以检查其详细信息。
| Sr.No. | 循环类型和描述 |
|---|---|
| 1 | repeat循环 多次执行一系列语句，并简化管理循环变量的代码。 |
| 2 | while循环 在给定条件为真时，重复语句或语句组。 它在执行循环体之前测试条件。 |
| 3 | for循环 像while语句，不同之处在于它测试在循环体的端部的条件。 |
| Sr.No. | 控制语句和描述 |
|---|---|
| 1 | break语句 终止循环语句，并将执行转移到循环后立即执行的语句。 |
| 2 | next语句 next语句模拟R语言switch语句的行为。 |
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") # Print the data frame.print(addresses)# Create another data frame with similar columnsnew.address <- data.frame( city = c("Lowry","Charlotte"), state = c("CO","FL"), zipcode = c("80230","33949"), stringsAsFactors = FALSE)# Print a header.cat("# # # The Second data frame") # Print the data frame.print(new.address)# Combine rows form both the data frames.all.addresses <- rbind(addresses,new.address)# Print a header.cat("# # # The combined data frame") # Print the result.print(all.addresses)当我们执行上面的代码，它产生以下结果 -
# # # # The First data frame city state zipcode[1,] "Tampa" "FL" "33602"[2,] "Seattle" "WA" "98104"[3,] "Hartford" "CT" "6161" [4,] "Denver" "CO" "80294"# # # The Second data frame city state zipcode1 Lowry CO 802302 Charlotte FL 33949# # # The combined data frame city state zipcode1 Tampa FL 336022 Seattle WA 981043 Hartford CT 61614 Denver CO 802945 Lowry CO 802306 Charlotte FL 33949
我们可以使用 merge() 函数合并两个数据帧。 数据帧必须具有相同的列名称，在其上进行合并。
在下面的例子中，我们考虑 library 名称“MASS”中有关 Pima Indian Women 的糖尿病的数据集。 我们基于血压（“bp”）和体重指数（“bmi”）的值合并两个数据集。 在选择这两列用于合并时，其中这两个变量的值在两个数据集中匹配的记录被组合在一起以形成单个数据帧。
library(MASS)merged.Pima <- merge(x = Pima.te, y = Pima.tr, by.x = c("bp", "bmi"), by.y = c("bp", "bmi"))print(merged.Pima)nrow(merged.Pima)当我们执行上面的代码，它产生以下结果 -
bp bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y1 60 33.8 1 117 23 0.466 27 No 2 125 20 0.0882 64 29.7 2 75 24 0.370 33 No 2 100 23 0.3683 64 31.2 5 189 33 0.583 29 Yes 3 158 13 0.2954 64 33.2 4 117 27 0.230 24 No 1 96 27 0.2895 66 38.1 3 115 39 0.150 28 No 1 114 36 0.2896 68 38.5 2 100 25 0.324 26 No 7 129 49 0.4397 70 27.4 1 116 28 0.204 21 No 0 124 20 0.2548 70 33.1 4 91 32 0.446 22 No 9 123 44 0.3749 70 35.4 9 124 33 0.282 34 No 6 134 23 0.54210 72 25.6 1 157 21 0.123 24 No 4 99 17 0.29411 72 37.7 5 95 33 0.370 27 No 6 103 32 0.32412 74 25.9 9 134 33 0.460 81 No 8 126 38 0.16213 74 25.9 1 95 21 0.673 36 No 8 126 38 0.16214 78 27.6 5 88 30 0.258 37 No 6 125 31 0.56515 78 27.6 10 122 31 0.512 45 No 6 125 31 0.56516 78 39.4 2 112 50 0.175 24 No 4 112 40 0.23617 88 34.5 1 117 24 0.403 40 Yes 4 127 11 0.598 age.y type.y1 31 No2 21 No3 24 No4 21 No5 21 No6 43 Yes7 36 Yes8 40 No9 29 Yes10 28 No11 55 No12 39 No13 39 No14 49 Yes15 49 Yes16 38 No17 28 No[1] 17
Status Age V1 V2 V3 V4 P 23646 45190 50333 55166 56271 CC 26174 35535 38227 37911 41184 CC 27723 25691 25712 26144 26398 CC 27193 30949 29693 29754 30772 CC 24370 50542 51966 54341 54273 CC 28359 58591 58803 59435 61292 CC 25136 45801 45389 47197 47126zz <- read.csv("mr.csv", strip.white = TRUE)zzz <- cbind(zz[gl(nrow(zz), 1, 4*nrow(zz)), 1:2], stack(zz[, 3:6])) Status Age values indX1 P 23646 45190 V1X2 CC 26174 35535 V1X3 CC 27723 25691 V1X4 CC 27193 30949 V1X5 CC 24370 50542 V1X6 CC 28359 58591 V1X7 CC 25136 45801 V1X11 P 23646 50333 V2...> reshape(zz, idvar="id",timevar="var", varying=list(c("V1","V2","V3","V4")),direction="long") Status Age var V1 id1.1 P 23646 1 45190 12.1 CC 26174 1 35535 23.1 CC 27723 1 25691 34.1 CC 27193 1 30949 45.1 CC 24370 1 50542 56.1 CC 28359 1 58591 67.1 CC 25136 1 45801 71.2 P 23646 2 50333 12.2 CC 26174 2 38227 2...函数是一组组合在一起以执行特定任务的语句。 R 语言具有大量内置函数，用户可以创建自己的函数。
在R语言中，函数是一个对象，因此R语言解释器能够将控制传递给函数，以及函数完成动作所需的参数。
该函数依次执行其任务并将控制返回到解释器以及可以存储在其他对象中的任何结果。
使用关键字函数创建 R 语言的函数。 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 from 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] 6Error in print(b) : argument "b" is missing, with no default
在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)
当我们运行脚本失败给下面的结果。
...: unexpected INCOMPLETE_STRING.... unexpected symbol 1: f <- 'Single quote ' insideunexpected symbol1: g <- "Double quotes " inside
R语言中的许多字符串使用 paste() 函数组合。 它可以采取任何数量的参数组合在一起。
对于粘贴功能的基本语法是 -
paste(..., sep = " ", collapse = NULL)
以下是所使用的参数的说明 -
... 表示要组合的任意数量的自变量。
sep 表示参数之间的任何分隔符。它是可选的。
collapse 用于消除两个字符串之间的空格。 但不是一个字符串的两个字内的空间。
a <- "Hello"b <- 'How'c <- "are you? "print(paste(a,b,c))print(paste(a,b,c, sep = "-"))print(paste(a,b,c, sep = "", collapse = ""))
当我们执行上面的代码，它产生以下结果 -
[1] "Hello How are you? "[1] "Hello-How-are you? "[1] "HelloHoware you? "
可以使用 format() 函数将数字和字符串格式化为特定样式。
格式化函数的基本语法是 -
format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none")) 以下是所使用的参数的描述 -
x 是向量输入。
digits 是显示的总位数。
nsmall 是小数点右边的最小位数。
科学设置为 TRUE 以显示科学记数法。
width 指示通过在开始处填充空白来显示的最小宽度。
justify 是字符串向左，右或中心的显示。
# Total number of digits displayed. Last digit rounded off.result <- format(23.123456789, digits = 9)print(result)# Display numbers in scientific notation.result <- format(c(6, 13.14521), scientific = TRUE)print(result)# The minimum number of digits to the right of the decimal point.result <- format(23.47, nsmall = 5)print(result)# Format treats everything as a string.result <- format(6)print(result)# Numbers are padded with blank in the beginning for width.result <- format(13.7, width = 6)print(result)# Left justify strings.result <- format("Hello", width = 8, justify = "l")print(result)# Justfy string with center.result <- format("Hello", width = 8, justify = "c")print(result)当我们执行上面的代码，它产生以下结果 -
[1] "23.1234568"[1] "6.000000e+00" "1.314521e+01"[1] "23.47000"[1] "6"[1] " 13.7"[1] "Hello "[1] " Hello "
此函数计算字符串中包含空格的字符数。
nchar() 函数的基本语法是 -
nchar(x)
以下是所使用的参数的描述 -
x 是向量输入。
result <- nchar("Count the number of characters")print(result)当我们执行上面的代码，它产生以下结果 -
[1] 30
这些函数改变字符串的字符的大小写。
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(x,first,last)
以下是所使用的参数的描述 -
x 是字符向量输入。
首先是要提取的第一个字符的位置。
last 是要提取的最后一个字符的位置。
# Extract characters from 5th to 7th position.result <- substring("Extract", 5, 7)print(result)当我们执行上面的代码，它产生以下结果 -
[1] "act"
向量是最基本的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:13print(v)# Creating a sequence from 6.6 to 12.6.v <- 6.6:12.6print(v)# If the final element specified does not belong to the sequence then it is discarded.v <- 3.8:11.4print(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
使用sequence (Seq.)序列运算符
# Create vector with elements from 5 to 9 incrementing by 0.4.print(seq(5, 9, by = 0.4))
当我们执行上面的代码，它产生以下结果 -
[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0
使用C()函数
如果其中一个元素是字符，则非字符值被强制转换为字符类型。
# The logical and numeric values are converted to characters.s <- c('apple','red',5,TRUE)print(s)当我们执行上面的代码，它产生以下结果 -
[1] "apple" "red" "5" "TRUE"
使用索引访问向量的元素。 []括号用于建立索引。 索引从位置1开始。在索引中给出负值会丢弃来自result.TRUE，FALSE或0和1的元素，也可用于索引。
# Accessing vector elements using position.t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")u <- t[c(2,3,6)]print(u)# Accessing vector elements using logical indexing.v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]print(v)# Accessing vector elements using negative indexing.x <- t[c(-2,-5)]print(x)# Accessing vector elements using 0/1 indexing.y <- t[c(0,0,0,0,0,0,1)]print(y)当我们执行上面的代码，它产生以下结果 -
[1] "Mon" "Tue" "Fri"[1] "Sun" "Fri"[1] "Sun" "Tue" "Wed" "Fri" "Sat"[1] "Sat"
可以添加，减去，相乘或相除两个相同长度的向量，将结果作为向量输出。
# Create two vectors.v1 <- c(3,8,4,5,0,11)v2 <- c(4,11,0,8,1,2)# Vector addition.add.result <- v1+v2print(add.result)# Vector substraction.sub.result <- v1-v2print(sub.result)# Vector multiplication.multi.result <- v1*v2print(multi.result)# Vector division.divi.result <- v1/v2print(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+v2print(add.result)sub.result <- v1-v2print(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语言对象，它包含不同类型的元素，如数字，字符串，向量和其中的另一个列表。 列表还可以包含矩阵或函数作为其元素。 列表是使用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"$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 vectorsresult <- v1+v2print(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对象。 它们包含相同原子类型的元素。 虽然我们可以创建一个只包含字符或只包含逻辑值的矩阵，但它们没有太多用处。 我们使用包含数字元素的矩阵用于数学计算。
使用matrix()函数创建一个矩阵。
在R语言中创建矩阵的基本语法是 -
matrix(data, nrow, ncol, byrow, dimnames)
以下是所使用的参数的说明 -
数据是成为矩阵的数据元素的输入向量。
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 col3row1 3 4 5row2 6 7 8row3 9 10 11row4 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] 13col1 col2 col3 6 7 8 row1 row2 row3 row4 5 8 11 14
# 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 + matrix2cat("Result of addition","")print(result)# Subtract the matricesresult <- matrix1 - matrix2cat("Result of subtraction","")print(result)当我们执行上面的代码，它产生以下结果 -
[,1] [,2] [,3][1,] 3 -1 2[2,] 9 4 6 [,1] [,2] [,3][1,] 5 0 3[2,] 2 9 4Result of addition [,1] [,2] [,3][1,] 8 -1 5[2,] 11 13 10Result 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 * matrix2cat("Result of multiplication","")print(result)# Divide the matricesresult <- matrix1 / matrix2cat("Result of division","")print(result)当我们执行上面的代码，它产生以下结果 -
[,1] [,2] [,3][1,] 3 -1 2[2,] 9 4 6 [,1] [,2] [,3][1,] 5 0 3[2,] 2 9 4Result of multiplication [,1] [,2] [,3][1,] 15 0 6[2,] 18 36 24Result of division [,1] [,2] [,3][1,] 0.6 -Inf 0.6666667[2,] 4.5 0.4444444 1.5000000
以下示例创建一个由两个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 COL3ROW1 5 10 13ROW2 9 11 14ROW3 3 12 15, , Matrix2 COL1 COL2 COL3ROW1 5 10 13ROW2 9 11 14ROW3 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 COL3ROW1 5 10 13ROW2 9 11 14ROW3 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+matrix2print(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
# 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 NorthLevels: 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 gender1 132 48 male2 151 49 male3 162 66 female4 139 53 female5 166 67 male6 147 52 female7 122 40 male[1] TRUE[1] male male female female male female male Levels: female male
可以通过使用新的等级次序再次应用因子函数来改变因子中的等级的顺序。
data <- c("East","West","East","North","North","East","West","West","West","East","North")# Create the factorsfactor_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 NorthLevels: East North West [1] East West East North North East West West West East NorthLevels: 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
# 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_date1 1 Rick 623.30 2012-01-012 2 Dan 515.20 2013-09-233 3 Michelle 611.00 2014-11-154 4 Ryan 729.00 2014-05-115 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.salary1 Rick 623.302 Dan 515.203 Michelle 611.004 Ryan 729.005 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_date1 1 Rick 623.3 2012-01-012 2 Dan 515.2 2013-09-23
用第2和第4列提取第3和第5行
# Create the data frame.emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE)# Extract 3rd and 5th row with 2nd and 4th column.result <- emp.data[c(3,5),c(2,4)]print(result)当我们执行上面的代码，它产生以下结果 -
emp_name start_date3 Michelle 2014-11-155 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.dataprint(v)当我们执行上面的代码，它产生以下结果 -
emp_id emp_name salary start_date dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 5 Gary 843.25 2015-03-27 Finance
# 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 frameemp.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 dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 5 Gary 843.25 2015-03-27 Finance6 6 Rasmi 578.00 2013-05-21 IT7 7 Pranab 722.50 2013-07-30 Operations8 8 Tusar 632.80 2014-06-17 Fianance
条形图表示矩形条中的数据，条的长度与变量的值成比例。 R语言使用函数 barplot() 创建条形图。 R 语言可以在条形图中绘制垂直和水平条。 在条形图中，每个条可以给予不同的颜色。
在 R 语言中创建条形图的基本语法是 -
barplot(H, xlab, ylab, main, names.arg, col)
以下是所使用的参数的描述 -
H 是包含在条形图中使用的数值的向量或矩阵。
xlab 是 x 轴的标签。
ylab 是 y 轴的标签。
main 是条形图的标题。
names.arg 是在每个条下出现的名称的向量。
col 用于向图中的条形提供颜色。
# 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()
当我们执行上面的代码，它产生以下结果 -
可以通过添加更多参数来扩展条形图的功能。 主要参数用于添加标题。 col 参数用于向条形添加颜色。 name.args 是具有与输入向量相同数量的值的向量，以描述每个条的含义。
以下脚本将在当前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语言中使用boxplot()函数来创建箱线图。
在R语言中创建箱线图的基本语法是 -
boxplot(x, data, notch, varwidth, names, main)
以下是所使用的参数的描述 -
x是向量或公式。
数据是数据帧。
notch是逻辑值。 设置为TRUE以绘制凹口。
varwidth是一个逻辑值。 设置为true以绘制与样本大小成比例的框的宽度。
names是将打印在每个箱线图下的组标签。
main用于给图表标题。
我们使用R语言环境中可用的数据集“mtcars”来创建基本箱线图。 让我们看看mtcars中的列“mpg”和“cyl”。
input <- mtcars[,c('mpg','cyl')]print(head(input))当我们执行上面的代码，它会产生以下结果 -
mpg cylMazda RX4 21.0 6Mazda RX4 Wag 21.0 6Datsun 710 22.8 4Hornet 4 Drive 21.4 6Hornet Sportabout 18.7 8Valiant 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语言使用hist()函数创建直方图。 此函数使用向量作为输入，并使用一些更多的参数来绘制直方图。
使用R语言创建直方图的基本语法是 -
hist(v,main,xlab,xlim,ylim,breaks,col,border)
以下是所使用的参数的描述 -
v是包含直方图中使用的数值的向量。
main表示图表的标题。
col用于设置条的颜色。
border用于设置每个条的边框颜色。
xlab用于给出x轴的描述。
xlim用于指定x轴上的值的范围。
ylim用于指定y轴上的值的范围。
break用于提及每个条的宽度。
使用输入vector，label，col和边界参数创建一个简单的直方图。
下面给出的脚本将创建并保存当前R语言工作目录中的直方图。
# Create data for the graph.v <- c(9,13,21,8,36,22,12,41,31,33,19)# Give the chart file a name.png(file = "histogram.png")# Create the histogram.hist(v,xlab = "Weight",col = "yellow",border = "blue")# Save the file.dev.off()
当我们执行上面的代码，它产生以下结果 -
要指定X轴和Y轴允许的值的范围，我们可以使用 xlim 和 ylim 参数。
每个条的宽度可以通过使用间隔来确定。
# Create data for the graph.v <- c(9,13,21,8,36,22,12,41,31,33,19)# Give the chart file a name.png(file = "histogram_lim_breaks.png")# Create the histogram.hist(v,xlab = "Weight",col = "green",border = "red", xlim = c(0,40), ylim = c(0,5), breaks = 5)# Save the file.dev.off()
当我们执行上面的代码，它产生以下结果 -
折线图是通过在它们之间绘制线段来连接一系列点的图。 这些点在它们的坐标（通常是x坐标）值之一中排序。 折线图通常用于识别数据中的趋势。
R语言中的plot()函数用于创建折线图。
在R语言中创建折线图的基本语法是 -
plot(v,type,col,xlab,ylab)
以下是所使用的参数的描述 -
v是包含数值的向量。
类型采用值“p”仅绘制点，“l”仅绘制线和“o”绘制点和线。
xlab是x轴的标签。
ylab是y轴的标签。
main是图表的标题。
col用于给点和线的颜色。
使用输入向量和类型参数“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()
当我们执行上面的代码，它产生以下结果 -
# 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(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 mpgMazda RX4 2.620 21.0Mazda RX4 Wag 2.875 21.0Datsun 710 2.320 22.8Hornet 4 Drive 3.215 21.4Hornet Sportabout 3.440 18.7Valiant 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语言创建饼图的基本语法是 -
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.jpg")# 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()当我们执行上面的代码，它产生以下结果 -
可以使用其他软件包绘制具有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 语言环境外的文件中读取数据。 我们还可以将数据写入将被操作系统存储和访问的文件。 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 文件是一个文本文件，其中列中的值由逗号分隔。 让我们考虑名为input.csv的文件中出现的以下数据。
您可以通过复制和粘贴此数据使用 Windows 记事本创建此文件。 使用记事本中的保存为所有文件（*.*）选项将文件保存为input.csv。
id,name,salary,start_date,dept1,Rick,623.3,2012-01-01,IT2,Dan,515.2,2013-09-23,Operations3,Michelle,611,2014-11-15,IT4,Ryan,729,2014-05-11,HR ,Gary,843.25,2015-03-27,Finance6,Nina,578,2013-05-21,IT7,Simon,632.8,2013-07-30,Operations8,Guru,722.5,2014-06-17,Finance
以下是read.csv()函数的一个简单示例，用于读取当前工作目录中可用的 CSV 文件 -
data <- read.csv("input.csv")print(data)当我们执行上面的代码，它产生以下结果 -
id, name, salary, start_date, dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
默认情况下，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 dept5 NA Gary 843.25 2015-03-27 Finance
# Create a data frame.data <- read.csv("input.csv")retval <- subset( data, dept == "IT")print(retval)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept1 1 Rick 623.3 2012-01-01 IT3 3 Michelle 611.0 2014-11-15 IT6 6 Nina 578.0 2013-05-21 IT
# Create a data frame.data <- read.csv("input.csv")info <- subset(data, salary > 600 & dept == "IT")print(info)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept1 1 Rick 623.3 2012-01-01 IT3 3 Michelle 611.0 2014-11-15 IT
# 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 dept3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance8 8 Guru 722.50 2014-06-17 Finance
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 dept1 3 3 Michelle 611.00 2014-11-15 IT2 4 4 Ryan 729.00 2014-05-11 HR3 5 NA Gary 843.25 2015-03-27 Finance4 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 dept1 3 Michelle 611.00 2014-11-15 IT2 4 Ryan 729.00 2014-05-11 HR3 NA Gary 843.25 2015-03-27 Finance4 8 Guru 722.50 2014-06-17 Finance
Microsoft Excel是最广泛使用的电子表格程序，以.xls或.xlsx格式存储数据。 R语言可以直接从这些文件使用一些excel特定的包。 很少这样的包是 - XLConnect，xlsx，gdata等。我们将使用xlsx包。 R语言也可以使用这个包写入excel文件。
您可以在R控制台中使用以下命令来安装“xlsx”软件包。 它可能会要求安装一些额外的软件包这个软件包依赖。 按照具有所需软件包名称的同一命令安装其他软件包。
install.packages("xlsx")使用以下命令验证并加载“xlsx”软件包。
# Verify the package is installed.any(grepl("xlsx",installed.packages()))# Load the library into R workspace.library("xlsx")当脚本运行，我们得到以下输出。
[1] TRUELoading required package: rJavaLoading required package: methodsLoading required package: xlsxjars
打开Microsoft Excel。 将以下数据复制并粘贴到名为sheet1的工作表中。
id name salary start_date dept1 Rick 623.3 1/1/2012 IT2 Dan 515.2 9/23/2013 Operations3 Michelle 611 11/15/2014 IT4 Ryan 729 5/11/2014 HR5 Gary 843.25 3/27/2015 Finance6 Nina 578 5/21/2013 IT7 Simon 632.8 7/30/2013 Operations8 Guru 722.5 6/17/2014 Finance
还要将以下数据复制并粘贴到另一个工作表，并将此工作表重命名为“city”。
name cityRick SeattleDan TampaMichelle ChicagoRyan SeattleGary HoustonNina BostonSimon MumbaiGuru Dallas
将Excel文件另存为“input.xlsx”。 应将其保存在R工作区的当前工作目录中。
通过使用read.xlsx()函数读取input.xlsx，如下所示。 结果作为数据帧存储在R语言环境中。
# Read the first worksheet in the file input.xlsx.data <- read.xlsx("input.xlsx", sheetIndex = 1)print(data)当我们执行上面的代码，它产生以下结果 -
id, name, salary, start_date, dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
二进制文件是包含仅以位和字节（0和1）的形式存储的信息的文件。它们不是人类可读的，因为它中的字节转换为包含许多其他不可打印字符的字符和符号。尝试使用任何文本编辑器读取二进制文件将显示如Ø和ð的字符。
二进制文件必须由特定程序读取才能使用。例如，Microsoft Word程序的二进制文件只能通过Word程序读取到人类可读的形式。这表示，除了人类可读的文本之外，还有更多的信息，例如字符和页码等的格式化，它们也与字母数字字符一起存储。最后一个二进制文件是一个连续的字节序列。我们在文本文件中看到的换行符是连接第一行到下一行的字符。
有时，由其他程序生成的数据需要由R作为二进制文件处理。另外，R语言是创建可以与其他程序共享的二进制文件所必需的。
R语言有两个函数WriteBin()和readBin()来创建和读取二进制文件。
writeBin(object, con)readBin(con, what, n )
以下是所使用的参数的描述 -
con 是读取或写入二进制文件的连接对象。
object 是要写入的二进制文件。
what - 是像字符，整数等代表字节模式被读取。
n 是从二进制文件读取的字节数。
我们考虑R语言内置数据“mtcars”。 首先，我们从它创建一个csv文件，并将其转换为二进制文件，并将其存储为操作系统文件。 接下来我们读取这个创建的二进制文件。
我们将数据帧“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.namesprint(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中的二进制文件得到原始数据。
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文件由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
# 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文件中的数据作为数据框读取。 然后处理数据帧以进行数据分析。
# 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 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
由于数据现在可以作为数据帧，我们可以使用数据帧相关函数来读取和操作文件。
JSON文件以人类可读格式将数据存储为文本。 Json代表JavaScript Object Notation。 R可以使用rjson包读取JSON文件。
在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文件由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"
我们可以使用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, dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
许多网站提供数据供其用户使用。 例如，世界卫生组织（WHO）以CSV，txt和XML文件的形式提供健康和医疗信息的报告。 使用R语言程序，我们可以从这些网站以编程方式提取特定数据。 R语言中用于从网站中提取数据的一些包是“RCurl”，XML“和”stringr“，它们用于连接到URL，识别文件所需的链接并将它们下载到本地环境。
处理URL和链接到文件需要以下的包。 如果它们在R语言环境中不可用，您可以使用以下命令安装它们。
install.packages("RCurl")install.packages("XML")install.packages("stringr")install.packages("plyr")我们将访问URL天气数据，并使用R在2015年下载CSV文件。
我们将使用函数getHTMLLinks()来收集文件的URL。 然后我们将使用函数downlaod.file()将文件保存到本地系统。 由于我们将对多个文件一次又一次地应用相同的代码，因此我们将创建一个被多次调用的函数。 文件名作为参数以R列表对象的形式传递到此函数。
# Read the URL.url <- "http://www.geos.ed.ac.uk/~weather/jcmb_ws/"# Gather the html links present in the webpage.links <- getHTMLLinks(url)# Identify only the links which point to the JCMB 2015 files. filenames <- links[str_detect(links, "JCMB_2015")]# Store the file names as a list.filenames_list <- as.list(filenames)# Create a function to download the files by passing the URL and filename list.downloadcsv <- function (mainurl,filename) { filedetails <- str_c(mainurl,filename) download.file(filedetails,filename)}# Now apply the l_ply function and save the files into the current R working directory.l_ply(filenames,downloadcsv,mainurl = "http://www.geos.ed.ac.uk/~weather/jcmb_ws/")运行上述代码后，您可以在当前R语言工作目录中找到以下文件。
"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv" "JCMB_2015_Mar.csv"
R语言有一个名为“RMySQL”的内置包，它提供与MySql数据库之间的本地连接。 您可以使用以下命令在R语言环境中安装此软件包。
install.packages("RMySQL")一旦安装了包，我们在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.frame)
当我们执行上面的代码，它产生以下结果 -
actor_id first_name last_name last_update1 1 PENELOPE GUINESS 2006-02-15 04:34:332 2 NICK WAHLBERG 2006-02-15 04:34:333 3 ED CHASE 2006-02-15 04:34:334 4 JENNIFER DAVIS 2006-02-15 04:34:335 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_update1 18 DAN TORN 2006-02-15 04:34:332 94 KENNETH TORN 2006-02-15 04:34:333 102 WALTER TORN 2006-02-15 04:34:33
我们可以通过将更新查询传递给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()创建表。 如果表已经存在，它将覆盖该表，并将数据帧用作输入。
# 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()中，就像我们使用它查询表中的数据一样。
dbSendQuery(mysqlconnection, 'drop table if exists mtcars')
执行上面的代码后，我们可以看到表在MySql环境中被删除。
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 = 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.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
数据系列中的最中间值称为中值。 在R语言中使用median()函数来计算此值。
计算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
模式是一组数据中出现次数最多的值。 Unike平均值和中位数，模式可以同时包含数字和字符数据。
R语言没有标准的内置函数来计算模式。 因此，我们创建一个用户函数来计算R语言中的数据集的模式。该函数将向量作为输入，并将模式值作为输出。
# Create the function.getmode <- function(v) { uniqv <- unique(v) uniqv[which.max(tabulate(match(v, uniqv)))]}# Create the vector with numbers.v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)# Calculate the mode using the user function.result <- getmode(v)print(result)# Create the vector with characters.charv <- c("o","it","the","it","it")# Calculate the mode using the user function.result <- getmode(charv)print(result)当我们执行上面的代码，它产生以下结果 -
[1] 2[1] "it"
回归分析是一种非常广泛使用的统计工具，用于建立两个变量之间的关系模型。 这些变量之一称为预测变量，其值通过实验收集。 另一个变量称为响应变量，其值从预测变量派生。
在线性回归中，这两个变量通过方程相关，其中这两个变量的指数（幂）为1.数学上，线性关系表示当绘制为曲线图时的直线。 任何变量的指数不等于1的非线性关系将创建一条曲线。
线性回归的一般数学方程为 -
y = ax + b
以下是所使用的参数的描述 -
y是响应变量。
x是预测变量。
a和b被称为系数常数。
回归的简单例子是当人的身高已知时预测人的体重。 为了做到这一点，我们需要有一个人的身高和体重之间的关系。
创建关系的步骤是 -
进行收集高度和相应重量的观测值的样本的实验。
使用R语言中的lm()函数创建关系模型。
从创建的模型中找到系数，并使用这些创建数学方程
获得关系模型的摘要以了解预测中的平均误差。 也称为残差。
为了预测新人的体重，使用R中的predict()函数。
下面是代表观察的样本数据 -
# Values of height151, 174, 138, 186, 128, 136, 179, 163, 152, 131# Values of weight.63, 81, 56, 91, 47, 57, 76, 72, 62, 48
此函数创建预测变量和响应变量之间的关系模型。
线性回归中lm()函数的基本语法是 -
lm(formula,data)
以下是所使用的参数的说明 -
公式是表示x和y之间的关系的符号。
数据是应用公式的向量。
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 ‘ ’ 1Residual standard error: 3.253 on 8 degrees of freedomMultiple 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(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()
当我们执行上面的代码，它产生以下结果 -
多元回归是线性回归到两个以上变量之间的关系的延伸。 在简单线性关系中，我们有一个预测变量和一个响应变量，但在多元回归中，我们有多个预测变量和一个响应变量。
多元回归的一般数学方程为 -
y = a + b1x1 + b2x2 +...bnxn
以下是所使用的参数的描述 -
y是响应变量。
a，b1，b2 ... bn是系数。
x1，x2，... xn是预测变量。
我们使用R语言中的lm()函数创建回归模型。模型使用输入数据确定系数的值。 接下来，我们可以使用这些系数来预测给定的一组预测变量的响应变量的值。
此函数创建预测变量和响应变量之间的关系模型。
lm()函数在多元回归中的基本语法是 -
lm(y ~ x1+x2+x3...,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 wtMazda RX4 21.0 160 110 2.620Mazda RX4 Wag 21.0 160 110 2.875Datsun 710 22.8 108 93 2.320Hornet 4 Drive 21.4 258 110 3.215Hornet Sportabout 18.7 360 175 3.440Valiant 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 # # # ","")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.x3orY = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3
Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.7104
逻辑回归是回归模型，其中响应变量（因变量）具有诸如True / False或0/1的分类值。 它实际上基于将其与预测变量相关的数学方程测量二元响应的概率作为响应变量的值。
逻辑回归的一般数学方程为 -
y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))
以下是所使用的参数的描述 -
y是响应变量。
x是预测变量。
a和b是作为数字常数的系数。
用于创建回归模型的函数是glm()函数。
逻辑回归中glm()函数的基本语法是 -
glm(formula,data,family)
以下是所使用的参数的描述 -
formula是表示变量之间的关系的符号。
data是给出这些变量的值的数据集。
family是R语言对象来指定模型的细节。 它的值是二项逻辑回归。
内置数据集“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 wtMazda RX4 1 6 110 2.620Mazda RX4 Wag 1 6 110 2.875Datsun 710 1 4 93 2.320Hornet 4 Drive 0 6 110 3.215Hornet Sportabout 0 8 175 3.440Valiant 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 freedomResidual deviance: 9.8415 on 28 degrees of freedomAIC: 17.841Number of Fisher Scoring iterations: 8
在总结中，对于变量“cyl”和“hp”，最后一列中的p值大于0.05，我们认为它们对变量“am”的值有贡献是无关紧要的。 只有重量（wt）影响该回归模型中的“am”值。
在来自独立源的数据的随机集合中，通常观察到数据的分布是正常的。 这意味着，在绘制水平轴上的变量值和垂直轴上的值的计数的图形时，我们得到钟形曲线。 曲线的中心表示数据集的平均值。 在图中，50％的值位于平均值的左侧，另外50％位于图表的右侧。 这在统计学中被称为正态分布。
R语言有四个内置函数来产生正态分布。 它们描述如下。
dnorm(x, mean, sd)pnorm(x, mean, sd)qnorm(p, mean, sd)rnorm(n, mean, sd)以下是在上述功能中使用的参数的描述 -
该函数给出给定平均值和标准偏差在每个点的概率分布的高度。
# 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()当我们执行上面的代码，它产生以下结果 -
该函数给出正态分布随机数的概率小于给定数的值。 它也被称为“累积分布函数”。
# 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()当我们执行上面的代码，它产生以下结果 -
该函数采用概率值，并给出累积值与概率值匹配的数字。
# 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 = 3)# Give the chart file a name.png(file = "qnorm.png")# Plot the graph.plot(x,y)# Save the file.dev.off()当我们执行上面的代码，它产生以下结果 -
此函数用于生成分布正常的随机数。 它将样本大小作为输入，并生成许多随机数。 我们绘制一个直方图来显示生成的数字的分布。
# 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()当我们执行上面的代码，它产生以下结果 -
二项分布模型处理在一系列实验中仅发现两个可能结果的事件的成功概率。 例如，掷硬币总是给出头或尾。 在二项分布期间估计在10次重复抛掷硬币中精确找到3个头的概率。
R语言有四个内置函数来生成二项分布。 它们描述如下。
dbinom(x, size, prob)pbinom(x, size, prob)qbinom(p, size, prob)rbinom(n, size, prob)
以下是所使用的参数的描述 -
x是数字的向量。
p是概率向量。
n是观察的数量。
size是试验的数量。
prob是每个试验成功的概率。
该函数给出每个点的概率密度分布。
# 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()
当我们执行上面的代码，它产生以下结果 -
此函数给出事件的累积概率。 它是表示概率的单个值。
# 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
该函数采用概率值，并给出累积值与概率值匹配的数字。
# 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
该函数从给定样本产生给定概率的所需数量的随机值。
# 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
泊松回归（英语:Poisson regression）包括回归模型，其中响应变量是计数而不是分数的形式。
例如，足球比赛系列中的出生次数或胜利次数。 此外，响应变量的值遵循泊松分布。
泊松回归的一般数学方程为 -
log(y) = a + b1x1 + b2x2 + bnxn.....
以下是所使用的参数的描述 -
y是响应变量。
a和b是数字系数。
x是预测变量。
用于创建泊松回归模型的函数是glm()函数。
在泊松回归中glm()函数的基本语法是 -
glm(formula,data,family)
以下是在上述功能中使用的参数的描述 -
formula是表示变量之间的关系的符号。
data是给出这些变量的值的数据集。
family是 R 语言对象来指定模型的细节。 它的值是“泊松”的逻辑回归。
我们有内置的数据集“warpbreaks”，其描述了羊毛类型（A或B）和张力（低，中或高）对每个织机的经纱断裂数量的影响。 让我们考虑“断裂”作为响应变量，它是断裂次数的计数。 羊毛“类型”和“张力”作为预测变量。
input <- warpbreaksprint(head(input))
当我们执行上面的代码，它产生以下结果 -
breaks wool tension1 26 A L2 30 A L3 54 A L4 25 A L5 70 A L6 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 freedomResidual deviance: 210.39 on 50 degrees of freedomAIC: 493.06Number of Fisher Scoring iterations: 4
在摘要中，我们查找最后一列中的p值小于0.05，以考虑预测变量对响应变量的影响。 如图所示，具有张力类型M和H的羊毛类型B对断裂计数有影响。
我们使用回归分析创建模型，描述变量在预测变量对响应变量的影响。 有时，如果我们有一个类别变量，如Yes / No或Male / Female等。简单的回归分析为分类变量的每个值提供多个结果。 在这种情况下，我们可以通过将分类变量与预测变量一起使用并比较分类变量的每个级别的回归线来研究分类变量的效果。 这样的分析被称为协方差分析，也称为ANCOVA。
考虑在数据集mtcars中内置的R语言。 在其中我们观察到字段“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 hpMazda RX4 1 21.0 110Mazda RX4 Wag 1 21.0 110Datsun 710 1 22.8 93Hornet 4 Drive 0 21.4 110Hornet Sportabout 0 18.7 175Valiant 0 18.1 105
我们创建一个回归模型，以“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 * amModel 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，我们得出结论，马力和传播类型之间的相互作用不显著。 因此，在汽车和手动变速器模式下，每加仑的里程将以类似的方式取决于汽车的马力。
时间序列是将统一统计值按照时间发生的先后顺序来进行排列，时间序列分析的主要目的是根据已有数据对未来进行预测。
一个稳定的时间序列中常常包含两个部分，那么就是：有规律的时间序列+噪声。所以，在以下的方法中，主要的目的就是去过滤噪声值，让我们的时间序列更加的有分析意义。
时间序列分析中ts()函数的基本语法是 -
timeseries.object.name <- ts(data, start, end, frequency)
以下是所使用的参数的描述 -
data是包含在时间序列中使用的值的向量或矩阵。
start以时间序列指定第一次观察的开始时间。
end指定时间序列中最后一次观测的结束时间。
frequency指定每单位时间的观测数。
除了参数“data”，所有其他参数是可选的。
拿到一个时间序列之后，我们首先要对其稳定性进行判断，只有非白噪声的稳定性时间序列才有分析的意义以及预测未来数据的价值。
所谓平稳，是指统计值在一个常数上下波动并且波动范围是有界限的。如果有明显的趋势或者周期性，那么就是不稳定的。一般判断有三种方法：
在R语言中，DF检测是一种检测稳定性的方法，如果得出的P值小于临界值，则认为是序列是稳定的。
白噪声序列，又称为纯随机性序列，序列的各个值之间没有任何的相关关系，序列在进行无序的随机波动，可以终止对该序列的分析，因为从白噪声序列中是提取不到任何有价值的信息的。
均值和方差为常数，并且具有与时间无关的自协方差。
考虑从2012年1月开始的一个地方的年降雨量细节。我们创建一个R时间序列对象为期12个月并绘制它。
# Get the data points in form of a R vector.rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)# Convert it to a time series object.rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)# Print the timeseries data.print(rainfall.timeseries)# Give the chart file a name.png(file = "rainfall.png")# Plot a graph of the time series.plot(rainfall.timeseries)# Save the file.dev.off()
当我们执行上面的代码，它产生以下结果及图表 -
Jan Feb Mar Apr May Jun Jul Aug Sep2012 799.0 1174.8 865.1 1334.6 635.4 918.5 685.5 998.6 784.2 Oct Nov Dec2012 985.0 882.8 1071.0
时间序列图 -
ts()函数中的频率参数值决定了测量数据点的时间间隔。 值为12表示时间序列为12个月。 其他值及其含义如下 -
频率= 12指定一年中每个月的数据点。
频率= 4每年的每个季度的数据点。
频率= 6每小时的10分钟的数据点。
频率= 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 2Jan 2012 799.0 655.0Feb 2012 1174.8 1306.9Mar 2012 865.1 1323.4Apr 2012 1334.6 1172.2May 2012 635.4 562.2Jun 2012 918.5 824.0Jul 2012 685.5 822.4Aug 2012 998.6 1265.5Sep 2012 784.2 799.6Oct 2012 985.0 1105.6Nov 2012 882.8 1106.7Dec 2012 1071.0 1337.8
多时间序列图 -
当模拟真实世界数据用于回归分析时，我们观察到，很少情况下，模型的方程是给出线性图的线性方程。大多数时候，真实世界数据模型的方程涉及更高程度的数学函数，如3的指数或sin函数。在这种情况下，模型的图给出了曲线而不是线。线性和非线性回归的目的是调整模型参数的值，以找到最接近您的数据的线或曲线。在找到这些值时，我们将能够以良好的精确度估计响应变量。
在最小二乘回归中，我们建立了一个回归模型，其中来自回归曲线的不同点的垂直距离的平方和被最小化。我们通常从定义的模型开始，并假设系数的一些值。然后我们应用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.081935Waiting for profiling to be done... 2.5% 97.5%b1 1.137708 1.253135b2 1.497364 2.496484
我们可以得出结论，b1的值更接近1，而b2的值更接近2而不是3。
决策树是以树的形式表示选择及其结果的图。图中的节点表示事件或选择，并且图的边缘表示决策规则或条件。它主要用于使用R的机器学习和数据挖掘应用程序。
决策树的使用的例子是 - 预测电子邮件是垃圾邮件或非垃圾邮件，预测肿瘤癌变，或者基于这些因素预测贷款的信用风险。通常，使用观测数据（也称为训练数据）来创建模型。然后使用一组验证数据来验证和改进模型。 R具有用于创建和可视化决策树的包。对于新的预测变量集合，我们使用此模型来确定R包“party”用于创建决策树。
在R语言控制台中使用以下命令安装软件包。您还必须安装相关软件包（如果有）。
install.packages("party")“party”包具有用于创建和分析决策树的函数ctree()。
在R中创建决策树的基本语法是 -
ctree(formula, data)
以下是所使用的参数的描述 -
formula是描述预测变量和响应变量的公式。
data是所使用的数据集的名称。
我们将使用名为readingSkills的R内置数据集来创建决策树。 它描述了某人的readingSkills的分数，如果我们知道变量“年龄”，“shoesize”，“分数”，以及该人是否为母语者。
这里是示例数据。
# Load the party package. It will automatically load other dependent packages.library(party)# Print some records from data set readingSkills.print(head(readingSkills))
当我们执行上面的代码，它产生以下结果及图表 -
nativeSpeaker age shoeSize score1 yes 5 24.83189 32.293852 yes 6 25.95238 36.631053 no 11 30.42170 49.605934 yes 7 28.66450 40.284565 yes 11 31.88207 55.460856 yes 10 30.07843 52.83124Loading required package: methodsLoading 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: methodsLoading required package: gridLoading required package: mvtnormLoading required package: modeltoolsLoading required package: stats4Loading required package: strucchangeLoading required package: zooAttaching package: ‘zoo’The following objects are masked from ‘package:base’: as.Date, as.Date.numericLoading required package: sandwich
从上面显示的决策树，我们可以得出结论，其readingSkills分数低于38.3和年龄超过6的人不是一个母语者。
在随机森林方法中，创建大量的决策树。 每个观察被馈入每个决策树。 每个观察的最常见的结果被用作最终输出。 新的观察结果被馈入所有的树并且对每个分类模型取多数投票。
对构建树时未使用的情况进行错误估计。 这称为OOB（袋外）误差估计，其被提及为百分比。
R语言包“randomForest”用于创建随机森林。
在R语言控制台中使用以下命令安装软件包。 您还必须安装相关软件包（如果有）。
install.packages("randomForest")包“randomForest”具有函数randomForest()，用于创建和分析随机森林。
在R语言中创建随机森林的基本语法是 -
randomForest(formula, data)
以下是所使用的参数的描述 -
formula是描述预测变量和响应变量的公式。
data是所使用的数据集的名称。
我们将使用名为readingSkills的R语言内置数据集来创建决策树。 它描述了某人的readingSkills的分数，如果我们知道变量“age”，“shoesize”，“score”，以及该人是否是母语。
以下是示例数据。
# Load the party package. It will automatically load other required packages.library(party)# Print some records from data set readingSkills.print(head(readingSkills))
当我们执行上面的代码，它产生以下结果及图表 -
nativeSpeaker age shoeSize score1 yes 5 24.83189 32.293852 yes 6 25.95238 36.631053 no 11 30.42170 49.605934 yes 7 28.66450 40.284565 yes 11 31.88207 55.460856 yes 10 30.07843 52.83124Loading required package: methodsLoading 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(output.forest,type = 2))
当我们执行上面的代码，它产生以下结果 -
Call: randomForest(formula = nativeSpeaker ~ age + shoeSize + score, data = readingSkills) Type of random forest: classification Number of trees: 500No. of variables tried at each split: 1 OOB estimate of error rate: 1%Confusion matrix: no yes class.errorno 99 1 0.01yes 1 99 0.01 MeanDecreaseGiniage 13.95406shoeSize 18.91006score 56.73051
从上面显示的随机森林，我们可以得出结论，鞋码和成绩是决定如果某人是母语者或不是母语的重要因素。 此外，该模型只有1%的误差，这意味着我们可以预测精度为99%。
生存分析处理预测特定事件将要发生的时间。 它也被称为故障时间分析或分析死亡时间。 例如，预测患有癌症的人将存活的天数或预测机械系统将失败的时间。
命名为survival的R语言包用于进行生存分析。 此包包含函数Surv（），它将输入数据作为R语言公式，并在选择的变量中创建一个生存对象用于分析。 然后我们使用函数survfit()创建一个分析图。
install.packages("survival")在R语言中创建生存分析的基本语法是 -
Surv(time,event)survfit(formula)
以下是所使用的参数的描述 -
time是直到事件发生的跟踪时间。
event指示预期事件的发生的状态。
formula是预测变量之间的关系。
我们将考虑在上面安装的生存包中存在的名为“pbc”的数据集。 它描述了关于受肝原发性胆汁性肝硬化（PBC）影响的人的生存数据点。 在数据集中存在的许多列中，我们主要关注字段“time”和“status”。 时间表示在接受肝移植或患者死亡的患者的登记和事件的较早之间的天数。
# Load the library.library("survival")# Print first few rows.print(head(pbc))当我们执行上面的代码，它产生以下结果及图表 -
id time status trt age sex ascites hepato spiders edema bili chol1 1 400 2 1 58.76523 f 1 1 1 1.0 14.5 2612 2 4500 0 1 56.44627 f 0 1 1 0.0 1.1 3023 3 1012 2 1 70.07255 m 0 0 0 0.5 1.4 1764 4 1925 2 1 54.74059 f 0 1 1 0.5 1.8 2445 5 1504 1 2 38.10541 f 0 1 1 0.0 3.4 2796 6 2503 2 2 66.25873 f 0 1 0 0.0 0.8 248 albumin copper alk.phos ast trig platelet protime stage1 2.60 156 1718.0 137.95 172 190 12.2 42 4.14 54 7394.8 113.52 88 221 10.6 33 3.48 210 516.0 96.10 55 151 12.0 44 2.54 64 6121.8 60.63 92 183 10.3 45 3.53 143 671.0 113.15 72 136 10.9 36 3.98 50 944.0 93.00 63 NA 11.0 3
从上述数据，我们正在考虑分析的时间和状态。
现在我们继续应用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
上图中的趋势有助于我们预测在特定天数结束时的生存概率。
卡方检验是一种确定两个分类变量之间是否存在显着相关性的统计方法。 这两个变量应该来自相同的人口，他们应该是类似 - 是/否，男/女，红/绿等。
例如，我们可以建立一个观察人们的冰淇淋购买模式的数据集，并尝试将一个人的性别与他们喜欢的冰淇淋的味道相关联。 如果发现相关性，我们可以通过了解访问的人的性别的数量来计划适当的味道库存。
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 testdata: car.dataX-squared = 33.001, df = 10, p-value = 0.0002723Warning message:In chisq.test(car.data) : Chi-squared approximation may be incorrect
结果显示p值小于0.05，这表明字符串相关。
R语言是用于统计分析，图形表示和报告的编程语言和软件环境。 R由Ross Ihaka和Robert Gentleman在新西兰奥克兰大学创建，目前由R开发核心团队开发。 R在GNU通用公共许可证下免费提供，并为各种操作系统（如Linux，Windows和Mac）提供预编译的二进制版本。 这种编程语言基于两个R语言作者（Robert Gentleman和Ross Ihaka）的名字的第一个字母命名为R语言。
尊敬的读者，这些R语言面试题是专门设计的，以便您应对在R语言相关面试中可能会被问到的问题。 根据我的经验，良好的面试官几乎不打算在你的面试中问任何特定的问题，通常都是以如下的问题为开端进一步展开后继的问题。
什么是R语言编程？
R语言是一种用于统计分析和为此目的创建图形的编程语言。不是数据类型，它具有用于计算的数据对象。它用于数据挖掘，回归分析，概率估计等领域，使用其中可用的许多软件包。表达式M [4,2]给出了第4行和第2列的元素。
什么是向量中元素的回收？举个例子。
当在操作中涉及不同长度的两个向量时，较短向量的元素被重用以完成操作。这被称为元素循环。示例-v1 <-c（4,1,0,6）和V2 <-c（2,4），则v1 * v2给出（8,4,0,24）。重复元件2和4。
在R语言中调用函数有什么不同的方法？
我们可以用3种方式在R语言中调用一个函数。第一种方法是通过使用参数的位置来调用。第二个方法id通过使用参数的名称来调用，第三个方法是通过默认参数调用。
什么是R语言中的延迟函数评估？
函数的延迟评估意味着，只有当它在函数体内部使用时，才会评估参数。如果没有对函数体中的参数的引用，则它被简单地忽略。
如何在R语言中安装软件包？
要在R语言中安装一个包，我们使用下面的命令。
install.packages（"package Name"）installed.packages()x <- “快速的棕色狐狸跳过懒惰的狗”split.string <- strsplit(x，"")extract.words <- split.string [[1]]result <- unique(tolower(extract.words))print(result)x <- pbinom(26,51,0.5)print(x)X是向量c(5,9.2,3,8.51，NA)，mean(x)的输出是什么？NAfunction(x){x [is.na(x)] <sum(x,na.rm = TRUE); x }data(package = .packages(all.available = TRUE))15%在%xpairs(formula, data)[1] NA
R语言是用于统计分析，图形表示和报告的编程语言和软件环境。 R语言由Ross Ihaka和Robert Gentleman在新西兰奥克兰大学创建，目前由R语言开发核心团队开发。
R语言的核心是解释计算机语言，其允许分支和循环以及使用函数的模块化编程。 R语言允许与以C，C ++，.Net，Python或FORTRAN语言编写的过程集成以提高效率。
R语言在GNU通用公共许可证下免费提供，并为各种操作系统（如Linux，Windows和Mac）提供预编译的二进制版本。
R是一个在GNU风格的副本左侧的自由软件，GNU项目的官方部分叫做GNU S.
R语言最初是由新西兰奥克兰奥克兰大学统计系的Ross Ihaka和Robert Gentleman写的。 R语言于1993年首次亮相。
一大群人通过发送代码和错误报告对R做出了贡献。
自1997年年中以来，已经有一个核心组（“R核心团队”）可以修改R源代码归档。
如前所述，R语言是用于统计分析，图形表示和报告的编程语言和软件环境。 以下是R语言的重要特点：
R语言是一种开发良好，简单有效的编程语言，包括条件，循环，用户定义的递归函数以及输入和输出设施。
R语言具有有效的数据处理和存储设施，
R语言提供了一套用于数组，列表，向量和矩阵计算的运算符。
R语言为数据分析提供了大型，一致和集成的工具集合。
R语言提供直接在计算机上或在纸张上打印的图形设施用于数据分析和显示。
作为结论，R语言是世界上最广泛使用的统计编程语言。 它是数据科学家的第一选择，并由一个充满活力和有才华的贡献者社区支持。 R语言在大学教授并部署在关键业务应用程序中。 本教程将教您R编程与适当的例子在简单和容易的步骤。
如果你愿意为本地设置R语言环境，你可以按照下面的步骤。
去 R 语言下载的镜像站点的列表下载
选择版本进行下载
点击运行
进入安装界面
一路默认，安装完毕！
R语言适用于多版本的Linux系统。
各版本Linux的各有不同。具体的安装步骤在上述资源中有对应的教程。但是，如果你是在赶时间，那么你可以用yum命令，如下所示的安装指令
安装R
$ yum install R
以上命令将安装R编程的核心功能与标准包，额外的包需要另外安装，而后你可以按如下提示启动R。
$ RR version 3.2.0 (2015-04-16) -- "Full of Ingredients" Copyright (C) 2015 The R Foundation for Statistical ComputingPlatform: 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命令安装所需的软件包。 例如，以下命令将安装为3D图表所需的plotrix软件包。
> install.packages("plotrix")我们将开始学习R语言编程，首先编写一个“你好，世界！ 的程序。 根据需要，您可以在R语言命令提示符处编程，也可以使用R语言脚本文件编写程序。 让我们逐个体验不同之处。
如果你已经配置好R语言环境，那么你只需要按一下的命令便可轻易开启命令提示符
$ R
这将启动R语言解释器，你会得到一个提示 > 在那里你可以开始输入你的程序，具体如下。
> myString <- "Hello, World!"> print ( myString)[1] "Hello, World!"
在这里，第一个语句先定义一个字符串变量myString，并将“Hello，World！”赋值其中，第二句则使用print()语句将变量myString的内容进行打印。
通常，您将通过在脚本文件中编写程序来执行编程，然后在命令提示符下使用R解释器（称为Rscript）来执行这些脚本。 所以让我们开始在一个命名为test.R的文本文件中编写下面的代码
# My first program in R ProgrammingmyString <- "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)虽然上面的注释将由R解释器执行，但它们不会干扰您的实际程序。 但是你必须为内容加上单引号或双引号。
通常，在使用任何编程语言进行编程时，您需要使用各种变量来存储各种信息。 变量只是保留值的存储位置。 这意味着，当你创建一个变量，你必须在内存中保留一些空间来存储它们。
您可能想存储各种数据类型的信息，如字符，宽字符，整数，浮点，双浮点，布尔等。基于变量的数据类型，操作系统分配内存并决定什么可以存储在保留内存中。
与其他编程语言（如 C 中的 C 和 java）相反，变量不会声明为某种数据类型。 变量分配有 R 对象，R 对象的数据类型变为变量的数据类型。尽管有很多类型的 R 对象，但经常使用的是：
这些对象中最简单的是向量对象，并且这些原子向量有六种数据类型，也称为六类向量。 其他 R 对象建立在原子向量之上。
| 数据类型 | 例 | 校验 |
|---|---|---|
| Logical（逻辑型） | TRUE, FALSE | v <- TRUE print(class(v)) 它产生以下结果 - [1] "logical" |
| Numeric（数字） | 12.3，5，999 | v <- 23.5print(class(v)) 它产生以下结果 - [1] "numeric" |
| Integer（整型） | 2L，34L，0L | v <- 2Lprint(class(v)) 它产生以下结果 - [1] "integer" |
| Complex（复合型） | 3 + 2i | v <- 2+5iprint(class(v)) 它产生以下结果 - [1] "complex" |
| Character（字符） | 'a' , "good", "TRUE", '23.4' | v <- "TRUE"print(class(v)) 它产生以下结果 - [1] "character" |
| Raw（原型） | "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"
虽然矩阵被限制为二维，但阵列可以具有任何数量的维度。 数组函数使用一个 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"
# 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# applying the nlevels function we can know the number of distinct values[1] 3
# 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 Age1 Male 152.0 81 422 Male 171.5 93 383 Female 165.0 78 26
变量为我们提供了我们的程序可以操作的命名存储。 R语言中的变量可以存储原子向量，原子向量组或许多Robject的组合。 有效的变量名称由字母，数字和点或下划线字符组成。 变量名以字母或不以数字后跟的点开头。
| 变量名 | 合法性 | 原因 |
|---|---|---|
| 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 ,"")cat ("var.2 is ", var.2 ,"")cat ("var.3 is ", var.3 ,"")当我们执行上面的代码，它产生以下结果 -
[1] 0 1 2 3var.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),"")var_x <- 34.5cat(" Now the class of var_x is ",class(var_x),"")var_x <- 27Lcat(" Next the class of var_x becomes ",class(var_x),"")当我们执行上面的代码，它产生以下结果 -
The class of var_x is character Now the class of var_x is numeric Next the class of var_x becomes integer
要知道工作空间中当前可用的所有变量，我们使用ls()函数。 ls()函数也可以使用模式来匹配变量名。
print(ls())
当我们执行上面的代码，它产生以下结果 -
[1] "my var" "my_new_var" "my_var" "var.1" [5] "var.2" "var.3" "var.name" "var_name2."[9] "var_x" "varname"
注意 - 它是一个示例输出，取决于在您的环境中声明的变量。
ls()函数可以使用模式来匹配变量名。
# List the variables starting with the pattern "var".print(ls(pattern = "var"))
当我们执行上面的代码，它产生以下结果 -
[1] "my var" "my_new_var" "my_var" "var.1" [5] "var.2" "var.3" "var.name" "var_name2."[9] "var_x" "varname"
以点(.)开头的变量被隐藏，它们可以使用ls()函数的“all.names = TRUE”参数列出。
print(ls(all.name = TRUE))
当我们执行上面的代码，它产生以下结果 -
[1] ".cars" ".Random.seed" ".var_name" ".varname" ".varname2" [6] "my var" "my_new_var" "my_var" "var.1" "var.2" [11]"var.3" "var.name" "var_name2." "var_x"
可以使用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语言支持的算术运算符。 操作符对向量的每个元素起作用。
| 运算符 | 描述 | 例 |
|---|---|---|
| + | 两个向量相加 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v+t) 它产生以下结果 - 10.0 8.5 10.0 |
| - | 两个向量相减 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v-t) 它产生以下结果 - -6.0 2.5 2.0 |
| * | 两个向量相乘 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v*t) 它产生以下结果 - 16.0 16.5 24.0 |
| / | 将第一个向量与第二个向量相除 | v <- c( 2,5.5,6)t <- c(8, 3, 4)print(v/t) 当我们执行上面的代码，它产生以下结果 - 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) 它产生以下结果 - FALSE TRUE FALSE FALSE |
| < | 检查第一个向量的每个元素是否小于第二个向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v < t) 它产生以下结果 - TRUE FALSE TRUE FALSE |
| == | 检查第一个向量的每个元素是否等于第二个向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v == t) 它产生以下结果 - FALSE FALSE FALSE TRUE |
| <= | 检查第一向量的每个元素是否小于或等于第二向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v<=t) 它产生以下结果 - TRUE FALSE TRUE TRUE |
| > = | 检查第一向量的每个元素是否大于或等于第二向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v>=t) 它产生以下结果 - FALSE TRUE FALSE TRUE |
| != | 检查第一个向量的每个元素是否不等于第二个向量的相应元素。 | v <- c(2,5.5,6,9)t <- c(8,2.5,14,9)print(v!=t) 它产生以下结果 - TRUE TRUE TRUE FALSE |
| 运算符 | 描述 | 例 |
|---|---|---|
| & | 它被称为元素逻辑AND运算符。 它将第一向量的每个元素与第二向量的相应元素组合，并且如果两个元素都为TRUE，则给出输出TRUE。 | v <- c(3,1,TRUE,2+3i)t <- c(4,1,FALSE,2+3i)print(v&t) 它产生以下结果 - TRUE TRUE FALSE TRUE |
| | | 它被称为元素逻辑或运算符。 它将第一向量的每个元素与第二向量的相应元素组合，并且如果元素为真，则给出输出TRUE。 | v <- c(3,0,TRUE,2+2i)t <- c(4,0,FALSE,2+3i)print(v|t) 它产生以下结果 - TRUE FALSE TRUE TRUE |
| ! | 它被称为逻辑非运算符。 取得向量的每个元素，并给出相反的逻辑值。 | v <- c(3,0,TRUE,2+2i)print(!v) 它产生以下结果 - FALSE TRUE FALSE FALSE |
逻辑运算符&&和|| 只考虑向量的第一个元素，给出单个元素的向量作为输出。
| 运算符 | 描述 | 例 |
|---|---|---|
| && | 称为逻辑AND运算符。 取两个向量的第一个元素，并且只有两个都为TRUE时才给出TRUE。 | v <- c(3,0,TRUE,2+2i)t <- c(1,3,TRUE,2+3i)print(v&&t) 它产生以下结果 - TRUE |
| || | 称为逻辑OR运算符。 取两个向量的第一个元素，如果其中一个为TRUE，则给出TRUE。 | v <- c(0,0,TRUE,2+2i)t <- c(0,3,TRUE,2+3i)print(v||t) 它产生以下结果 - FALSE |
这些运算符用于向向量赋值。
| 运算符 | 描述 | 例 |
|---|---|---|
<− or = or <<−
| 称为左分配 | 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) 它产生以下结果 - 3+0i 1+0i 1+0i 2+3i3+0i 1+0i 1+0i 2+3i3+0i 1+0i 1+0i 2+3i |
-> or ->>
| 称为右分配 | c(3,1,TRUE,2+3i) -> v1c(3,1,TRUE,2+3i) ->> v2 print(v1)print(v2) 它产生以下结果 - 3+0i 1+0i 1+0i 2+3i3+0i 1+0i 1+0i 2+3i |
这些运算符用于特定目的，而不是一般的数学或逻辑计算。
| 运算符 | 描述 | 例 |
|---|---|---|
| : | 冒号运算符。 它为向量按顺序创建一系列数字。 | v <- 2:8print(v) 它产生以下结果 - 2 3 4 5 6 7 8 |
| %in% | 此运算符用于标识元素是否属于向量。 | v1 <- 8v2 <- 12t <- 1:10print(v1 %in% t) print(v2 %in% t) 它产生以下结果 - TRUEFALSE |
| %*% | 此运算符用于将矩阵与其转置相乘。 | 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提供以下类型的决策语句。 单击以下链接以检查其详细信息。
| Sr.No. | 声明和描述 |
|---|---|
| 1 | if语句 if语句由一个布尔表达式后跟一个或多个语句组成。 |
| 2 | if ... else语句 if语句后面可以有一个可选的else语句，当布尔表达式为false时执行。 |
| 3 | switch语句 switch语句允许根据值列表测试变量的相等性。 |
R语言的包是R函数，编译代码和样本数据的集合。 它们存储在R语言环境中名为“library”的目录下。 默认情况下，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 Packageboot Bootstrap Functions (Originally by Angelo Canty for S)class Functions for Classificationcluster "Finding Groups in Data": Cluster Analysis Extended Rousseeuw et al.codetools Code Analysis Tools for Rcompiler The R Compiler Package
获取当前在R环境中加载的所有包
search()
当我们执行上述代码时，它产生了以下结果。它会根据你的个人电脑的本地设置而异。
[1] ".GlobalEnv" "package:stats" "package:graphics" [4] "package:grDevices" "package:utils" "package:datasets" [7] "package:methods" "Autoloads" "package:base"
有两种方法来添加新的R包。 一个是直接从CRAN目录安装，另一个是将软件包下载到本地系统并手动安装它。
以下命令直接从CRAN网页获取软件包，并将软件包安装在R环境中。 可能会提示您选择最近的镜像。 根据您的位置选择一个。
install.packages("Package Name") # Install the package named "XML". install.packages("XML")
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编程语言提供以下种类的循环来处理循环需求。 单击以下链接以检查其详细信息。
| Sr.No. | 循环类型和描述 |
|---|---|
| 1 | repeat循环 多次执行一系列语句，并简化管理循环变量的代码。 |
| 2 | while循环 在给定条件为真时，重复语句或语句组。 它在执行循环体之前测试条件。 |
| 3 | for循环 像while语句，不同之处在于它测试在循环体的端部的条件。 |
| Sr.No. | 控制语句和描述 |
|---|---|
| 1 | break语句 终止循环语句，并将执行转移到循环后立即执行的语句。 |
| 2 | next语句 next语句模拟R语言switch语句的行为。 |
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") # Print the data frame.print(addresses)# Create another data frame with similar columnsnew.address <- data.frame( city = c("Lowry","Charlotte"), state = c("CO","FL"), zipcode = c("80230","33949"), stringsAsFactors = FALSE)# Print a header.cat("# # # The Second data frame") # Print the data frame.print(new.address)# Combine rows form both the data frames.all.addresses <- rbind(addresses,new.address)# Print a header.cat("# # # The combined data frame") # Print the result.print(all.addresses)当我们执行上面的代码，它产生以下结果 -
# # # # The First data frame city state zipcode[1,] "Tampa" "FL" "33602"[2,] "Seattle" "WA" "98104"[3,] "Hartford" "CT" "6161" [4,] "Denver" "CO" "80294"# # # The Second data frame city state zipcode1 Lowry CO 802302 Charlotte FL 33949# # # The combined data frame city state zipcode1 Tampa FL 336022 Seattle WA 981043 Hartford CT 61614 Denver CO 802945 Lowry CO 802306 Charlotte FL 33949
我们可以使用 merge() 函数合并两个数据帧。 数据帧必须具有相同的列名称，在其上进行合并。
在下面的例子中，我们考虑 library 名称“MASS”中有关 Pima Indian Women 的糖尿病的数据集。 我们基于血压（“bp”）和体重指数（“bmi”）的值合并两个数据集。 在选择这两列用于合并时，其中这两个变量的值在两个数据集中匹配的记录被组合在一起以形成单个数据帧。
library(MASS)merged.Pima <- merge(x = Pima.te, y = Pima.tr, by.x = c("bp", "bmi"), by.y = c("bp", "bmi"))print(merged.Pima)nrow(merged.Pima)当我们执行上面的代码，它产生以下结果 -
bp bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y1 60 33.8 1 117 23 0.466 27 No 2 125 20 0.0882 64 29.7 2 75 24 0.370 33 No 2 100 23 0.3683 64 31.2 5 189 33 0.583 29 Yes 3 158 13 0.2954 64 33.2 4 117 27 0.230 24 No 1 96 27 0.2895 66 38.1 3 115 39 0.150 28 No 1 114 36 0.2896 68 38.5 2 100 25 0.324 26 No 7 129 49 0.4397 70 27.4 1 116 28 0.204 21 No 0 124 20 0.2548 70 33.1 4 91 32 0.446 22 No 9 123 44 0.3749 70 35.4 9 124 33 0.282 34 No 6 134 23 0.54210 72 25.6 1 157 21 0.123 24 No 4 99 17 0.29411 72 37.7 5 95 33 0.370 27 No 6 103 32 0.32412 74 25.9 9 134 33 0.460 81 No 8 126 38 0.16213 74 25.9 1 95 21 0.673 36 No 8 126 38 0.16214 78 27.6 5 88 30 0.258 37 No 6 125 31 0.56515 78 27.6 10 122 31 0.512 45 No 6 125 31 0.56516 78 39.4 2 112 50 0.175 24 No 4 112 40 0.23617 88 34.5 1 117 24 0.403 40 Yes 4 127 11 0.598 age.y type.y1 31 No2 21 No3 24 No4 21 No5 21 No6 43 Yes7 36 Yes8 40 No9 29 Yes10 28 No11 55 No12 39 No13 39 No14 49 Yes15 49 Yes16 38 No17 28 No[1] 17
Status Age V1 V2 V3 V4 P 23646 45190 50333 55166 56271 CC 26174 35535 38227 37911 41184 CC 27723 25691 25712 26144 26398 CC 27193 30949 29693 29754 30772 CC 24370 50542 51966 54341 54273 CC 28359 58591 58803 59435 61292 CC 25136 45801 45389 47197 47126zz <- read.csv("mr.csv", strip.white = TRUE)zzz <- cbind(zz[gl(nrow(zz), 1, 4*nrow(zz)), 1:2], stack(zz[, 3:6])) Status Age values indX1 P 23646 45190 V1X2 CC 26174 35535 V1X3 CC 27723 25691 V1X4 CC 27193 30949 V1X5 CC 24370 50542 V1X6 CC 28359 58591 V1X7 CC 25136 45801 V1X11 P 23646 50333 V2...> reshape(zz, idvar="id",timevar="var", varying=list(c("V1","V2","V3","V4")),direction="long") Status Age var V1 id1.1 P 23646 1 45190 12.1 CC 26174 1 35535 23.1 CC 27723 1 25691 34.1 CC 27193 1 30949 45.1 CC 24370 1 50542 56.1 CC 28359 1 58591 67.1 CC 25136 1 45801 71.2 P 23646 2 50333 12.2 CC 26174 2 38227 2...函数是一组组合在一起以执行特定任务的语句。 R 语言具有大量内置函数，用户可以创建自己的函数。
在R语言中，函数是一个对象，因此R语言解释器能够将控制传递给函数，以及函数完成动作所需的参数。
该函数依次执行其任务并将控制返回到解释器以及可以存储在其他对象中的任何结果。
使用关键字函数创建 R 语言的函数。 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 from 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] 6Error in print(b) : argument "b" is missing, with no default
向量是最基本的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:13print(v)# Creating a sequence from 6.6 to 12.6.v <- 6.6:12.6print(v)# If the final element specified does not belong to the sequence then it is discarded.v <- 3.8:11.4print(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
使用sequence (Seq.)序列运算符
# Create vector with elements from 5 to 9 incrementing by 0.4.print(seq(5, 9, by = 0.4))
当我们执行上面的代码，它产生以下结果 -
[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0
使用C()函数
如果其中一个元素是字符，则非字符值被强制转换为字符类型。
# The logical and numeric values are converted to characters.s <- c('apple','red',5,TRUE)print(s)当我们执行上面的代码，它产生以下结果 -
[1] "apple" "red" "5" "TRUE"
使用索引访问向量的元素。 []括号用于建立索引。 索引从位置1开始。在索引中给出负值会丢弃来自result.TRUE，FALSE或0和1的元素，也可用于索引。
# Accessing vector elements using position.t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")u <- t[c(2,3,6)]print(u)# Accessing vector elements using logical indexing.v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]print(v)# Accessing vector elements using negative indexing.x <- t[c(-2,-5)]print(x)# Accessing vector elements using 0/1 indexing.y <- t[c(0,0,0,0,0,0,1)]print(y)当我们执行上面的代码，它产生以下结果 -
[1] "Mon" "Tue" "Fri"[1] "Sun" "Fri"[1] "Sun" "Tue" "Wed" "Fri" "Sat"[1] "Sat"
可以添加，减去，相乘或相除两个相同长度的向量，将结果作为向量输出。
# Create two vectors.v1 <- c(3,8,4,5,0,11)v2 <- c(4,11,0,8,1,2)# Vector addition.add.result <- v1+v2print(add.result)# Vector substraction.sub.result <- v1-v2print(sub.result)# Vector multiplication.multi.result <- v1*v2print(multi.result)# Vector division.divi.result <- v1/v2print(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+v2print(add.result)sub.result <- v1-v2print(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语言对象，它包含不同类型的元素，如数字，字符串，向量和其中的另一个列表。 列表还可以包含矩阵或函数作为其元素。 列表是使用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"$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 vectorsresult <- v1+v2print(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对象。 它们包含相同原子类型的元素。 虽然我们可以创建一个只包含字符或只包含逻辑值的矩阵，但它们没有太多用处。 我们使用包含数字元素的矩阵用于数学计算。
使用matrix()函数创建一个矩阵。
在R语言中创建矩阵的基本语法是 -
matrix(data, nrow, ncol, byrow, dimnames)
以下是所使用的参数的说明 -
数据是成为矩阵的数据元素的输入向量。
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 col3row1 3 4 5row2 6 7 8row3 9 10 11row4 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] 13col1 col2 col3 6 7 8 row1 row2 row3 row4 5 8 11 14
# 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 + matrix2cat("Result of addition","")print(result)# Subtract the matricesresult <- matrix1 - matrix2cat("Result of subtraction","")print(result)当我们执行上面的代码，它产生以下结果 -
[,1] [,2] [,3][1,] 3 -1 2[2,] 9 4 6 [,1] [,2] [,3][1,] 5 0 3[2,] 2 9 4Result of addition [,1] [,2] [,3][1,] 8 -1 5[2,] 11 13 10Result 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 * matrix2cat("Result of multiplication","")print(result)# Divide the matricesresult <- matrix1 / matrix2cat("Result of division","")print(result)当我们执行上面的代码，它产生以下结果 -
[,1] [,2] [,3][1,] 3 -1 2[2,] 9 4 6 [,1] [,2] [,3][1,] 5 0 3[2,] 2 9 4Result of multiplication [,1] [,2] [,3][1,] 15 0 6[2,] 18 36 24Result of division [,1] [,2] [,3][1,] 0.6 -Inf 0.6666667[2,] 4.5 0.4444444 1.5000000
以下示例创建一个由两个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 COL3ROW1 5 10 13ROW2 9 11 14ROW3 3 12 15, , Matrix2 COL1 COL2 COL3ROW1 5 10 13ROW2 9 11 14ROW3 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 COL3ROW1 5 10 13ROW2 9 11 14ROW3 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+matrix2print(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
# 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 NorthLevels: 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 gender1 132 48 male2 151 49 male3 162 66 female4 139 53 female5 166 67 male6 147 52 female7 122 40 male[1] TRUE[1] male male female female male female male Levels: female male
可以通过使用新的等级次序再次应用因子函数来改变因子中的等级的顺序。
data <- c("East","West","East","North","North","East","West","West","West","East","North")# Create the factorsfactor_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 NorthLevels: East North West [1] East West East North North East West West West East NorthLevels: 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
# 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_date1 1 Rick 623.30 2012-01-012 2 Dan 515.20 2013-09-233 3 Michelle 611.00 2014-11-154 4 Ryan 729.00 2014-05-115 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.salary1 Rick 623.302 Dan 515.203 Michelle 611.004 Ryan 729.005 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_date1 1 Rick 623.3 2012-01-012 2 Dan 515.2 2013-09-23
用第2和第4列提取第3和第5行
# Create the data frame.emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE)# Extract 3rd and 5th row with 2nd and 4th column.result <- emp.data[c(3,5),c(2,4)]print(result)当我们执行上面的代码，它产生以下结果 -
emp_name start_date3 Michelle 2014-11-155 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.dataprint(v)当我们执行上面的代码，它产生以下结果 -
emp_id emp_name salary start_date dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 5 Gary 843.25 2015-03-27 Finance
# 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 frameemp.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 dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 5 Gary 843.25 2015-03-27 Finance6 6 Rasmi 578.00 2013-05-21 IT7 7 Pranab 722.50 2013-07-30 Operations8 8 Tusar 632.80 2014-06-17 Fianance
条形图表示矩形条中的数据，条的长度与变量的值成比例。 R语言使用函数 barplot() 创建条形图。 R 语言可以在条形图中绘制垂直和水平条。 在条形图中，每个条可以给予不同的颜色。
在 R 语言中创建条形图的基本语法是 -
barplot(H, xlab, ylab, main, names.arg, col)
以下是所使用的参数的描述 -
H 是包含在条形图中使用的数值的向量或矩阵。
xlab 是 x 轴的标签。
ylab 是 y 轴的标签。
main 是条形图的标题。
names.arg 是在每个条下出现的名称的向量。
col 用于向图中的条形提供颜色。
# 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()
当我们执行上面的代码，它产生以下结果 -
可以通过添加更多参数来扩展条形图的功能。 主要参数用于添加标题。 col 参数用于向条形添加颜色。 name.args 是具有与输入向量相同数量的值的向量，以描述每个条的含义。
以下脚本将在当前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语言中使用boxplot()函数来创建箱线图。
在R语言中创建箱线图的基本语法是 -
boxplot(x, data, notch, varwidth, names, main)
以下是所使用的参数的描述 -
x是向量或公式。
数据是数据帧。
notch是逻辑值。 设置为TRUE以绘制凹口。
varwidth是一个逻辑值。 设置为true以绘制与样本大小成比例的框的宽度。
names是将打印在每个箱线图下的组标签。
main用于给图表标题。
我们使用R语言环境中可用的数据集“mtcars”来创建基本箱线图。 让我们看看mtcars中的列“mpg”和“cyl”。
input <- mtcars[,c('mpg','cyl')]print(head(input))当我们执行上面的代码，它会产生以下结果 -
mpg cylMazda RX4 21.0 6Mazda RX4 Wag 21.0 6Datsun 710 22.8 4Hornet 4 Drive 21.4 6Hornet Sportabout 18.7 8Valiant 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语言使用hist()函数创建直方图。 此函数使用向量作为输入，并使用一些更多的参数来绘制直方图。
使用R语言创建直方图的基本语法是 -
hist(v,main,xlab,xlim,ylim,breaks,col,border)
以下是所使用的参数的描述 -
v是包含直方图中使用的数值的向量。
main表示图表的标题。
col用于设置条的颜色。
border用于设置每个条的边框颜色。
xlab用于给出x轴的描述。
xlim用于指定x轴上的值的范围。
ylim用于指定y轴上的值的范围。
break用于提及每个条的宽度。
使用输入vector，label，col和边界参数创建一个简单的直方图。
下面给出的脚本将创建并保存当前R语言工作目录中的直方图。
# Create data for the graph.v <- c(9,13,21,8,36,22,12,41,31,33,19)# Give the chart file a name.png(file = "histogram.png")# Create the histogram.hist(v,xlab = "Weight",col = "yellow",border = "blue")# Save the file.dev.off()
当我们执行上面的代码，它产生以下结果 -
要指定X轴和Y轴允许的值的范围，我们可以使用 xlim 和 ylim 参数。
每个条的宽度可以通过使用间隔来确定。
# Create data for the graph.v <- c(9,13,21,8,36,22,12,41,31,33,19)# Give the chart file a name.png(file = "histogram_lim_breaks.png")# Create the histogram.hist(v,xlab = "Weight",col = "green",border = "red", xlim = c(0,40), ylim = c(0,5), breaks = 5)# Save the file.dev.off()
当我们执行上面的代码，它产生以下结果 -
折线图是通过在它们之间绘制线段来连接一系列点的图。 这些点在它们的坐标（通常是x坐标）值之一中排序。 折线图通常用于识别数据中的趋势。
R语言中的plot()函数用于创建折线图。
在R语言中创建折线图的基本语法是 -
plot(v,type,col,xlab,ylab)
以下是所使用的参数的描述 -
v是包含数值的向量。
类型采用值“p”仅绘制点，“l”仅绘制线和“o”绘制点和线。
xlab是x轴的标签。
ylab是y轴的标签。
main是图表的标题。
col用于给点和线的颜色。
使用输入向量和类型参数“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()
当我们执行上面的代码，它产生以下结果 -
# 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(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 mpgMazda RX4 2.620 21.0Mazda RX4 Wag 2.875 21.0Datsun 710 2.320 22.8Hornet 4 Drive 3.215 21.4Hornet Sportabout 3.440 18.7Valiant 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语言创建饼图的基本语法是 -
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.jpg")# 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()当我们执行上面的代码，它产生以下结果 -
可以使用其他软件包绘制具有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 语言环境外的文件中读取数据。 我们还可以将数据写入将被操作系统存储和访问的文件。 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 文件是一个文本文件，其中列中的值由逗号分隔。 让我们考虑名为input.csv的文件中出现的以下数据。
您可以通过复制和粘贴此数据使用 Windows 记事本创建此文件。 使用记事本中的保存为所有文件（*.*）选项将文件保存为input.csv。
id,name,salary,start_date,dept1,Rick,623.3,2012-01-01,IT2,Dan,515.2,2013-09-23,Operations3,Michelle,611,2014-11-15,IT4,Ryan,729,2014-05-11,HR ,Gary,843.25,2015-03-27,Finance6,Nina,578,2013-05-21,IT7,Simon,632.8,2013-07-30,Operations8,Guru,722.5,2014-06-17,Finance
以下是read.csv()函数的一个简单示例，用于读取当前工作目录中可用的 CSV 文件 -
data <- read.csv("input.csv")print(data)当我们执行上面的代码，它产生以下结果 -
id, name, salary, start_date, dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
默认情况下，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 dept5 NA Gary 843.25 2015-03-27 Finance
# Create a data frame.data <- read.csv("input.csv")retval <- subset( data, dept == "IT")print(retval)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept1 1 Rick 623.3 2012-01-01 IT3 3 Michelle 611.0 2014-11-15 IT6 6 Nina 578.0 2013-05-21 IT
# Create a data frame.data <- read.csv("input.csv")info <- subset(data, salary > 600 & dept == "IT")print(info)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept1 1 Rick 623.3 2012-01-01 IT3 3 Michelle 611.0 2014-11-15 IT
# 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 dept3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance8 8 Guru 722.50 2014-06-17 Finance
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 dept1 3 3 Michelle 611.00 2014-11-15 IT2 4 4 Ryan 729.00 2014-05-11 HR3 5 NA Gary 843.25 2015-03-27 Finance4 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 dept1 3 Michelle 611.00 2014-11-15 IT2 4 Ryan 729.00 2014-05-11 HR3 NA Gary 843.25 2015-03-27 Finance4 8 Guru 722.50 2014-06-17 Finance
Microsoft Excel是最广泛使用的电子表格程序，以.xls或.xlsx格式存储数据。 R语言可以直接从这些文件使用一些excel特定的包。 很少这样的包是 - XLConnect，xlsx，gdata等。我们将使用xlsx包。 R语言也可以使用这个包写入excel文件。
您可以在R控制台中使用以下命令来安装“xlsx”软件包。 它可能会要求安装一些额外的软件包这个软件包依赖。 按照具有所需软件包名称的同一命令安装其他软件包。
install.packages("xlsx")使用以下命令验证并加载“xlsx”软件包。
# Verify the package is installed.any(grepl("xlsx",installed.packages()))# Load the library into R workspace.library("xlsx")当脚本运行，我们得到以下输出。
[1] TRUELoading required package: rJavaLoading required package: methodsLoading required package: xlsxjars
打开Microsoft Excel。 将以下数据复制并粘贴到名为sheet1的工作表中。
id name salary start_date dept1 Rick 623.3 1/1/2012 IT2 Dan 515.2 9/23/2013 Operations3 Michelle 611 11/15/2014 IT4 Ryan 729 5/11/2014 HR5 Gary 843.25 3/27/2015 Finance6 Nina 578 5/21/2013 IT7 Simon 632.8 7/30/2013 Operations8 Guru 722.5 6/17/2014 Finance
还要将以下数据复制并粘贴到另一个工作表，并将此工作表重命名为“city”。
name cityRick SeattleDan TampaMichelle ChicagoRyan SeattleGary HoustonNina BostonSimon MumbaiGuru Dallas
将Excel文件另存为“input.xlsx”。 应将其保存在R工作区的当前工作目录中。
通过使用read.xlsx()函数读取input.xlsx，如下所示。 结果作为数据帧存储在R语言环境中。
# Read the first worksheet in the file input.xlsx.data <- read.xlsx("input.xlsx", sheetIndex = 1)print(data)当我们执行上面的代码，它产生以下结果 -
id, name, salary, start_date, dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
二进制文件是包含仅以位和字节（0和1）的形式存储的信息的文件。它们不是人类可读的，因为它中的字节转换为包含许多其他不可打印字符的字符和符号。尝试使用任何文本编辑器读取二进制文件将显示如Ø和ð的字符。
二进制文件必须由特定程序读取才能使用。例如，Microsoft Word程序的二进制文件只能通过Word程序读取到人类可读的形式。这表示，除了人类可读的文本之外，还有更多的信息，例如字符和页码等的格式化，它们也与字母数字字符一起存储。最后一个二进制文件是一个连续的字节序列。我们在文本文件中看到的换行符是连接第一行到下一行的字符。
有时，由其他程序生成的数据需要由R作为二进制文件处理。另外，R语言是创建可以与其他程序共享的二进制文件所必需的。
R语言有两个函数WriteBin()和readBin()来创建和读取二进制文件。
writeBin(object, con)readBin(con, what, n )
以下是所使用的参数的描述 -
con 是读取或写入二进制文件的连接对象。
object 是要写入的二进制文件。
what - 是像字符，整数等代表字节模式被读取。
n 是从二进制文件读取的字节数。
我们考虑R语言内置数据“mtcars”。 首先，我们从它创建一个csv文件，并将其转换为二进制文件，并将其存储为操作系统文件。 接下来我们读取这个创建的二进制文件。
我们将数据帧“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.namesprint(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中的二进制文件得到原始数据。
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文件由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
# 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文件中的数据作为数据框读取。 然后处理数据帧以进行数据分析。
# 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 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
由于数据现在可以作为数据帧，我们可以使用数据帧相关函数来读取和操作文件。
JSON文件以人类可读格式将数据存储为文本。 Json代表JavaScript Object Notation。 R可以使用rjson包读取JSON文件。
在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文件由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"
我们可以使用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, dept1 1 Rick 623.30 2012-01-01 IT2 2 Dan 515.20 2013-09-23 Operations3 3 Michelle 611.00 2014-11-15 IT4 4 Ryan 729.00 2014-05-11 HR5 NA Gary 843.25 2015-03-27 Finance6 6 Nina 578.00 2013-05-21 IT7 7 Simon 632.80 2013-07-30 Operations8 8 Guru 722.50 2014-06-17 Finance
许多网站提供数据供其用户使用。 例如，世界卫生组织（WHO）以CSV，txt和XML文件的形式提供健康和医疗信息的报告。 使用R语言程序，我们可以从这些网站以编程方式提取特定数据。 R语言中用于从网站中提取数据的一些包是“RCurl”，XML“和”stringr“，它们用于连接到URL，识别文件所需的链接并将它们下载到本地环境。
处理URL和链接到文件需要以下的包。 如果它们在R语言环境中不可用，您可以使用以下命令安装它们。
install.packages("RCurl")install.packages("XML")install.packages("stringr")install.packages("plyr")我们将访问URL天气数据，并使用R在2015年下载CSV文件。
我们将使用函数getHTMLLinks()来收集文件的URL。 然后我们将使用函数downlaod.file()将文件保存到本地系统。 由于我们将对多个文件一次又一次地应用相同的代码，因此我们将创建一个被多次调用的函数。 文件名作为参数以R列表对象的形式传递到此函数。
# Read the URL.url <- "http://www.geos.ed.ac.uk/~weather/jcmb_ws/"# Gather the html links present in the webpage.links <- getHTMLLinks(url)# Identify only the links which point to the JCMB 2015 files. filenames <- links[str_detect(links, "JCMB_2015")]# Store the file names as a list.filenames_list <- as.list(filenames)# Create a function to download the files by passing the URL and filename list.downloadcsv <- function (mainurl,filename) { filedetails <- str_c(mainurl,filename) download.file(filedetails,filename)}# Now apply the l_ply function and save the files into the current R working directory.l_ply(filenames,downloadcsv,mainurl = "http://www.geos.ed.ac.uk/~weather/jcmb_ws/")运行上述代码后，您可以在当前R语言工作目录中找到以下文件。
"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv" "JCMB_2015_Mar.csv"
R语言有一个名为“RMySQL”的内置包，它提供与MySql数据库之间的本地连接。 您可以使用以下命令在R语言环境中安装此软件包。
install.packages("RMySQL")一旦安装了包，我们在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.frame)
当我们执行上面的代码，它产生以下结果 -
actor_id first_name last_name last_update1 1 PENELOPE GUINESS 2006-02-15 04:34:332 2 NICK WAHLBERG 2006-02-15 04:34:333 3 ED CHASE 2006-02-15 04:34:334 4 JENNIFER DAVIS 2006-02-15 04:34:335 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_update1 18 DAN TORN 2006-02-15 04:34:332 94 KENNETH TORN 2006-02-15 04:34:333 102 WALTER TORN 2006-02-15 04:34:33
我们可以通过将更新查询传递给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()创建表。 如果表已经存在，它将覆盖该表，并将数据帧用作输入。
# 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()中，就像我们使用它查询表中的数据一样。
dbSendQuery(mysqlconnection, 'drop table if exists mtcars')
执行上面的代码后，我们可以看到表在MySql环境中被删除。
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 = 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.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
数据系列中的最中间值称为中值。 在R语言中使用median()函数来计算此值。
计算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
模式是一组数据中出现次数最多的值。 Unike平均值和中位数，模式可以同时包含数字和字符数据。
R语言没有标准的内置函数来计算模式。 因此，我们创建一个用户函数来计算R语言中的数据集的模式。该函数将向量作为输入，并将模式值作为输出。
# Create the function.getmode <- function(v) { uniqv <- unique(v) uniqv[which.max(tabulate(match(v, uniqv)))]}# Create the vector with numbers.v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)# Calculate the mode using the user function.result <- getmode(v)print(result)# Create the vector with characters.charv <- c("o","it","the","it","it")# Calculate the mode using the user function.result <- getmode(charv)print(result)当我们执行上面的代码，它产生以下结果 -
[1] 2[1] "it"
回归分析是一种非常广泛使用的统计工具，用于建立两个变量之间的关系模型。 这些变量之一称为预测变量，其值通过实验收集。 另一个变量称为响应变量，其值从预测变量派生。
在线性回归中，这两个变量通过方程相关，其中这两个变量的指数（幂）为1.数学上，线性关系表示当绘制为曲线图时的直线。 任何变量的指数不等于1的非线性关系将创建一条曲线。
线性回归的一般数学方程为 -
y = ax + b
以下是所使用的参数的描述 -
y是响应变量。
x是预测变量。
a和b被称为系数常数。
回归的简单例子是当人的身高已知时预测人的体重。 为了做到这一点，我们需要有一个人的身高和体重之间的关系。
创建关系的步骤是 -
进行收集高度和相应重量的观测值的样本的实验。
使用R语言中的lm()函数创建关系模型。
从创建的模型中找到系数，并使用这些创建数学方程
获得关系模型的摘要以了解预测中的平均误差。 也称为残差。
为了预测新人的体重，使用R中的predict()函数。
下面是代表观察的样本数据 -
# Values of height151, 174, 138, 186, 128, 136, 179, 163, 152, 131# Values of weight.63, 81, 56, 91, 47, 57, 76, 72, 62, 48
此函数创建预测变量和响应变量之间的关系模型。
线性回归中lm()函数的基本语法是 -
lm(formula,data)
以下是所使用的参数的说明 -
公式是表示x和y之间的关系的符号。
数据是应用公式的向量。
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 ‘ ’ 1Residual standard error: 3.253 on 8 degrees of freedomMultiple 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(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()
当我们执行上面的代码，它产生以下结果 -
多元回归是线性回归到两个以上变量之间的关系的延伸。 在简单线性关系中，我们有一个预测变量和一个响应变量，但在多元回归中，我们有多个预测变量和一个响应变量。
多元回归的一般数学方程为 -
y = a + b1x1 + b2x2 +...bnxn
以下是所使用的参数的描述 -
y是响应变量。
a，b1，b2 ... bn是系数。
x1，x2，... xn是预测变量。
我们使用R语言中的lm()函数创建回归模型。模型使用输入数据确定系数的值。 接下来，我们可以使用这些系数来预测给定的一组预测变量的响应变量的值。
此函数创建预测变量和响应变量之间的关系模型。
lm()函数在多元回归中的基本语法是 -
lm(y ~ x1+x2+x3...,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 wtMazda RX4 21.0 160 110 2.620Mazda RX4 Wag 21.0 160 110 2.875Datsun 710 22.8 108 93 2.320Hornet 4 Drive 21.4 258 110 3.215Hornet Sportabout 18.7 360 175 3.440Valiant 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 # # # ","")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.x3orY = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3
Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.7104
逻辑回归是回归模型，其中响应变量（因变量）具有诸如True / False或0/1的分类值。 它实际上基于将其与预测变量相关的数学方程测量二元响应的概率作为响应变量的值。
逻辑回归的一般数学方程为 -
y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))
以下是所使用的参数的描述 -
y是响应变量。
x是预测变量。
a和b是作为数字常数的系数。
用于创建回归模型的函数是glm()函数。
逻辑回归中glm()函数的基本语法是 -
glm(formula,data,family)
以下是所使用的参数的描述 -
formula是表示变量之间的关系的符号。
data是给出这些变量的值的数据集。
family是R语言对象来指定模型的细节。 它的值是二项逻辑回归。
内置数据集“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 wtMazda RX4 1 6 110 2.620Mazda RX4 Wag 1 6 110 2.875Datsun 710 1 4 93 2.320Hornet 4 Drive 0 6 110 3.215Hornet Sportabout 0 8 175 3.440Valiant 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 freedomResidual deviance: 9.8415 on 28 degrees of freedomAIC: 17.841Number of Fisher Scoring iterations: 8
在总结中，对于变量“cyl”和“hp”，最后一列中的p值大于0.05，我们认为它们对变量“am”的值有贡献是无关紧要的。 只有重量（wt）影响该回归模型中的“am”值。
在来自独立源的数据的随机集合中，通常观察到数据的分布是正常的。 这意味着，在绘制水平轴上的变量值和垂直轴上的值的计数的图形时，我们得到钟形曲线。 曲线的中心表示数据集的平均值。 在图中，50％的值位于平均值的左侧，另外50％位于图表的右侧。 这在统计学中被称为正态分布。
R语言有四个内置函数来产生正态分布。 它们描述如下。
dnorm(x, mean, sd)pnorm(x, mean, sd)qnorm(p, mean, sd)rnorm(n, mean, sd)以下是在上述功能中使用的参数的描述 -
该函数给出给定平均值和标准偏差在每个点的概率分布的高度。
# 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()当我们执行上面的代码，它产生以下结果 -
该函数给出正态分布随机数的概率小于给定数的值。 它也被称为“累积分布函数”。
# 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()当我们执行上面的代码，它产生以下结果 -
该函数采用概率值，并给出累积值与概率值匹配的数字。
# 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 = 3)# Give the chart file a name.png(file = "qnorm.png")# Plot the graph.plot(x,y)# Save the file.dev.off()当我们执行上面的代码，它产生以下结果 -
此函数用于生成分布正常的随机数。 它将样本大小作为输入，并生成许多随机数。 我们绘制一个直方图来显示生成的数字的分布。
# 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()当我们执行上面的代码，它产生以下结果 -
二项分布模型处理在一系列实验中仅发现两个可能结果的事件的成功概率。 例如，掷硬币总是给出头或尾。 在二项分布期间估计在10次重复抛掷硬币中精确找到3个头的概率。
R语言有四个内置函数来生成二项分布。 它们描述如下。
dbinom(x, size, prob)pbinom(x, size, prob)qbinom(p, size, prob)rbinom(n, size, prob)
以下是所使用的参数的描述 -
x是数字的向量。
p是概率向量。
n是观察的数量。
size是试验的数量。
prob是每个试验成功的概率。
该函数给出每个点的概率密度分布。
# 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()
当我们执行上面的代码，它产生以下结果 -
此函数给出事件的累积概率。 它是表示概率的单个值。
# 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
该函数采用概率值，并给出累积值与概率值匹配的数字。
# 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
该函数从给定样本产生给定概率的所需数量的随机值。
# 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
泊松回归（英语:Poisson regression）包括回归模型，其中响应变量是计数而不是分数的形式。
例如，足球比赛系列中的出生次数或胜利次数。 此外，响应变量的值遵循泊松分布。
泊松回归的一般数学方程为 -
log(y) = a + b1x1 + b2x2 + bnxn.....
以下是所使用的参数的描述 -
y是响应变量。
a和b是数字系数。
x是预测变量。
用于创建泊松回归模型的函数是glm()函数。
在泊松回归中glm()函数的基本语法是 -
glm(formula,data,family)
以下是在上述功能中使用的参数的描述 -
formula是表示变量之间的关系的符号。
data是给出这些变量的值的数据集。
family是 R 语言对象来指定模型的细节。 它的值是“泊松”的逻辑回归。
我们有内置的数据集“warpbreaks”，其描述了羊毛类型（A或B）和张力（低，中或高）对每个织机的经纱断裂数量的影响。 让我们考虑“断裂”作为响应变量，它是断裂次数的计数。 羊毛“类型”和“张力”作为预测变量。
input <- warpbreaksprint(head(input))
当我们执行上面的代码，它产生以下结果 -
breaks wool tension1 26 A L2 30 A L3 54 A L4 25 A L5 70 A L6 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 freedomResidual deviance: 210.39 on 50 degrees of freedomAIC: 493.06Number of Fisher Scoring iterations: 4
在摘要中，我们查找最后一列中的p值小于0.05，以考虑预测变量对响应变量的影响。 如图所示，具有张力类型M和H的羊毛类型B对断裂计数有影响。
我们使用回归分析创建模型，描述变量在预测变量对响应变量的影响。 有时，如果我们有一个类别变量，如Yes / No或Male / Female等。简单的回归分析为分类变量的每个值提供多个结果。 在这种情况下，我们可以通过将分类变量与预测变量一起使用并比较分类变量的每个级别的回归线来研究分类变量的效果。 这样的分析被称为协方差分析，也称为ANCOVA。
考虑在数据集mtcars中内置的R语言。 在其中我们观察到字段“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 hpMazda RX4 1 21.0 110Mazda RX4 Wag 1 21.0 110Datsun 710 1 22.8 93Hornet 4 Drive 0 21.4 110Hornet Sportabout 0 18.7 175Valiant 0 18.1 105
我们创建一个回归模型，以“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 * amModel 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，我们得出结论，马力和传播类型之间的相互作用不显著。 因此，在汽车和手动变速器模式下，每加仑的里程将以类似的方式取决于汽车的马力。
时间序列是将统一统计值按照时间发生的先后顺序来进行排列，时间序列分析的主要目的是根据已有数据对未来进行预测。
一个稳定的时间序列中常常包含两个部分，那么就是：有规律的时间序列+噪声。所以，在以下的方法中，主要的目的就是去过滤噪声值，让我们的时间序列更加的有分析意义。
时间序列分析中ts()函数的基本语法是 -
timeseries.object.name <- ts(data, start, end, frequency)
以下是所使用的参数的描述 -
data是包含在时间序列中使用的值的向量或矩阵。
start以时间序列指定第一次观察的开始时间。
end指定时间序列中最后一次观测的结束时间。
frequency指定每单位时间的观测数。
除了参数“data”，所有其他参数是可选的。
拿到一个时间序列之后，我们首先要对其稳定性进行判断，只有非白噪声的稳定性时间序列才有分析的意义以及预测未来数据的价值。
所谓平稳，是指统计值在一个常数上下波动并且波动范围是有界限的。如果有明显的趋势或者周期性，那么就是不稳定的。一般判断有三种方法：
在R语言中，DF检测是一种检测稳定性的方法，如果得出的P值小于临界值，则认为是序列是稳定的。
白噪声序列，又称为纯随机性序列，序列的各个值之间没有任何的相关关系，序列在进行无序的随机波动，可以终止对该序列的分析，因为从白噪声序列中是提取不到任何有价值的信息的。
均值和方差为常数，并且具有与时间无关的自协方差。
考虑从2012年1月开始的一个地方的年降雨量细节。我们创建一个R时间序列对象为期12个月并绘制它。
# Get the data points in form of a R vector.rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)# Convert it to a time series object.rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)# Print the timeseries data.print(rainfall.timeseries)# Give the chart file a name.png(file = "rainfall.png")# Plot a graph of the time series.plot(rainfall.timeseries)# Save the file.dev.off()
当我们执行上面的代码，它产生以下结果及图表 -
Jan Feb Mar Apr May Jun Jul Aug Sep2012 799.0 1174.8 865.1 1334.6 635.4 918.5 685.5 998.6 784.2 Oct Nov Dec2012 985.0 882.8 1071.0
时间序列图 -
ts()函数中的频率参数值决定了测量数据点的时间间隔。 值为12表示时间序列为12个月。 其他值及其含义如下 -
频率= 12指定一年中每个月的数据点。
频率= 4每年的每个季度的数据点。
频率= 6每小时的10分钟的数据点。
频率= 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 2Jan 2012 799.0 655.0Feb 2012 1174.8 1306.9Mar 2012 865.1 1323.4Apr 2012 1334.6 1172.2May 2012 635.4 562.2Jun 2012 918.5 824.0Jul 2012 685.5 822.4Aug 2012 998.6 1265.5Sep 2012 784.2 799.6Oct 2012 985.0 1105.6Nov 2012 882.8 1106.7Dec 2012 1071.0 1337.8
多时间序列图 -
当模拟真实世界数据用于回归分析时，我们观察到，很少情况下，模型的方程是给出线性图的线性方程。大多数时候，真实世界数据模型的方程涉及更高程度的数学函数，如3的指数或sin函数。在这种情况下，模型的图给出了曲线而不是线。线性和非线性回归的目的是调整模型参数的值，以找到最接近您的数据的线或曲线。在找到这些值时，我们将能够以良好的精确度估计响应变量。
在最小二乘回归中，我们建立了一个回归模型，其中来自回归曲线的不同点的垂直距离的平方和被最小化。我们通常从定义的模型开始，并假设系数的一些值。然后我们应用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.081935Waiting for profiling to be done... 2.5% 97.5%b1 1.137708 1.253135b2 1.497364 2.496484
我们可以得出结论，b1的值更接近1，而b2的值更接近2而不是3。
决策树是以树的形式表示选择及其结果的图。图中的节点表示事件或选择，并且图的边缘表示决策规则或条件。它主要用于使用R的机器学习和数据挖掘应用程序。
决策树的使用的例子是 - 预测电子邮件是垃圾邮件或非垃圾邮件，预测肿瘤癌变，或者基于这些因素预测贷款的信用风险。通常，使用观测数据（也称为训练数据）来创建模型。然后使用一组验证数据来验证和改进模型。 R具有用于创建和可视化决策树的包。对于新的预测变量集合，我们使用此模型来确定R包“party”用于创建决策树。
在R语言控制台中使用以下命令安装软件包。您还必须安装相关软件包（如果有）。
install.packages("party")“party”包具有用于创建和分析决策树的函数ctree()。
在R中创建决策树的基本语法是 -
ctree(formula, data)
以下是所使用的参数的描述 -
formula是描述预测变量和响应变量的公式。
data是所使用的数据集的名称。
我们将使用名为readingSkills的R内置数据集来创建决策树。 它描述了某人的readingSkills的分数，如果我们知道变量“年龄”，“shoesize”，“分数”，以及该人是否为母语者。
这里是示例数据。
# Load the party package. It will automatically load other dependent packages.library(party)# Print some records from data set readingSkills.print(head(readingSkills))
当我们执行上面的代码，它产生以下结果及图表 -
nativeSpeaker age shoeSize score1 yes 5 24.83189 32.293852 yes 6 25.95238 36.631053 no 11 30.42170 49.605934 yes 7 28.66450 40.284565 yes 11 31.88207 55.460856 yes 10 30.07843 52.83124Loading required package: methodsLoading 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: methodsLoading required package: gridLoading required package: mvtnormLoading required package: modeltoolsLoading required package: stats4Loading required package: strucchangeLoading required package: zooAttaching package: ‘zoo’The following objects are masked from ‘package:base’: as.Date, as.Date.numericLoading required package: sandwich
从上面显示的决策树，我们可以得出结论，其readingSkills分数低于38.3和年龄超过6的人不是一个母语者。
在随机森林方法中，创建大量的决策树。 每个观察被馈入每个决策树。 每个观察的最常见的结果被用作最终输出。 新的观察结果被馈入所有的树并且对每个分类模型取多数投票。
对构建树时未使用的情况进行错误估计。 这称为OOB（袋外）误差估计，其被提及为百分比。
R语言包“randomForest”用于创建随机森林。
在R语言控制台中使用以下命令安装软件包。 您还必须安装相关软件包（如果有）。
install.packages("randomForest")包“randomForest”具有函数randomForest()，用于创建和分析随机森林。
在R语言中创建随机森林的基本语法是 -
randomForest(formula, data)
以下是所使用的参数的描述 -
formula是描述预测变量和响应变量的公式。
data是所使用的数据集的名称。
我们将使用名为readingSkills的R语言内置数据集来创建决策树。 它描述了某人的readingSkills的分数，如果我们知道变量“age”，“shoesize”，“score”，以及该人是否是母语。
以下是示例数据。
# Load the party package. It will automatically load other required packages.library(party)# Print some records from data set readingSkills.print(head(readingSkills))
当我们执行上面的代码，它产生以下结果及图表 -
nativeSpeaker age shoeSize score1 yes 5 24.83189 32.293852 yes 6 25.95238 36.631053 no 11 30.42170 49.605934 yes 7 28.66450 40.284565 yes 11 31.88207 55.460856 yes 10 30.07843 52.83124Loading required package: methodsLoading 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(output.forest,type = 2))
当我们执行上面的代码，它产生以下结果 -
Call: randomForest(formula = nativeSpeaker ~ age + shoeSize + score, data = readingSkills) Type of random forest: classification Number of trees: 500No. of variables tried at each split: 1 OOB estimate of error rate: 1%Confusion matrix: no yes class.errorno 99 1 0.01yes 1 99 0.01 MeanDecreaseGiniage 13.95406shoeSize 18.91006score 56.73051
从上面显示的随机森林，我们可以得出结论，鞋码和成绩是决定如果某人是母语者或不是母语的重要因素。 此外，该模型只有1%的误差，这意味着我们可以预测精度为99%。
生存分析处理预测特定事件将要发生的时间。 它也被称为故障时间分析或分析死亡时间。 例如，预测患有癌症的人将存活的天数或预测机械系统将失败的时间。
命名为survival的R语言包用于进行生存分析。 此包包含函数Surv（），它将输入数据作为R语言公式，并在选择的变量中创建一个生存对象用于分析。 然后我们使用函数survfit()创建一个分析图。
install.packages("survival")在R语言中创建生存分析的基本语法是 -
Surv(time,event)survfit(formula)
以下是所使用的参数的描述 -
time是直到事件发生的跟踪时间。
event指示预期事件的发生的状态。
formula是预测变量之间的关系。
我们将考虑在上面安装的生存包中存在的名为“pbc”的数据集。 它描述了关于受肝原发性胆汁性肝硬化（PBC）影响的人的生存数据点。 在数据集中存在的许多列中，我们主要关注字段“time”和“status”。 时间表示在接受肝移植或患者死亡的患者的登记和事件的较早之间的天数。
# Load the library.library("survival")# Print first few rows.print(head(pbc))当我们执行上面的代码，它产生以下结果及图表 -
id time status trt age sex ascites hepato spiders edema bili chol1 1 400 2 1 58.76523 f 1 1 1 1.0 14.5 2612 2 4500 0 1 56.44627 f 0 1 1 0.0 1.1 3023 3 1012 2 1 70.07255 m 0 0 0 0.5 1.4 1764 4 1925 2 1 54.74059 f 0 1 1 0.5 1.8 2445 5 1504 1 2 38.10541 f 0 1 1 0.0 3.4 2796 6 2503 2 2 66.25873 f 0 1 0 0.0 0.8 248 albumin copper alk.phos ast trig platelet protime stage1 2.60 156 1718.0 137.95 172 190 12.2 42 4.14 54 7394.8 113.52 88 221 10.6 33 3.48 210 516.0 96.10 55 151 12.0 44 2.54 64 6121.8 60.63 92 183 10.3 45 3.53 143 671.0 113.15 72 136 10.9 36 3.98 50 944.0 93.00 63 NA 11.0 3
从上述数据，我们正在考虑分析的时间和状态。
现在我们继续应用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
上图中的趋势有助于我们预测在特定天数结束时的生存概率。
卡方检验是一种确定两个分类变量之间是否存在显着相关性的统计方法。 这两个变量应该来自相同的人口，他们应该是类似 - 是/否，男/女，红/绿等。
例如，我们可以建立一个观察人们的冰淇淋购买模式的数据集，并尝试将一个人的性别与他们喜欢的冰淇淋的味道相关联。 如果发现相关性，我们可以通过了解访问的人的性别的数量来计划适当的味道库存。
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 testdata: car.dataX-squared = 33.001, df = 10, p-value = 0.0002723Warning message:In chisq.test(car.data) : Chi-squared approximation may be incorrect
结果显示p值小于0.05，这表明字符串相关。
R语言是用于统计分析，图形表示和报告的编程语言和软件环境。 R由Ross Ihaka和Robert Gentleman在新西兰奥克兰大学创建，目前由R开发核心团队开发。 R在GNU通用公共许可证下免费提供，并为各种操作系统（如Linux，Windows和Mac）提供预编译的二进制版本。 这种编程语言基于两个R语言作者（Robert Gentleman和Ross Ihaka）的名字的第一个字母命名为R语言。
尊敬的读者，这些R语言面试题是专门设计的，以便您应对在R语言相关面试中可能会被问到的问题。 根据我的经验，良好的面试官几乎不打算在你的面试中问任何特定的问题，通常都是以如下的问题为开端进一步展开后继的问题。
什么是R语言编程？
R语言是一种用于统计分析和为此目的创建图形的编程语言。不是数据类型，它具有用于计算的数据对象。它用于数据挖掘，回归分析，概率估计等领域，使用其中可用的许多软件包。表达式M [4,2]给出了第4行和第2列的元素。
什么是向量中元素的回收？举个例子。
当在操作中涉及不同长度的两个向量时，较短向量的元素被重用以完成操作。这被称为元素循环。示例-v1 <-c（4,1,0,6）和V2 <-c（2,4），则v1 * v2给出（8,4,0,24）。重复元件2和4。
在R语言中调用函数有什么不同的方法？
我们可以用3种方式在R语言中调用一个函数。第一种方法是通过使用参数的位置来调用。第二个方法id通过使用参数的名称来调用，第三个方法是通过默认参数调用。
什么是R语言中的延迟函数评估？
函数的延迟评估意味着，只有当它在函数体内部使用时，才会评估参数。如果没有对函数体中的参数的引用，则它被简单地忽略。
如何在R语言中安装软件包？
要在R语言中安装一个包，我们使用下面的命令。
install.packages（"package Name"）installed.packages()x <- “快速的棕色狐狸跳过懒惰的狗”split.string <- strsplit(x，"")extract.words <- split.string [[1]]result <- unique(tolower(extract.words))print(result)x <- pbinom(26,51,0.5)print(x)X是向量c(5,9.2,3,8.51，NA)，mean(x)的输出是什么？NAfunction(x){x [is.na(x)] <sum(x,na.rm = TRUE); x }data(package = .packages(all.available = TRUE))15%在%xpairs(formula, data)[1] NA