基础篇
一.R环境设置
尝试在线环境
你真的不需要设置自己的环境来开始学习R编程语言。 原因很简单，我们已经在线设置了R编程环境，以便您可以在进行理论工作的同时在线编译和执行所有可用的示例。 这给你对你正在阅读的信心，并用不同的选项检查结果。 随意修改任何示例并在线执行。
实例：
# Print Hello World.
print("Hello World")
# Add two numbers.
print(23.9 + 11.6)Windows安装
您可以从R-3.2.2 for Windows（32/64位）下载R的Windows安装程序版本，并将其保存在本地目录中。
因为它是一个名为“R-version-win.exe”的Windows安装程序（.exe）。 您只需双击并运行安装程序接受默认设置即可。 如果您的Windows是32位版本，它将安装32位版本。 但是如果你的窗口是64位，那么它安装32位和64位版本。
安装后，您可以找到该图标，以在Windows程序文件下的目录结构“R \ R3.2.2 \ bin \ i386 \ Rgui.exe”中运行程序。 单击此图标会打开R-GUI，它是R控制台来执行R编程。
Linux安装
R语言适用于多版本的Linux系统。
各版本Linux的各有不同。具体的安装步骤在上述资源中有对应的教程。但是，如果你是在赶时间，那么你可以用yum命令，如下所示的安装指令
安装R
$ yum install R以上命令将安装R编程的核心功能与标准包，额外的包需要另外安装，而后你可以按如下提示启动R。
$ R
R version 3.2.0 (2015-04-16) -- "Full of Ingredients"
Copyright (C) 2015 The R Foundation for Statistical Computing
Platform: x86_64-redhat-linux-gnu (64-bit)
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.
R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.
Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
> 现在，您可以在R语言提示符下使用install命令安装所需的软件包。 例如，以下命令将安装为3D图表所需的plotrix软件包。
> install.packages("plotrix")二.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 Programming
myString <- "Hello, World!"
print ( myString)将上述代码保存在test.R文件中，并在Linux命令提示符下执行，如下所示。 即使您使用的是Windows或其他系统，语法也将保持不变。
$ Rscript test.R 当我们运行上面的程序，它产生以下结果。
[1] "Hello, World!"注释
注释能帮助您解释R语言程序中的脚本，它们在实际执行程序时会被解释器忽略。 单个注释使用＃在语句的开头写入，如下所示
# My first program in R ProgrammingR语言不支持多行注释，但你可以使用一个小技巧，如下
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
Numeric（数字） 12.3，5，999
Integer（整型） 2L，34L，0L
Complex（复合型） 3 + 2i
Character（字符） ‘a’ , ‘“good”, “TRUE”, ‘23.4’
Raw（原型） “Hello” 被存储为 48 65 6c 6c 6f
在R编程中，非常基本的数据类型是称为向量的R对象，其保存如上所示的不同类的元素。 请注意，在R中，类的数量不仅限于上述六种类型。 例如，我们可以使用许多原子向量并创建一个数组，其类将成为数组。Vectors 向量
当你想用多个元素创建向量时，你应该使用c()函数，这意味着将元素组合成一个向量。
# Create a vector. apple <- c('red','green',"yellow") print(apple) # Get the class of the vector. print(class(apple))当我们执行上面的代码，它产生以下结果
[1] "red" "green" "yellow" [1] "character"Lists 列表
列表是一个R对象，它可以在其中包含许多不同类型的元素，如向量，函数甚至其中的另一个列表。
# Create a list. list1 <- list(c(2,5,3),21.3,sin) # Print the list. print(list1)当我们执行上面的代码，它产生以下结果
[[1]] [1] 2 5 3 [[2]] [1] 21.3 [[3]] function (x) .Primitive("sin") ### Matrices 矩阵矩阵是二维矩形数据集。 它可以使用矩阵函数的向量输入创建。
# Create a matrix. M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE) print(M)当我们执行上面的代码，它产生以下结果
[,1] [,2] [,3] [1,] "a" "a" "b" [2,] "c" "b" "a"Arrays 数组
虽然矩阵被限制为二维，但阵列可以具有任何数量的维度。 数组函数使用一个dim属性创建所需的维数。 在下面的例子中，我们创建了一个包含两个元素的数组，每个元素为3x3个矩阵。
# Create an array. a <- array(c('green','yellow'),dim = c(3,3,2)) print(a)当我们执行上面的代码，它产生以下结果
, , 1 [,1] [,2] [,3] [1,] "green" "yellow" "green" [2,] "yellow" "green" "yellow" [3,] "green" "yellow" "green" , , 2 [,1] [,2] [,3] [1,] "yellow" "green" "yellow" [2,] "green" "yellow" "green" [3,] "yellow" "green" "yellow"Factors 因子
因子是使用向量创建的r对象。 它将向量与向量中元素的不同值一起存储为标签。 标签总是字符，不管它在输入向量中是数字还是字符或布尔等。 它们在统计建模中非常有用。
使用factor()函数创建因子。nlevels函数给出级别计数。# Create a vector. apple_colors <- c('green','green','yellow','red','red','red','green') # Create a factor object. factor_apple <- factor(apple_colors) # Print the factor. print(factor_apple) print(nlevels(factor_apple))当我们执行上面的代码，它产生以下结果
[1] green green yellow red red red yellow green Levels: green red yellow # applying the nlevels function we can know the number of distinct values [1] 3Data Frames 数据帧
数据帧是表格数据对象。 与数据帧中的矩阵不同，每列可以包含不同的数据模式。 第一列可以是数字，而第二列可以是字符，第三列可以是逻辑的。 它是等长度的向量的列表。
使用data.frame()函数创建数据帧。# Create the data frame. BMI <- data.frame( gender = c("Male", "Male","Female"), height = c(152, 171.5, 165), weight = c(81,93, 78), Age = c(42,38,26) ) print(BMI)当我们执行上面的代码，它产生以下结果
gender height weight Age 1 Male 152.0 81 42 2 Male 171.5 93 38 3 Female 165.0 78 26四.变量
变量为我们提供了我们的程序可以操作的命名存储。 R语言中的变量可以存储原子向量，原子向量组或许多Robject的组合。 有效的变量名称由字母，数字和点或下划线字符组成。 变量名以字母或不以数字后跟的点开头。
注：有字母，数字，点和下划线，其中只能字母开头变量赋值
可以使用向左，向右和等于运算符来为变量分配值。 可以使用print()或cat()函数打印变量的值。 cat()函数将多个项目组合成连续打印输出。
# Assignment using equal operator. var.1 = c(0,1,2,3) # Assignment using leftward operator. var.2 <- c("learn","R") # Assignment using rightward operator. c(TRUE,1) -> var.3 print(var.1) cat ("var.1 is ", var.1 ," ") cat ("var.2 is ", var.2 ," ") cat ("var.3 is ", var.3 ," ")当我们执行上面的代码，它产生以下结果 -
[1] 0 1 2 3 var.1 is 0 1 2 3 var.2 is learn R var.3 is 1 1注 - 向量c（TRUE，1）具有逻辑和数值类的混合。 因此，逻辑类强制转换为数字类，使TRUE为1。
变量的数据类型
在R语言中，变量本身没有声明任何数据类型，而是获取分配给它的R - 对象的数据类型。 所以R称为动态类型语言，这意味着我们可以在程序中使用同一个变量时，一次又一次地更改变量的数据类型。
var_x <- "Hello" cat("The class of var_x is ",class(var_x)," ") var_x <- 34.5 cat(" Now the class of var_x is ",class(var_x)," ") var_x <- 27L cat(" Next the class of var_x becomes ",class(var_x)," ")当我们执行上面的代码，它产生以下结果 -
The class of var_x is character Now the class of var_x is numeric Next the class of var_x becomes integer查找变量
要知道工作空间中当前可用的所有变量，我们使用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()函数可以使用模式来匹配变量名。
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语言支持的算术运算符。 操作符对向量的每个元素起作用。
除了加减乘除 - %% 两个向量求余
- ％/％ 两个向量相除求商
- ^ 将第二向量作为第一向量的指数
关系运算符
即大于小于等于以及不等于逻辑运算符
下表显示了R语言支持的逻辑运算符。 它只适用于逻辑，数字或复杂类型的向量。 所有大于1的数字被认为是逻辑值TRUE。
将第一向量的每个元素与第二向量的相应元素进行比较。 比较的结果是布尔值。 - & 它被称为元素逻辑AND运算符。 它将第一向量的每个元素与第二向量的相应元素组合，并且如果两个元素都为TRUE，则给出输出TRUE。
- | 它被称为元素逻辑或运算符。 它将第一向量的每个元素与第二向量的相应元素组合，并且如果元素为真，则给出输出TRUE。
- ! 它被称为逻辑非运算符。 取得向量的每个元素，并给出相反的逻辑值。
逻辑运算符&&和|| 只考虑向量的第一个元素，给出单个元素的向量作为输出。 - && 称为逻辑AND运算符。 取两个向量的第一个元素，并且只有两个都为TRUE时才给出TRUE。
- || 称为逻辑OR运算符。 取两个向量的第一个元素，如果其中一个为TRUE，则给出TRUE。
赋值运算符
这些运算符用于向向量赋值。 - <− or = or <<− 称为左分配
- -> or ->> 称为右分配
其他运算符
这些运算符用于特定目的，而不是一般的数学或逻辑计算。 - : 冒号运算符。 它为向量按顺序创建一系列数字。
- %in% 此运算符用于标识元素是否属于向量。
- %*% 此运算符用于将矩阵与其转置相乘。
六.决策
决策结构要求程序员指定要由程序评估或测试的一个或多个条件，以及如果条件被确定为真则要执行的一个或多个语句，如果条件为假则执行其他语句。
以下是在大多数编程语言中的典型决策结构的一般形式
R提供以下类型的决策语句。 单击以下链接以检查其详细信息。
if语句由一个布尔表达式后跟一个或多个语句组成。
if语句后面可以有一个可选的else语句，当布尔表达式为false时执行。
switch语句允许根据值列表测试变量的相等性。
七.包
R语言的包是R函数，编译代码和样本数据的集合。 它们存储在R语言环境中名为“library”的目录下。 默认情况下，R语言在安装期间安装一组软件包。 随后添加更多包，当它们用于某些特定目的时。 当我们启动R语言控制台时，默认情况下只有默认包可用。 已经安装的其他软件包必须显式加载以供将要使用它们的R语言程序使用。
所有可用的R语言包都列在R语言的包。
下面是用于检查，验证和使用R包的命令列表。
检查可用R语言的包
获取包含R包的库位置
.libPaths()当我们执行上面的代码，它产生以下结果。 它可能会根据您的电脑的本地设置而有所不同。
[2] "C:/Program Files/R/R-3.2.2/library"获取已安装的所有软件包列表
library()当我们执行上面的代码，它产生以下结果。 它可能会根据您的电脑的本地设置而有所不同。
Packages in library ‘C:/Program Files/R/R-3.2.2/library’:
base The R Base Package
boot Bootstrap Functions (Originally by Angelo Canty
for S)
class Functions for Classification
cluster "Finding Groups in Data": Cluster Analysis
Extended Rousseeuw et al.
codetools Code Analysis Tools for R
compiler The R Compiler Package获取当前在R环境中加载的所有包
search()当我们执行上述代码时，它产生了以下结果。它会根据你的个人电脑的本地设置而异。
[1] ".GlobalEnv" "package:stats" "package:graphics"
[4] "package:grDevices" "package:utils" "package:datasets"
[7] "package:methods" "Autoloads" "package:base" 安装一个新的软件包
有两种方法来添加新的R包。 一个是直接从CRAN目录安装，另一个是将软件包下载到本地系统并手动安装它。
直接从CRAN安装
以下命令直接从CRAN网页获取软件包，并将软件包安装在R环境中。 可能会提示您选择最近的镜像。 根据您的位置选择一个。
# Install the package named "XML".
install.packages("XML")手动安装包
转到链接R Packages下载所需的包。 将包作为.zip文件保存在本地系统中的适当位置。
现在您可以运行以下命令在R环境中安装此软件包。
# 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编程语言提供以下种类的循环来处理循环需求。 单击以下链接以检查其详细信息。
多次执行一系列语句，并简化管理循环变量的代码。
在给定条件为真时，重复语句或语句组。 它在执行循环体之前测试条件。
像while语句，不同之处在于它测试在循环体的端部的条件。
循环控制语句
循环控制语句从其正常序列改变执行。 当执行离开作用域时，在该作用域中创建的所有自动对象都将被销毁。
R语言支持以下控制语句。 单击以下链接以检查其详细信息。
终止循环语句，并将执行转移到循环后立即执行的语句。
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 columns
new.address <- data.frame(
city = c("Lowry","Charlotte"),
state = c("CO","FL"),
zipcode = c("80230","33949"),
stringsAsFactors = FALSE
)
# Print a header.
cat("# # # The Second data frame
")
# Print the data frame.
print(new.address)
# Combine rows form both the data frames.
all.addresses <- rbind(addresses,new.address)
# Print a header.
cat("# # # The combined data frame
")
# Print the result.
print(all.addresses)当我们执行上面的代码，它产生以下结果 -
# # # # The First data frame
city state zipcode
[1,] "Tampa" "FL" "33602"
[2,] "Seattle" "WA" "98104"
[3,] "Hartford" "CT" "6161"
[4,] "Denver" "CO" "80294"
# # # The Second data frame
city state zipcode
1 Lowry CO 80230
2 Charlotte FL 33949
# # # The combined data frame
city state zipcode
1 Tampa FL 33602
2 Seattle WA 98104
3 Hartford CT 6161
4 Denver CO 80294
5 Lowry CO 80230
6 Charlotte FL 33949合并数据帧
我们可以使用merge()函数合并两个数据帧。 数据帧必须具有相同的列名称，在其上进行合并。
在下面的例子中，我们考虑图书馆名称“MASS”中有关Pima Indian Women的糖尿病的数据集。 我们基于血压（“bp”）和体重指数（“bmi”）的值合并两个数据集。 在选择这两列用于合并时，其中这两个变量的值在两个数据集中匹配的记录被组合在一起以形成单个数据帧。
library(MASS)
merged.Pima <- merge(x = Pima.te, y = Pima.tr,
by.x = c("bp", "bmi"),
by.y = c("bp", "bmi")
)
print(merged.Pima)
nrow(merged.Pima)当我们执行上面的代码，它产生以下结果 -
bp bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y
1 60 33.8 1 117 23 0.466 27 No 2 125 20 0.088
2 64 29.7 2 75 24 0.370 33 No 2 100 23 0.368
3 64 31.2 5 189 33 0.583 29 Yes 3 158 13 0.295
4 64 33.2 4 117 27 0.230 24 No 1 96 27 0.289
5 66 38.1 3 115 39 0.150 28 No 1 114 36 0.289
6 68 38.5 2 100 25 0.324 26 No 7 129 49 0.439
7 70 27.4 1 116 28 0.204 21 No 0 124 20 0.254
8 70 33.1 4 91 32 0.446 22 No 9 123 44 0.374
9 70 35.4 9 124 33 0.282 34 No 6 134 23 0.542
10 72 25.6 1 157 21 0.123 24 No 4 99 17 0.294
11 72 37.7 5 95 33 0.370 27 No 6 103 32 0.324
12 74 25.9 9 134 33 0.460 81 No 8 126 38 0.162
13 74 25.9 1 95 21 0.673 36 No 8 126 38 0.162
14 78 27.6 5 88 30 0.258 37 No 6 125 31 0.565
15 78 27.6 10 122 31 0.512 45 No 6 125 31 0.565
16 78 39.4 2 112 50 0.175 24 No 4 112 40 0.236
17 88 34.5 1 117 24 0.403 40 Yes 4 127 11 0.598
age.y type.y
1 31 No
2 21 No
3 24 No
4 21 No
5 21 No
6 43 Yes
7 36 Yes
8 40 No
9 29 Yes
10 28 No
11 55 No
12 39 No
13 39 No
14 49 Yes
15 49 Yes
16 38 No
17 28 No
[1] 17melt()拆分数据和cast()数据重构
R语言编程的一个最有趣的方面是关于在多个步骤中改变数据的形状以获得期望的形状。 用于执行此操作的函数称为melt()和cast()。
我们考虑称为船舶的数据集称为“MASS”。
library(MASS)
print(ships)当我们执行上面的代码，它产生以下结果 -
type year period service incidents
1 A 60 60 127 0
2 A 60 75 63 0
3 A 65 60 1095 3
4 A 65 75 1095 4
5 A 70 60 1512 6
.............
.............
8 A 75 75 2244 11
9 B 60 60 44882 39
10 B 60 75 17176 29
11 B 65 60 28609 58
............
............
17 C 60 60 1179 1
18 C 60 75 552 1
19 C 65 60 781 0
............
............melt()拆分数据
现在我们拆分数据进行重组，将除类型和年份以外的所有列转换为多行展示。
molten.ships <- melt(ships, id = c("type","year"))
print(molten.ships)当我们执行上面的代码，它产生以下结果 -
type year variable value
1 A 60 period 60
2 A 60 period 75
3 A 65 period 60
4 A 65 period 75
............
............
9 B 60 period 60
10 B 60 period 75
11 B 65 period 60
12 B 65 period 75
13 B 70 period 60
...........
...........
41 A 60 service 127
42 A 60 service 63
43 A 65 service 1095
...........
...........
70 D 70 service 1208
71 D 75 service 0
72 D 75 service 2051
73 E 60 service 45
74 E 60 service 0
75 E 65 service 789
...........
...........
101 C 70 incidents 6
102 C 70 incidents 2
103 C 75 incidents 0
104 C 75 incidents 1
105 D 60 incidents 0
106 D 60 incidents 0
...........
...........cast()重构数据
我们可以将被拆分的数据转换为一种新形式，使用cast()函数创建每年每种类型的船的总和。
recasted.ship <- cast(molten.ships, type+year~variable,sum)
print(recasted.ship)当我们执行上面的代码，它产生以下结果 -
type year period service incidents
1 A 60 135 190 0
2 A 65 135 2190 7
3 A 70 135 4865 24
4 A 75 135 2244 11
5 B 60 135 62058 68
6 B 65 135 48979 111
7 B 70 135 20163 56
8 B 75 135 7117 18
9 C 60 135 1731 2
10 C 65 135 1457 1
11 C 70 135 2731 8
12 C 75 135 274 1
13 D 60 135 356 0
14 D 65 135 480 0
15 D 70 135 1557 13
16 D 75 135 2051 4
17 E 60 135 45 0
18 E 65 135 1226 14
19 E 70 135 3318 17
20 E 75 135 542 1十一.函数
函数是一组组合在一起以执行特定任务的语句。 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 frm 41 to 68.
print(sum(41:68))当我们执行上面的代码，它产生以下结果 -
[1] 32 33 34 35 36 37 38 39 40 41 42 43 44
[1] 53.5
[1] 1526用户定义的函数
我们可以在R语言中创建用户定义的函数。它们特定于用户想要的，一旦创建，它们就可以像内置函数一样使用。 下面是一个创建和使用函数的例子。
# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
for(i in 1:a) {
b <- i^2
print(b)
}
} 调用函数
# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
for(i in 1:a) {
b <- i^2
print(b)
}
}
# Call the function new.function supplying 6 as an argument.
new.function(6)当我们执行上面的代码，它产生以下结果 -
[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36调用没有参数的函数
# Create a function without an argument.
new.function <- function() {
for(i in 1:5) {
print(i^2)
}
}
# Call the function without supplying an argument.
new.function()当我们执行上面的代码，它产生以下结果 -
[1] 1
[1] 4
[1] 9
[1] 16
[1] 25使用参数值调用函数（按位置和名称）
函数调用的参数可以按照函数中定义的顺序提供，也可以以不同的顺序提供，但分配给参数的名称。
# Create a function with arguments.
new.function <- function(a,b,c) {
result <- a * b + c
print(result)
}
# Call the function by position of arguments.
new.function(5,3,11)
# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)当我们执行上面的代码，它产生以下结果 -
[1] 26
[1] 58使用默认参数调用函数
我们可以在函数定义中定义参数的值，并调用函数而不提供任何参数以获取默认结果。 但是我们也可以通过提供参数的新值来获得非默认结果来调用这样的函数。
# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
result <- a * b
print(result)
}
# Call the function without giving any argument.
new.function()
# Call the function with giving new values of the argument.
new.function(9,5)当我们执行上面的代码，它产生以下结果 -
[1] 18
[1] 45功能的延迟计算
对函数的参数进行延迟评估，这意味着它们只有在函数体需要时才进行评估。
# Create a function with arguments.
new.function <- function(a, b) {
print(a^2)
print(a)
print(b)
}
# Evaluate the function without supplying one of the arguments.
new.function(6)当我们执行上面的代码，它产生以下结果 -
[1] 36
[1] 6
Error in print(b) : argument "b" is missing, with no default十二.字符串
在R语言中的单引号或双引号对中写入的任何值都被视为字符串.R语言存储的每个字符串都在双引号内，即使是使用单引号创建的依旧如此。
在字符串构造中应用的规则
在字符串的开头和结尾的引号应该是两个双引号或两个单引号。它们不能被混合。
双引号可以插入到以单引号开头和结尾的字符串中。
单引号可以插入以双引号开头和结尾的字符串。
双引号不能插入以双引号开头和结尾的字符串。
单引号不能插入以单引号开头和结尾的字符串。
有效字符串的示例
以下示例阐明了在ř 语言中创建³³字符串的规则。
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 ' inside
unexpected symbol
1: g <- "Double quotes " inside字符串操作
连接字符串 - paste（）函数
R 语言中的许多字符串使用paste（）函数组合。它可以采取任何数量的参数组合在一起。
#####语法
对于粘贴功能的基本语法是 -
paste(..., sep = " ", collapse = NULL)以下是所使用的参数的说明 -
…表示要组合的任意数量的自变量。
九月表示参数之间的任何分隔符。它是可选的。
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是向量输入。
数字是显示的总位数。
nsmall是小数点右边的最小位数。
科学设置为TRUE以显示科学记数法。
宽度指示通过在开始处填充空白来显示的最小宽度。
理由是字符串向左，右或中心的显示。
例
# Total number of digits displayed. Last digit rounded off.
result <- format(23.123456789, digits = 9)
print(result)
# Display numbers in scientific notation.
result <- format(c(6, 13.14521), scientific = TRUE)
print(result)
# The minimum number of digits to the right of the decimal point.
result <- format(23.47, nsmall = 5)
print(result)
# Format treats everything as a string.
result <- format(6)
print(result)
# Numbers are padded with blank in the beginning for width.
result <- format(13.7, width = 6)
print(result)
# Left justify strings.
result <- format("Hello", width = 8, justify = "l")
print(result)
# Justfy string with center.
result <- format("Hello", width = 8, justify = "c")
print(result)当我们执行上面的代码，它产生以下结果 -
[1] "23.1234568"
[1] "6.000000e+00" "1.314521e+01"
[1] "23.47000"
[1] "6"
[1] " 13.7"
[1] "Hello "
[1] " Hello "计算字符串中的字符数 - nchar（）函数
此函数计算字符串中包含空格的字符数。
语法
nchar（）函数的基本语法是 -
nchar(x)
以下是所使用的参数的描述 -
- X是向量输入。
例
result <- nchar("Count the number of characters")
print(result)当我们执行上面的代码，它产生以下结果 -
[1] 30更改案例 - toupper（）和tolower（）函数
这些函数改变字符串的字符的大小写。
语法
toupper（）和tolower（）函数的基本语法是 -
toupper(x)
tolower(x)以下是所使用的参数的描述 -
- X是向量输入。
例
# Changing to Upper case.
result <- toupper("Changing To Upper")
print(result)
# Changing to lower case.
result <- tolower("Changing To Lower")
print(result)当我们执行上面的代码，它产生以下结果 -
[1] "CHANGING TO UPPER"
[1] "changing to lower"提取字符串的一部分 - substring（）函数
此函数提取字符串的部分。
语法
substring（）函数的基本语法是 -
substring(x,first,last)以下是所使用的参数的描述 -
X是字符向量输入。
首先是要提取的第一个字符的位置。
最后是要提取的最后一个字符的位置。
例
# 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:13
print(v)
# Creating a sequence from 6.6 to 12.6.
v <- 6.6:12.6
print(v)
# If the final element specified does not belong to the sequence then it is discarded.
v <- 3.8:11.4
print(v)当我们执行上面的代码，它产生以下结果 -
[1] 5 6 7 8 9 10 11 12 13
[1] 6.6 7.6 8.6 9.6 10.6 11.6 12.6
[1] 3.8 4.8 5.8 6.8 7.8 8.8 9.8 10.8使用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] "Sun"向量操作
向量运算
可以添加，减去，相乘或相除两个相同长度的向量，将结果作为向量输出。
# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)
# Vector addition.
add.result <- v1+v2
print(add.result)
# Vector substraction.
sub.result <- v1-v2
print(sub.result)
# Vector multiplication.
multi.result <- v1*v2
print(multi.result)
# Vector division.
divi.result <- v1/v2
print(divi.result)当我们执行上面的代码，它产生以下结果 -
[1] 7 19 4 13 1 13
[1] -1 -3 4 -3 -1 9
[1] 12 88 0 40 0 22
[1] 0.7500000 0.7272727 Inf 0.6250000 0.0000000 5.5000000向量元素回收
如果我们对不等长的两个向量应用算术运算，则较短向量的元素被循环以完成操作。
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)
add.result <- v1+v2
print(add.result)
sub.result <- v1-v2
print(sub.result)当我们执行上面的代码，它产生以下结果 -
[1] 7 19 8 16 4 22
[1] -1 -3 0 -6 -4 0向量元素排序
向量中的元素可以使用sort()函数排序。
v <- c(3,8,4,5,0,11, -9, 304)
# Sort the elements of the vector.
sort.result <- sort(v)
print(sort.result)
# Sort the elements in the reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)
# Sorting character vectors.
v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)
# Sorting character vectors in reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)当我们执行上面的代码，它产生以下结果 -
[1] -9 0 3 4 5 8 11 304
[1] 304 11 8 5 4 3 0 -9
[1] "Blue" "Red" "violet" "yellow"
[1] "yellow" "violet" "Red" "Blue" 十四.列表
列表是R语言对象，它包含不同类型的元素，如数字，字符串，向量和其中的另一个列表。列表还可以包含矩阵或函数作为其元素。列表是使用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"合并列表
通过将所有列表放在一个列表（）函数中，您可以将许多列表合并到一个列表中。
# Create two lists.
list1 <- list(1,2,3)
list2 <- list("Sun","Mon","Tue")
# Merge the two lists.
merged.list <- c(list1,list2)
# Print the merged list.
print(merged.list)当我们执行上面的代码，它产生以下结果 -
[[1]]
[1] 1
[[2]]
[1] 2
[[3]]
[1] 3
[[4]]
[1] "Sun"
[[5]]
[1] "Mon"
[[6]]
[1] "Tue"将列表转换为向量
列表可以转换为向量，使得向量的元素可以用于进一步的操作。可以在将列表转换为向量之后应用对向量的所有算术运算。要做这个转换，我们使用unlist（）函数。它将列表作为输入并生成向量。
# Create lists.
list1 <- list(1:5)
print(list1)
list2 <-list(10:14)
print(list2)
# Convert the lists to vectors.
v1 <- unlist(list1)
v2 <- unlist(list2)
print(v1)
print(v2)
# Now add the vectors
result <- v1+v2
print(result)当我们执行上面的代码，它产生以下结果 -
[[1]]
[1] 1 2 3 4 5
[[1]]
[1] 10 11 12 13 14
[1] 1 2 3 4 5
[1] 10 11 12 13 14
[1] 11 13 15 17 19十五.矩阵
矩阵是其中元素以二维矩形布局布置的R对象。 它们包含相同原子类型的元素。 虽然我们可以创建一个只包含字符或只包含逻辑值的矩阵，但它们没有太多用处。 我们使用包含数字元素的矩阵用于数学计算。
使用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 col3
row1 3 4 5
row2 6 7 8
row3 9 10 11
row4 12 13 14访问矩阵的元素
可以通过使用元素的列和行索引来访问矩阵的元素。 我们考虑上面的矩阵P找到下面的具体元素。
# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")
# Create the matrix.
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
# Access the element at 3rd column and 1st row.
print(P[1,3])
# Access the element at 2nd column and 4th row.
print(P[4,2])
# Access only the 2nd row.
print(P[2,])
# Access only the 3rd column.
print(P[,3])当我们执行上面的代码，它产生以下结果 -
[1] 5
[1] 13
col1 col2 col3
6 7 8
row1 row2 row3 row4
5 8 11 14 矩阵计算
使用R运算符对矩阵执行各种数学运算。 操作的结果也是一个矩阵。
对于操作中涉及的矩阵，维度（行数和列数）应该相同。
矩阵加法和减法
# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)
matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)
# Add the matrices.
result <- matrix1 + matrix2
cat("Result of addition","
")
print(result)
# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","
")
print(result)当我们执行上面的代码，它产生以下结果 -
[,1] [,2] [,3]
[1,] 3 -1 2
[2,] 9 4 6
[,1] [,2] [,3]
[1,] 5 0 3
[2,] 2 9 4
Result of addition
[,1] [,2] [,3]
[1,] 8 -1 5
[2,] 11 13 10
Result of subtraction
[,1] [,2] [,3]
[1,] -2 -1 -1
[2,] 7 -5 2矩阵乘法和除法
# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)
matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)
# Multiply the matrices.
result <- matrix1 * matrix2
cat("Result of multiplication","
")
print(result)
# Divide the matrices
result <- matrix1 / matrix2
cat("Result of division","
")
print(result)当我们执行上面的代码，它产生以下结果 -
[,1] [,2] [,3]
[1,] 3 -1 2
[2,] 9 4 6
[,1] [,2] [,3]
[1,] 5 0 3
[2,] 2 9 4
Result of multiplication
[,1] [,2] [,3]
[1,] 15 0 6
[2,] 18 36 24
Result of division
[,1] [,2] [,3]
[1,] 0.6 -Inf 0.6666667
[2,] 4.5 0.4444444 1.5000000十六.数组
数组对可以在两个以上维度中存储数据的R数据对象。例如 - 如果我们创建一个维度（2,3,4）的数组，则它创造4个矩形矩阵，每个矩阵具有2行和3列数组只能存储数据类型。
使用array（）函数创建数组。它使用向量作为输入，并使用dim参数中的值创建数组。
例
以下示例创建一个由两个3x3的矩阵组成的数组，每个矩阵具有3行和3列。
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)当我们执行上面的代码，它产生以下结果 -
, , 1
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15
, , 2
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15命名列和行
我们可以使用dimnames参数给数组中的行，列和矩阵命名。
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")
# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
matrix.names))
print(result)当我们执行上面的代码，它产生以下结果 -
, , Matrix1
COL1 COL2 COL3
ROW1 5 10 13
ROW2 9 11 14
ROW3 3 12 15
, , Matrix2
COL1 COL2 COL3
ROW1 5 10 13
ROW2 9 11 14
ROW3 3 12 15访问数组元素
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")
# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
column.names, matrix.names))
# Print the third row of the second matrix of the array.
print(result[3,,2])
# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])
# Print the 2nd Matrix.
print(result[,,2])当我们执行上面的代码，它产生以下结果 -
COL1 COL2 COL3
3 12 15
[1] 13
COL1 COL2 COL3
ROW1 5 10 13
ROW2 9 11 14
ROW3 3 12 15操作数组元素
由于数组由多维构成矩阵，所以对数组元素的操作通过访问矩阵的元素来执行。
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
# Take these vectors as input to the array.
array1 <- array(c(vector1,vector2),dim = c(3,3,2))
# Create two vectors of different lengths.
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))
# create matrices from these arrays.
matrix1 <- array1[,,2]
matrix2 <- array2[,,2]
# Add the matrices.
result <- matrix1+matrix2
print(result)当我们执行上面的代码，它产生以下结果 -
[,1] [,2] [,3]
[1,] 10 20 26
[2,] 18 22 28
[3,] 6 24 30跨数组元素的计算
我们可以使用适用（）函数在数组中的元素上进行计算。
语法
apply(x, margin, fun)以下是所使用的参数的说明 -
X是一个数组。
保证金是所使用的数据集的名称。
有趣的是要应用于数组元素的函数。
例
我们使用下面的适用（）函数计算所有矩阵中数组行中元素的总和。
# 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十七.因子
因子是用于对数据进行分类并将其存储为级别的数据对象。 它们可以存储字符串和整数。 它们在具有有限数量的唯一值的列中很有用。 像“男性”，“女性”和True，False等。它们在统计建模的数据分析中很有用。
使用factor()函数通过将向量作为输入创建因子。
例
# Create a vector as input.
data <- c("East","West","East","North","North","East","West","West","West","East","North")
print(data)
print(is.factor(data))
# Apply the factor function.
factor_data <- factor(data)
print(factor_data)
print(is.factor(factor_data))当我们执行上面的代码，它产生以下结果 -
[1] "East" "West" "East" "North" "North" "East" "West" "West" "West" "East" "North"
[1] FALSE
[1] East West East North North East West West West East North
Levels: East North West
[1] TRUE数据帧的因子
在创建具有文本数据列的任何数据框时，R语言将文本列视为分类数据并在其上创建因子。
# Create the vectors for data frame.
height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")
# Create the data frame.
input_data <- data.frame(height,weight,gender)
print(input_data)
# Test if the gender column is a factor.
print(is.factor(input_data$gender))
# Print the gender column so see the levels.
print(input_data$gender)当我们执行上面的代码，它产生以下结果 -
height weight gender
1 132 48 male
2 151 49 male
3 162 66 female
4 139 53 female
5 166 67 male
6 147 52 female
7 122 40 male
[1] TRUE
[1] male male female female male female male
Levels: female male更改级别顺序
可以通过使用新的等级次序再次应用因子函数来改变因子中的等级的顺序。
data <- c("East","West","East","North","North","East","West","West","West","East","North")
# Create the factors
factor_data <- factor(data)
print(factor_data)
# Apply the factor function with required order of the level.
new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)当我们执行上面的代码，它产生以下结果 -
[1] East West East North North East West West West East North
Levels: East North West
[1] East West East North North East West West West East North
Levels: East West North生成因子级别
我们可以使用gl()函数生成因子级别。 它需要两个整数作为输入，指示每个级别有多少级别和多少次。
语法
gl(n, k, labels)以下是所使用的参数的说明 -
n是给出级数的整数。
k是给出复制数目的整数。
labels是所得因子水平的标签向量。
例
v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
print(v)当我们执行上面的代码，它产生以下结果 -
Tampa Tampa Tampa Tampa Seattle Seattle Seattle Seattle Boston
[10] Boston Boston Boston
Levels: Tampa Seattle Boston#十八.数据帧
数据帧是表或二维阵列状结构，其中每一列包含一个变量的值，并且每一行包含来自每一列的一组值。
以下是数据帧的特性。
列名称应为非空。
行名称应该是唯一的。
存储在数据帧中的数据可以是数字，因子或字符类型。
每个列应包含相同数量的数据项。
创建数据帧
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Print the data frame. print(emp.data)当我们执行上面的代码，它产生以下结果 -
emp_id emp_name salary start_date 1 1 Rick 623.30 2012-01-01 2 2 Dan 515.20 2013-09-23 3 3 Michelle 611.00 2014-11-15 4 4 Ryan 729.00 2014-05-11 5 5 Gary 843.25 2015-03-27获取数据帧的结构
通过使用str()函数可以看到数据帧的结构。
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Get the structure of the data frame. str(emp.data)当我们执行上面的代码，它产生以下结果 -
'data.frame': 5 obs. of 4 variables: $ emp_id : int 1 2 3 4 5 $ emp_name : chr "Rick" "Dan" "Michelle" "Ryan" ... $ salary : num 623 515 611 729 843 $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...数据框中的数据摘要
可以通过应用summary()函数获取数据的统计摘要和性质。
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Print the summary. print(summary(emp.data))当我们执行上面的代码，它产生以下结果 -
emp_id emp_name salary start_date Min. :1 Length:5 Min. :515.2 Min. :2012-01-01 1st Qu.:2 Class :character 1st Qu.:611.0 1st Qu.:2013-09-23 Median :3 Mode :character Median :623.3 Median :2014-05-11 Mean :3 Mean :664.4 Mean :2014-01-14 3rd Qu.:4 3rd Qu.:729.0 3rd Qu.:2014-11-15 Max. :5 Max. :843.2 Max. :2015-03-27从数据帧提取数据
使用列名称从数据框中提取特定列。
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Extract Specific columns. result <- data.frame(emp.data$emp_name,emp.data$salary) print(result)当我们执行上面的代码，它产生以下结果 -
emp.data.emp_name emp.data.salary 1 Rick 623.30 2 Dan 515.20 3 Michelle 611.00 4 Ryan 729.00 5 Gary 843.25先提取前两行，然后提取所有列
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Extract first two rows. result <- emp.data[1:2,] print(result)当我们执行上面的代码，它产生以下结果 -
emp_id emp_name salary start_date 1 1 Rick 623.3 2012-01-01 2 2 Dan 515.2 2013-09-23用第2和第4列提取第3和第5行
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Extract 3rd and 5th row with 2nd and 4th column. result <- emp.data[c(3,5),c(2,4)] print(result)当我们执行上面的代码，它产生以下结果 -
emp_name start_date 3 Michelle 2014-11-15 5 Gary 2015-03-27扩展数据帧
可以通过添加列和行来扩展数据帧。
添加列
只需使用新的列名称添加列向量。
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Add the "dept" coulmn.
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)当我们执行上面的代码，它产生以下结果 -
emp_id emp_name salary start_date dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 5 Gary 843.25 2015-03-27 Finance添加行
要将更多行永久添加到现有数据帧，我们需要引入与现有数据帧相同结构的新行，并使用rbind()函数。
在下面的示例中，我们创建一个包含新行的数据帧，并将其与现有数据帧合并以创建最终数据帧。
# Create the first data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
dept = c("IT","Operations","IT","HR","Finance"),
stringsAsFactors = FALSE
)
# Create the second data frame
emp.newdata <- data.frame(
emp_id = c (6:8),
emp_name = c("Rasmi","Pranab","Tusar"),
salary = c(578.0,722.5,632.8),
start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
dept = c("IT","Operations","Fianance"),
stringsAsFactors = FALSE
)
# Bind the two data frames.
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)当我们执行上面的代码，它产生以下结果 -
emp_id emp_name salary start_date dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 5 Gary 843.25 2015-03-27 Finance
6 6 Rasmi 578.00 2013-05-21 IT
7 7 Pranab 722.50 2013-07-30 Operations
8 8 Tusar 632.80 2014-06-17 Fianance进阶篇
1.条形图
条形图表示矩形条中的数据，条的长度与变量的值成比例。 R语言使用函数barplot()创建条形图。 R语言可以在条形图中绘制垂直和水平条。 在条形图中，每个条可以给予不同的颜色。
语法
在R语言中创建条形图的基本语法是 -
barplot(H, xlab, ylab, main, names.arg, col)以下是所使用的参数的描述 -
H是包含在条形图中使用的数值的向量或矩阵。
xlab是x轴的标签。
ylab是y轴的标签。
main是条形图的标题。
names.arg是在每个条下出现的名称的向量。
col用于向图中的条形提供颜色。
例
使用输入向量和每个条的名称创建一个简单的条形图。
以下脚本将创建并保存当前R语言工作目录中的条形图。
# Give the chart file a name.
png(file = "barchart.png")
# Plot the bar chart.
barplot(H)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
条形图标签，标题和颜色
可以通过添加更多参数来扩展条形图的功能。 主要参数用于添加标题。 col参数用于向条形添加颜色。 args.name是具有与输入向量相同数量的值的向量，以描述每个条的含义。
例
以下脚本将在当前R语言工作目录中创建并保存条形图。
# Create the data for the chart.
H <- c(7,12,28,3,41)
M <- c("Mar","Apr","May","Jun","Jul")
# Give the chart file a name.
png(file = "barchart_months_revenue.png")
# Plot the bar chart.
barplot(H,names.arg = M,xlab = "Month",ylab = "Revenue",col = "blue",
main = "Revenue chart",border = "red")
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
组合条形图和堆积条形图
我们可以使用矩阵作为输入值，在每个条中创建条形图和堆叠组的条形图。
超过两个变量表示为用于创建组合条形图和堆叠条形图的矩阵。
# Create the input vectors.
colors <- c("green","orange","brown")
months <- c("Mar","Apr","May","Jun","Jul")
regions <- c("East","West","North")
# Create the matrix of the values.
Values <- matrix(c(2,9,3,11,9,4,8,7,3,12,5,2,8,10,11),nrow = 3,ncol = 5,byrow = TRUE)
# Give the chart file a name.
png(file = "barchart_stacked.png")
# Create the bar chart.
barplot(Values,main = "total revenue",names.arg = months,xlab = "month",ylab = "revenue",
col = colors)
# Add the legend to the chart.
legend("topleft", regions, cex = 1.3, fill = colors)
# Save the file.
dev.off()
2.箱线图
箱线图是数据集中的数据分布良好的度量。 它将数据集分成三个四分位数。 此图表表示数据集中的最小值，最大值，中值，第一四分位数和第三四分位数。 它还可用于通过绘制每个数据集的箱线图来比较数据集之间的数据分布。
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 cyl
Mazda RX4 21.0 6
Mazda RX4 Wag 21.0 6
Datsun 710 22.8 4
Hornet 4 Drive 21.4 6
Hornet Sportabout 18.7 8
Valiant 18.1 6创建箱线图
以下脚本将为mpg（英里/加仑）和cyl（气缸数）之间的关系创建箱线图。
# Give the chart file a name.
png(file = "boxplot.png")
# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, xlab = "Number of Cylinders",
ylab = "Miles Per Gallon", main = "Mileage Data")
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
带槽的箱线图
我们可以绘制带槽的箱线图，以了解不同数据组的中值如何相互匹配。
以下脚本将为每个数据组创建一个带缺口的箱线图。
# Give the chart file a name.
png(file = "boxplot_with_notch.png")
# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars,
xlab = "Number of Cylinders",
ylab = "Miles Per Gallon",
main = "Mileage Data",
notch = TRUE,
varwidth = TRUE,
col = c("green","yellow","purple"),
names = c("High","Medium","Low")
)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
[图片上传中…(image-9f3e39-1552623568628-0)]
3.直方图
直方图表示被存储到范围中的变量的值的频率。 直方图类似于条形图，但不同之处在于将值分组为连续范围。 直方图中的每个柱表示该范围中存在的值的数量的高度。
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值的范围
要指定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()当我们执行上面的代码，它产生以下结果 -
[图片上传中…(image-d6f09b-1552623852107-0)]
4.折线图
折线图是通过在它们之间绘制线段来连接一系列点的图。这些点在它们的坐标（通常是x坐标）值之一中排序。折线图通常用于识别数据中的趋势。
R语言中的情节（）函数用于创建折线图。
###语法
在R语言中创建折线图的基本语法是 -
plot(v,type,col,xlab,ylab)以下是所使用的参数的描述 -
使用输入向量和类型参数“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()当我们执行上面的代码，它产生以下结果 -
[图片上传中…(image-469771-1552624000469-2)]
折线图标题，颜色和标签
线图的特征可以通过使用附加参数来扩展。我们向点和线添加颜色，为图表添加标题，并向轴添加标签。
例
# Create the data for the chart.
v <- c(7,12,28,3,41)
# Give the chart file a name.
png(file = "line_chart_label_colored.jpg")
# Plot the bar chart.
plot(v,type = "o", col = "red", xlab = "Month", ylab = "Rain fall",
main = "Rain fall chart")
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
多线型折线图
通过使用lines（）函数，可以在同一个图表上绘制多条线。
在绘制第一行之后，lines （）函数可以使用一个额外的向量作为输入来绘制图表中的第二行。
# Create the data for the chart.
v <- c(7,12,28,3,41)
t <- c(14,7,6,19,3)
# Give the chart file a name.
png(file = "line_chart_2_lines.jpg")
# Plot the bar chart.
plot(v,type = "o",col = "red", xlab = "Month", ylab = "Rain fall",
main = "Rain fall chart")
lines(t, type = "o", col = "blue")
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
5.散点图
散点图显示在笛卡尔平面中绘制的许多点。 每个点表示两个变量的值。 在水平轴上选择一个变量，在垂直轴上选择另一个变量。
使用plot()函数创建简单散点图。
语法
在R语言中创建散点图的基本语法是 -
plot(x, y, main, xlab, ylab, xlim, ylim, axes)以下是所使用的参数的描述 -
x是其值为水平坐标的数据集。
y是其值是垂直坐标的数据集。
main要是图形的图块。
xlab是水平轴上的标签。
ylab是垂直轴上的标签。
xlim是用于绘图的x的值的极限。
ylim是用于绘图的y的值的极限。
axes指示是否应在绘图上绘制两个轴。
例
我们使用R语言环境中可用的数据集“mtcars”来创建基本散点图。 让我们使用mtcars中的“wt”和“mpg”列。
input <- mtcars[,c('wt','mpg')]
print(head(input))当我们执行上面的代码，它产生以下结果 -
wt mpg
Mazda RX4 2.620 21.0
Mazda RX4 Wag 2.875 21.0
Datsun 710 2.320 22.8
Hornet 4 Drive 3.215 21.4
Hornet Sportabout 3.440 18.7
Valiant 3.460 18.1创建散点图
以下脚本将为wt（重量）和mpg（英里/加仑）之间的关系创建一个散点图。
# Get the input values.
input <- mtcars[,c('wt','mpg')]
# Give the chart file a name.
png(file = "scatterplot.png")
# Plot the chart for cars with weight between 2.5 to 5 and mileage between 15 and 30.
plot(x = input$wt,y = input$mpg,
xlab = "Weight",
ylab = "Milage",
xlim = c(2.5,5),
ylim = c(15,30),
main = "Weight vs Milage"
)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
散点图矩阵
当我们有两个以上的变量，我们想找到一个变量和其余变量之间的相关性，我们使用散点图矩阵。 我们使用pairs()函数创建散点图的矩阵。
语法
在R中创建散点图矩阵的基本语法是 -
pairs(formula, data)以下是所使用的参数的描述 -
formula表示成对使用的一系列变量。
data表示将从其获取变量的数据集。
例
每个变量与每个剩余变量配对。 为每对绘制散点图。
# Give the chart file a name.
png(file = "scatterplot_matrices.png")
# Plot the matrices between 4 variables giving 12 plots.
# One variable with 3 others and total 4 variables.
pairs(~wt+mpg+disp+cyl,data = mtcars,
main = "Scatterplot Matrix")
# Save the file.
dev.off()当执行上面的代码中，我们得到以下输出。
6.饼状图
R编程语言有许多库来创建图表和图表。 饼图是将值表示为具有不同颜色的圆的切片。 切片被标记，并且对应于每个片的数字也在图表中表示。
在R语言中，饼图是使用pie()函数创建的，它使用正数作为向量输入。 附加参数用于控制标签，颜色，标题等。
语法
使用R语言创建饼图的基本语法是 -
pie(x, labels, radius, main, col, clockwise)以下是所使用的参数的描述 -
x是包含饼图中使用的数值的向量。
labels用于给出切片的描述。
radius表示饼图圆的半径（值-1和+1之间）。
main表示图表的标题。
col表示调色板。
clockwise是指示片段是顺时针还是逆时针绘制的逻辑值。
例
使用输入向量和标签创建一个非常简单的饼图。 以下脚本将创建并保存当前R语言工作目录中的饼图。
# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")
# Give the chart file a name.
png(file = "city.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()当我们执行上面的代码，它产生以下结果 -
[图片上传中…(image-f4714e-1552624406629-1)]
3D饼图
可以使用其他软件包绘制具有3个维度的饼图。 软件包plotrix有一个名为pie3D（）的函数，用于此。
# Get the library.
library(plotrix)
# Create data for the graph.
x <- c(21, 62, 10,53)
lbl <- c("London","New York","Singapore","Mumbai")
# Give the chart file a name.
png(file = "3d_pie_chart.jpg")
# Plot the chart.
pie3D(x,labels = lbl,explode = 0.1, main = "Pie Chart of Countries ")
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
7.CSV文件
在R语言中，我们可以从存储在R语言环境外的文件中读取数据。我们还可以将数据写入将被操作系统存储和访问的文件.R语言可以读取和写入各种文件格式，如CSV，EXCEL，XML等。
在本章中，我们将学习从csv文件读取数据，然后将数据写入csv文件。该文件应该存在于当前工作目录中，以便R语言可以读取它。当然我们也可以设置我们自己的目录并从那里读取文件。
获取和设置工作目录
您可以使用getwd（）函数检查R语言工作区指向的目录。您还可以使用setwd（）函数设置新的工作目录。
# Get and print current working directory.
print(getwd())
# Set current working directory.
setwd("/web/com")
# Get and print current working directory.
print(getwd())当我们执行上面的代码，它产生以下结果 -
[1] "/web/com/1441086124_2016"
[1] "/web/com"此结果取决于您的操作系统和您当前工作的目录。
输入为CSV文件
CSV文件是一个文本文件，其中列中的值由逗号分隔。让我们考虑名为input.csv的文件中出现的以下数据。
您可以通过复制和粘贴此数据使用的Windows记事本创建此文件。使用记事本中的保存为所有文件（。）选项将文件保存为input.csv。
id,name,salary,start_date,dept
1,Rick,623.3,2012-01-01,IT
2,Dan,515.2,2013-09-23,Operations
3,Michelle,611,2014-11-15,IT
4,Ryan,729,2014-05-11,HR
,Gary,843.25,2015-03-27,Finance
6,Nina,578,2013-05-21,IT
7,Simon,632.8,2013-07-30,Operations
8,Guru,722.5,2014-06-17,Finance读取CSV文件
以下是read.csv（）函数的一个简单示例，用于读取当前工作目录中可用的CSV文件 -
data <- read.csv("input.csv")
print(data)当我们执行上面的代码，它产生以下结果 -
id, name, salary, start_date, dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
6 6 Nina 578.00 2013-05-21 IT
7 7 Simon 632.80 2013-07-30 Operations
8 8 Guru 722.50 2014-06-17 Finance分析CSV文件
默认情况下，read.csv（）函数将输出作为数据帧。这可以容易地如下检查。此外，我们可以检查列和行的数量。
data <- read.csv("input.csv")
print(is.data.frame(data))
print(ncol(data))
print(nrow(data))当我们执行上面的代码，它产生以下结果 -
[1] TRUE
[1] 5
[1] 8一旦我们读取数据帧中的数据，我们可以应用所有适用于数据帧的函数，如下一节所述。
获得最高工资
# Create a data frame.
data <- read.csv("input.csv")
# Get the max salary from data frame.
sal <- max(data$salary)
print(sal)当我们执行上面的代码，它产生以下结果 -
[1] 843.25获取具有最高工资的人的详细信息
我们可以获取满足特定过滤条件的行，类似于SQL where子句。
# Create a data frame.
data <- read.csv("input.csv")
# Get the max salary from data frame.
sal <- max(data$salary)
# Get the person detail having max salary.
retval <- subset(data, salary == max(salary))
print(retval)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept
5 NA Gary 843.25 2015-03-27 Finance获取所有的IT部门员工的信息
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset( data, dept == "IT")
print(retval)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept
1 1 Rick 623.3 2012-01-01 IT
3 3 Michelle 611.0 2014-11-15 IT
6 6 Nina 578.0 2013-05-21 IT获得工资大于600的IT部门的人员
# Create a data frame.
data <- read.csv("input.csv")
info <- subset(data, salary > 600 & dept == "IT")
print(info)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept
1 1 Rick 623.3 2012-01-01 IT
3 3 Michelle 611.0 2014-11-15 IT获得2014年或之后加入的人
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
print(retval)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
8 8 Guru 722.50 2014-06-17 Finance写入CSV文件
R语言可以创建csv文件形式的现有数据帧.write.csv（）函数用于创建csv文件。此文件在工作目录中创建。
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
# Write filtered data into a new file.
write.csv(retval,"output.csv")
newdata <- read.csv("output.csv")
print(newdata)当我们执行上面的代码，它产生以下结果 -
X id name salary start_date dept
1 3 3 Michelle 611.00 2014-11-15 IT
2 4 4 Ryan 729.00 2014-05-11 HR
3 5 NA Gary 843.25 2015-03-27 Finance
4 8 8 Guru 722.50 2014-06-17 Finance这里列X来自数据集newper。这可以在写入文件时使用附加参数删除。
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
# Write filtered data into a new file.
write.csv(retval,"output.csv", row.names = FALSE)
newdata <- read.csv("output.csv")
print(newdata)当我们执行上面的代码，它产生以下结果 -
id name salary start_date dept
1 3 Michelle 611.00 2014-11-15 IT
2 4 Ryan 729.00 2014-05-11 HR
3 NA Gary 843.25 2015-03-27 Finance
4 8 Guru 722.50 2014-06-17 Finance8.Excel文件
Microsoft Excel是最广泛使用的电子表格程序，以.xls或.xlsx格式存储数据。 R语言可以直接从这些文件使用一些excel特定的包。 很少这样的包是 - XLConnect，xlsx，gdata等。我们将使用xlsx包。 R语言也可以使用这个包写入excel文件。
安装xlsx软件包
您可以在R控制台中使用以下命令来安装“xlsx”软件包。 它可能会要求安装一些额外的软件包这个软件包依赖。 按照具有所需软件包名称的同一命令安装其他软件包。
install.packages("xlsx")验证并加载“xlsx”软件包
使用以下命令验证并加载“xlsx”软件包。
# Verify the package is installed.
any(grepl("xlsx",installed.packages()))
# Load the library into R workspace.
library("xlsx")当脚本运行，我们得到以下输出。
[1] TRUE
Loading required package: rJava
Loading required package: methods
Loading required package: xlsxjars输入为xlsx文件
打开Microsoft Excel。 将以下数据复制并粘贴到名为sheet1的工作表中。
id name salary start_date dept
1 Rick 623.3 1/1/2012 IT
2 Dan 515.2 9/23/2013 Operations
3 Michelle 611 11/15/2014 IT
4 Ryan 729 5/11/2014 HR
5 Gary 843.25 3/27/2015 Finance
6 Nina 578 5/21/2013 IT
7 Simon 632.8 7/30/2013 Operations
8 Guru 722.5 6/17/2014 Finance还要将以下数据复制并粘贴到另一个工作表，并将此工作表重命名为“city”。
name city
Rick Seattle
Dan Tampa
Michelle Chicago
Ryan Seattle
Gary Houston
Nina Boston
Simon Mumbai
Guru Dallas将Excel文件另存为“input.xlsx”。 应将其保存在R工作区的当前工作目录中。
读取Excel文件
通过使用read.xlsx()函数读取input.xlsx，如下所示。 结果作为数据帧存储在R语言环境中。
# Read the first worksheet in the file input.xlsx.
data <- read.xlsx("input.xlsx", sheetIndex = 1)
print(data)当我们执行上面的代码，它产生以下结果 -
id, name, salary, start_date, dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
6 6 Nina 578.00 2013-05-21 IT
7 7 Simon 632.80 2013-07-30 Operations
8 8 Guru 722.50 2014-06-17 Finance9.二进制文件
二进制文件是包含仅以位和字节（0和1）的形式存储的信息的文件。它们不是人类可读的，因为它中的字节转换为包含许多其他不可打印字符的字符和符号。尝试使用任何文本编辑器读取二进制文件将显示如Ø和d的字符。
二进制文件必须由特定程序读取才能使用。例如，Microsoft Word程序的二进制文件只能通过Word程序读取到人类可读的形式。这表示，除了人类可读的文本之外，还有更多的信息，例如字符和页码等的格式化，它们也与字母数字字符一起存储。最后一个二进制文件是一个连续的字节序列。我们在文本文件中看到的换行符是连接第一行到下一行的字符。
有时，由其他程序生成的数据需要由ř作为二进制文件处理。另外，R语言是创建可以与其他程序共享的二进制文件所必需的。
ř语言有两个函数WriteBin（）和readBin（）来创建和读取二进制文件。
语法
writeBin(object, con)
readBin(con, what, n )以下是所使用的参数的描述 -
CON是读取或写入二进制文件的连接对象。
对象是要写入的二进制文件。
什么是模式，如字符，整数等表示要读取的字节。
ñ是从二进制文件读取的字节数。
例
我们考虑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.names
print(finaldata)当我们执行上面的代码，它产生以下结果和图表 -
[1] 7108963 1728081249 7496037 6 6 4
[7] 6 8 1 1 1 0
[13] 0 4 4 4 3 3
[1] 6 6 4 6 8
[1] 1 1 1 0 0
[1] 4 4 4 3 3
cyl am gear
[1,] 6 1 4
[2,] 6 1 4
[3,] 4 1 4
[4,] 6 0 3
[5,] 8 0 3正如我们所看到的，我们通过读取 - [R中的二进制文件得到原始数据。
10.XML文件
XML是一种文件格式，它使用标准ASCII文本共享万维网，内部网和其他地方的文件格式和数据。它代表可扩展标记语言（XML）。类似于HTML它包含标记标签。但是与HTML中的标记标记描述页面的结构不同，在XML中，标记标记描述了包含在文件中的数据的含义。
您可以使用“XML”包读取R语言中的xml文件。此软件包可以使用以下命令安装。
install.packages("XML")输入数据
通过将以下数据复制到文本编辑器（如记事本）中来创建XMl文件。使用.xml扩展名保存文件，并将文件类型选择为所有文件（。）。
<RECORDS>
<EMPLOYEE>
<ID>1</ID>
<NAME>Rick</NAME>
<SALARY>623.3</SALARY>
<STARTDATE>1/1/2012</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>2</ID>
<NAME>Dan</NAME>
<SALARY>515.2</SALARY>
<STARTDATE>9/23/2013</STARTDATE>
<DEPT>Operations</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>3</ID>
<NAME>Michelle</NAME>
<SALARY>611</SALARY>
<STARTDATE>11/15/2014</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>4</ID>
<NAME>Ryan</NAME>
<SALARY>729</SALARY>
<STARTDATE>5/11/2014</STARTDATE>
<DEPT>HR</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>5</ID>
<NAME>Gary</NAME>
<SALARY>843.25</SALARY>
<STARTDATE>3/27/2015</STARTDATE>
<DEPT>Finance</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>6</ID>
<NAME>Nina</NAME>
<SALARY>578</SALARY>
<STARTDATE>5/21/2013</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>7</ID>
<NAME>Simon</NAME>
<SALARY>632.8</SALARY>
<STARTDATE>7/30/2013</STARTDATE>
<DEPT>Operations</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>8</ID>
<NAME>Guru</NAME>
<SALARY>722.5</SALARY>
<STARTDATE>6/17/2014</STARTDATE>
<DEPT>Finance</DEPT>
</EMPLOYEE>
</RECORDS>读取XML文件
xml文件由R语言使用函数xmlParse（）读取。它作为列表存储在R语言中。
# Load the package required to read XML files.
library("XML")
# Also load the other required package.
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Print the result.
print(result)当我们执行上面的代码，它产生以下结果 -
1
Rick
623.3
1/1/2012
IT
2
Dan
515.2
9/23/2013
Operations
3
Michelle
611
11/15/2014
IT
4
Ryan
729
5/11/2014
HR
5
Gary
843.25
3/27/2015
Finance
6
Nina
578
5/21/2013
IT
7
Simon
632.8
7/30/2013
Operations
8
Guru
722.5
6/17/2014
Finance获取XML文件中存在的节点数
# Load the packages required to read XML files.
library("XML")
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Exract the root node form the xml file.
rootnode <- xmlRoot(result)
# Find number of nodes in the root.
rootsize <- xmlSize(rootnode)
# Print the result.
print(rootsize)当我们执行上面的代码，它产生以下结果 -
output
[1] 8第一个节点的详细信息
让我们看看解析文件的第一条记录。它将给我们一个关于存在于顶层节点中的各种元素的想法。
# Load the packages required to read XML files.
library("XML")
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Exract the root node form the xml file.
rootnode <- xmlRoot(result)
# Print the result.
print(rootnode[1])当我们执行上面的代码，它产生以下结果 -
$EMPLOYEE
1
Rick
623.3
1/1/2012
IT
attr(,"class")
[1] "XMLInternalNodeList" "XMLNodeList" 获取节点的不同元素
# Load the packages required to read XML files.
library("XML")
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Exract the root node form the xml file.
rootnode <- xmlRoot(result)
# Get the first element of the first node.
print(rootnode[[1]][[1]])
# Get the fifth element of the first node.
print(rootnode[[1]][[5]])
# Get the second element of the third node.
print(rootnode[[3]][[2]])当我们执行上面的代码，它产生以下结果 -
1
IT
Michelle XML到数据帧
为了在大文件中有效地处理数据，我们将xml文件中的数据作为数据框读取。然后处理数据帧以进行数据分析。
# Load the packages required to read XML files.
library("XML")
library("methods")
# Convert the input xml file to a data frame.
xmldataframe <- xmlToDataFrame("input.xml")
print(xmldataframe)当我们执行上面的代码，它产生以下结果 -
ID NAME SALARY STARTDATE DEPT
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
6 6 Nina 578.00 2013-05-21 IT
7 7 Simon 632.80 2013-07-30 Operations
8 8 Guru 722.50 2014-06-17 Finance由于数据现在可以作为数据帧，我们可以使用数据帧相关函数来读取和操作文件。
11.JSON文件
JSON文件以人类可读格式将数据存储为文本.Json代表JavaScript Object Notation.R可以使用rjson包读取JSON文件。
安装rjson包
在ř语言控制台中，您可以发出以下命令来安装rjson包。
install.packages("rjson")输入数据
通过将以下数据复制到文本编辑器（如记事本）中来创建JSON文件。使用.json扩展名保存文件，并将文件类型选择为所有文件（。）。
{
"ID":["1","2","3","4","5","6","7","8" ],
"Name":["Rick","Dan","Michelle","Ryan","Gary","Nina","Simon","Guru" ],
"Salary":["623.3","515.2","611","729","843.25","578","632.8","722.5" ],
"StartDate":[ "1/1/2012","9/23/2013","11/15/2014","5/11/2014","3/27/2015","5/21/2013",
"7/30/2013","6/17/2014"],
"Dept":[ "IT","Operations","IT","HR","Finance","IT","Operations","Finance"]
}读取JSON文件
JSON文件由R使用来自JSON（）的函数读取。它作为列表存储在R中。
# Load the package required to read JSON files.
library("rjson")
# Give the input file name to the function.
result <- fromJSON(file = "input.json")
# Print the result.
print(result)
当我们执行上面的代码，它产生以下结果 -
$ID
[1] "1" "2" "3" "4" "5" "6" "7" "8"
$Name
[1] "Rick" "Dan" "Michelle" "Ryan" "Gary" "Nina" "Simon" "Guru"
$Salary
[1] "623.3" "515.2" "611" "729" "843.25" "578" "632.8" "722.5"
$StartDate
[1] "1/1/2012" "9/23/2013" "11/15/2014" "5/11/2014" "3/27/2015" "5/21/2013"
"7/30/2013" "6/17/2014"
$Dept
[1] "IT" "Operations" "IT" "HR" "Finance" "IT"
"Operations" "Finance"将JSON转换为数据帧
我们可以使用as.data.frame（）函数将上面提取的数据转换为ř语言数据帧以进行进一步分析。
# Load the package required to read JSON files.
library("rjson")
# Give the input file name to the function.
result <- fromJSON(file = "input.json")
# Convert JSON file to a data frame.
json_data_frame <- as.data.frame(result)
print(json_data_frame)当我们执行上面的代码，它产生以下结果 -
id, name, salary, start_date, dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
6 6 Nina 578.00 2013-05-21 IT
7 7 Simon 632.80 2013-07-30 Operations
8 8 Guru 722.50 2014-06-17 Finance13.Web数据
许多网站提供数据供其用户使用。例如，世界卫生组织（WHO）以CSV，txt和XML文件的形式提供健康和医疗信息的报告。使用R语言程序，我们可以从这些网站以编程方式提取特定数据R语言中用于从网站中提取数据的一些包是“RCurl”，XML“和”stringr“，它们用于连接到URL，识别文件所需的链接并将它们下载到本地环境。
安装 - [R语言的包
处理URL和链接到文件需要以下的包。如果它们在R语言环境中不可用，您可以使用以下命令安装它们。
install.packages("RCurl")
install.packages("XML")
install.packages("stringr")
install.packages("plyr")输入数据
我们将访问URL 天气数据，并使用[R在2015年下载CSV文件。
例
我们将使用函数getHTMLLinks（）来收集文件的URL。然后我们将使用函数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/")验证文件下载
运行上述代码后，您可以在当前ř语言工作目录中找到以下文件。
"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv"
"JCMB_2015_Mar.csv"14.数据库
Sql查询。但R语言可以轻松地连接到许多关系数据库，如MySql，Oracle，Sql服务器等，并数据是从它们获取记录作为数据框。一旦数据在R语言环境中可用，它就变成正常的R语言数据集，并且可以使用所有强大的包和函数来操作或分析。
在本教程中，我们将使用MySQL的作为连接到- [R语言的参考数据库。
RMySQL包
R语言有一个名为“RMySQL”的内置包，它提供与MySql数据库之间的本地连接。您可以使用以下命令在R语言环境中安装此软件包。
install.packages("RMySQL")将ř连接到MySQL的
一旦安装了包，我们在R中创建一个连接对象以连接到数据库。它使用用户名，密码，数据库名称和主机名作为输入。
# Create a connection Object to MySQL database.
# We will connect to the sampel database named "sakila" that comes with MySql installation.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
host = 'localhost')
# List the tables available in this database.
dbListTables(mysqlconnection)当我们执行上面的代码，它产生以下结果 -
[1] "actor" "actor_info"
[3] "address" "category"
[5] "city" "country"
[7] "customer" "customer_list"
[9] "film" "film_actor"
[11] "film_category" "film_list"
[13] "film_text" "inventory"
[15] "language" "nicer_but_slower_film_list"
[17] "payment" "rental"
[19] "sales_by_film_category" "sales_by_store"
[21] "staff" "staff_list"
[23] "store" 查询表
我们可以使用函数dbSendQuery（）查询MySql中的数据库表。查询在MySql中执行，并使用R语言fetch（）函数返回结果集。最后，它被存储为R语言中的数据帧。
# Query the "actor" tables to get all the rows.
result = dbSendQuery(mysqlconnection, "select * from actor")
# Store the result in a R data frame object. n = 5 is used to fetch first 5 rows.
data.frame = fetch(result, n = 5)
print(data.frame)当我们执行上面的代码，它产生以下结果 -
actor_id first_name last_name last_update
1 1 PENELOPE GUINESS 2006-02-15 04:34:33
2 2 NICK WAHLBERG 2006-02-15 04:34:33
3 3 ED CHASE 2006-02-15 04:34:33
4 4 JENNIFER DAVIS 2006-02-15 04:34:33
5 5 JOHNNY LOLLOBRIGIDA 2006-02-15 04:34:33带过滤条件的查询
我们可以传递任何有效的选择查询来获取结果。
result = dbSendQuery(mysqlconnection, "select * from actor where last_name = 'TORN'")
# Fetch all the records(with n = -1) and store it as a data frame.
data.frame = fetch(result, n = -1)
print(data)当我们执行上面的代码，它产生以下结果 -
actor_id first_name last_name last_update
1 18 DAN TORN 2006-02-15 04:34:33
2 94 KENNETH TORN 2006-02-15 04:34:33
3 102 WALTER TORN 2006-02-15 04:34:33更新表中的行
我们可以通过将更新查询传递给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的中创建表
我们可以在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中的表
我们可以删除MySql数据库中的表，将drop table语句传递到dbSendQuery（）中，就像我们使用它查询表中的数据一样。
dbSendQuery(mysqlconnection, 'drop table if exists mtcars')执行上面的代码后，我们可以看到表在MySQL的环境中被删除。
15.外部资源
以下资源包含有关R语言编程的其他信息。 请使用它们获得有关此主题的更深入的知识。
R语言编程的相关链接
R上的编程有用的书籍
R语言是一种用于统计分析和为此目的创建图形的编程语言。不是数据类型，它具有用于计算的数据对象。它用于数据挖掘，回归分析，概率估计等领域，使用其中可用的许多软件包。
R语言中的不同数据对象是什么？
它们是R语言中的6个数据对象。它们是向量，列表，数组，矩阵，数据框和表。
什么使R语言中的有效变量名？
有效的变量名称由字母，数字和点或下划线字符组成。变量名以字母或不以数字后跟的点开头。
数组和矩阵之间的主要区别是什么？
矩阵总是二维的，因为它只有行和列。但是阵列可以具有任何数量的维度，并且每个维度是矩阵。例如，3x3x2阵列表示维度为3x3的2个矩阵。
R语言中的哪个数据对象用于存储和处理分类数据？
R语言中的因子数据对象用于存储和处理R语言中的分类数据。
如何在R语言中加载和使用csv文件？
可以使用R语言ead.csv函数加载csv文件。 R语言在使用此函数读取csv文件时创建数据框。
如何获取R语言中当前工作目录的名称？
命令getwd()给出了R语言环境中的当前工作目录。
什么是R语言 Base包？
这是在R语言环境设置时默认加载的包。它提供了R语言环境中的基本功能，如输入/输出，算术计算等。
在逻辑回归中如何使用R语言？
逻辑回归处理测量二元响应变量的概率。在R语言中，函数glm()用于创建逻辑回归。
如何访问名为M的矩阵的第2列和第4行中的元素？
表达式M [4,2]给出了第4行和第2列的元素。
什么是向量中元素的回收？举个例子。
当在操作中涉及不同长度的两个向量时，较短向量的元素被重用以完成操作。这被称为元素循环。示例-v1 <-c（4,1,0,6）和V2 <-c（2,4），则v1 * v2给出（8,4,0,24）。重复元件2和4。
在R语言中调用函数有什么不同的方法？
我们可以用3种方式在R语言中调用一个函数。第一种方法是通过使用参数的位置来调用。第二个方法id通过使用参数的名称来调用，第三个方法是通过默认参数调用。
什么是R语言中的延迟函数评估？
函数的延迟评估意味着，只有当它在函数体内部使用时，才会评估参数。如果没有对函数体中的参数的引用，则它被简单地忽略。
如何在R语言中安装软件包？
要在R语言中安装一个包，我们使用下面的命令。
install.packages（"package Name"）命名用于读取XML文件的R语言包。
名为“XML”的包用于读取和处理XML文件。
我们可以更新和删除列表中的任何元素吗？
我们可以更新任何元素，但我们只能删除列表末尾的元素。
给一般表达式在R语言中创建一个矩阵。
在R语言中创建矩阵的一般表达式是 - matrix（data，nrow，ncol，byrow，dimnames）
该函数用于在R语言中创建boxplot图形？
boxplot()函数用于在R语言中创建箱线图。它使用公式和数据框作为输入创建箱线图。
在做时间序列分析时，在ts()函数中fR语言equency = 6是什么意思？
频率6表示时间序列数据的时间间隔是每10分钟一小时。
什么是R语言中的数据重塑？
在R语言中，数据对象可以从一种形式转换为另一种形式。例如，我们可以通过合并许多列表来创建数据框。这涉及一系列R语言命令，以将数据带入新格式。这被称为数据整形。
R语言unif（4）的输出是什么？
它生成0和1之间的4个随机数。
如何获得R语言中安装的所有软件包的列表？
使用命令
installed.packages()运行命令 - strsplit（x，“e”）是什么意思？
它将向量x中的字符串拆分为字母e位置处的子字符串。
给一个R脚本从字符串中提取大写的所有唯一字 - “快速的棕色狐狸跳过懒惰的狗”。
x <- “快速的棕色狐狸跳过懒惰的狗”
split.string <- strsplit(x，"")
extract.words <- split.string [[1]]
result <- unique(tolower(extract.words))
print(result)向量v是c（1,2,3,4），列表x是列表（5：8），v * x [1]的输出是什么？
v * x [1]中的错误：二进制运算符的非数值参数
向量v是c（1,2,3,4），列表x是列表（5：8），v * x [[1]]的输出是什么？
[1] 5 12 21 32sunlist()是什么？
它将列表转换为向量。
给予R语言表达式，从使用pbinom的硬币51个硬币中得到26个或更少的头。
x <- pbinom(26,51,0.5)
print(x)X是向量c(5,9.2,3,8.51，NA)，mean(x)的输出是什么？
NA
###如何将JSON文件中的数据转换为数据框？
使用函数as.data.frame()
###在R语言中给出一个函数，用向量的元素的和代替向量x的所有缺失值？
function(x){x [is.na(x)] apply()在R语言中的用途是什么？
它用于对数组中的每个元素应用相同的函数。例如，查找每行中行的平均值。
是数组称为矩阵还是矩阵称为数组？
每个矩阵可以称为数组，但不能相反。矩阵总是二维的，但数组可以是任何维度。
如何找到缺失值的帮助页面？
?NA
如何获得向量x的标准偏差？
sd(x,na.rm = TRUE)如何在R语言中设置当前工作目录的路径？
setwd("Path")“%%”和”%/%”之间有什么区别？
“%%”给出第一向量与第二向量的除法的余数，而”%/%”给出第一向量与第二向量的除法的商。
col.max(x)是什么？
查找该列具有每行的最大值。
###给出创建直方图的命令。
hist()如何从R语言工作区中删除向量？
rm(x)列出包”MASS”中可用的数据集
data(package ="MASS")###列出所有可用软件包中可用的数据集。
data(package = .packages(all.available = TRUE))什么是命令的使用 - install.packages(file.choose(),repos = NULL)？
它用于通过浏览和选择文件从本地目录安装R语言包。
给出命令以检查元素15是否存在于向量x中。
15%在%x给出创建散点图矩阵的语法。
pairs(formula, data)其中公式表示成对使用的变量系列，数据表示从中获取变量的数据集。
R语言中的subset()函数和sample()函数有什么区别？
subset()函数用于选择变量和观察值。 sample()函数用于从数据集中选择大小为n的随机样本。
如何检查”m”是R语言中的矩阵数据对象？
is.matrix(m)应该重新运行TRUE。
下面的表达式all(NA == NA)的输出是什么？
[1] NA
如何获得矩阵在R语言中的转置？
函数t()用于转置矩阵。示例-t(m)，其中m是矩阵。
在R语言中使用”next”语句是什么？
当我们想要跳过循环的当前迭代而不终止它时，R编程语言中的”next”语句是有用的。
统计篇
1.平均值，中位数和模式
R中的统计分析通过使用许多内置函数来执行。 这些函数大多数是R基础包的一部分。 这些函数将R向量作为输入和参数，并给出结果。
我们在本章中讨论的功能是平均值，中位数和模式。
Mean平均值
通过求出数据集的和再除以求和数的总量得到平均值
函数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。
要从计算中删除缺少的值，请使用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.22Median中位数
数据系列中的最中间值称为中值。 在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.6Mode模式
模式是一组数据中出现次数最多的值。 Unike平均值和中位数，模式可以同时包含数字和字符数据。
R语言没有标准的内置函数来计算模式。 因此，我们创建一个用户函数来计算R语言中的数据集的模式。该函数将向量作为输入，并将模式值作为输出。
例
# Create the function.
getmode <- function(v) {
uniqv <- unique(v)
uniqv[which.max(tabulate(match(v, uniqv)))]
}
# Create the vector with numbers.
v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)
# Calculate the mode using the user function.
result <- getmode(v)
print(result)
# Create the vector with characters.
charv <- c("o","it","the","it","it")
# Calculate the mode using the user function.
result <- getmode(charv)
print(result)当我们执行上面的代码，它产生以下结果 -
[1] 2
[1] "it"2.线性回归
回归分析是一种非常广泛使用的统计工具，用于建立两个变量之间的关系模型。 这些变量之一称为预测变量，其值通过实验收集。 另一个变量称为响应变量，其值从预测变量派生。
在线性回归中，这两个变量通过方程相关，其中这两个变量的指数（幂）为1.数学上，线性关系表示当绘制为曲线图时的直线。 任何变量的指数不等于1的非线性关系将创建一条曲线。
线性回归的一般数学方程为 -
y = ax + b以下是所使用的参数的描述 -
y是响应变量。
x是预测变量。
a和b被称为系数常数。
建立回归的步骤
回归的简单例子是当人的身高已知时预测人的体重。 为了做到这一点，我们需要有一个人的身高和体重之间的关系。
创建关系的步骤是 -
进行收集高度和相应重量的观测值的样本的实验。
使用R语言中的lm()函数创建关系模型。
从创建的模型中找到系数，并使用这些创建数学方程
获得关系模型的摘要以了解预测中的平均误差。 也称为残差。
为了预测新人的体重，使用R中的predict()函数。
输入数据
下面是代表观察的样本数据 -
# Values of height
151, 174, 138, 186, 128, 136, 179, 163, 152, 131
# Values of weight.
63, 81, 56, 91, 47, 57, 76, 72, 62, 48LM()函数
此函数创建预测变量和响应变量之间的关系模型。
语法
线性回归中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 ‘ ’ 1
Residual standard error: 3.253 on 8 degrees of freedom
Multiple R-squared: 0.9548, Adjusted R-squared: 0.9491
F-statistic: 168.9 on 1 and 8 DF, p-value: 1.164e-06predict()函数
语法
线性回归中的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()当我们执行上面的代码，它产生以下结果 -
3.多重回归
多元回归是线性回归到两个以上变量之间的关系的延伸。 在简单线性关系中，我们有一个预测变量和一个响应变量，但在多元回归中，我们有多个预测变量和一个响应变量。
多元回归的一般数学方程为 -
y = a + b1x1 + b2x2 +...bnxn以下是所使用的参数的描述 -
y是响应变量。
a，b1，b2 … bn是系数。
x1，x2，… xn是预测变量。
我们使用R语言中的lm()函数创建回归模型。模型使用输入数据确定系数的值。 接下来，我们可以使用这些系数来预测给定的一组预测变量的响应变量的值。
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 wt
Mazda RX4 21.0 160 110 2.620
Mazda RX4 Wag 21.0 160 110 2.875
Datsun 710 22.8 108 93 2.320
Hornet 4 Drive 21.4 258 110 3.215
Hornet Sportabout 18.7 360 175 3.440
Valiant 18.1 225 105 3.460创建关系模型并获取系数
input <- mtcars[,c("mpg","disp","hp","wt")]
# Create the relationship model.
model <- lm(mpg~disp+hp+wt, data = input)
# Show the model.
print(model)
# Get the Intercept and coefficients as vector elements.
cat("# # # # The Coefficient Values # # # ","
")
a <- coef(model)[1]
print(a)
Xdisp <- coef(model)[2]
Xhp <- coef(model)[3]
Xwt <- coef(model)[4]
print(Xdisp)
print(Xhp)
print(Xwt)当我们执行上面的代码，它产生以下结果 -
Call:
lm(formula = mpg ~ disp + hp + wt, data = input)
Coefficients:
(Intercept) disp hp wt
37.105505 -0.000937 -0.031157 -3.800891
# # # # The Coefficient Values # # #
(Intercept)
37.10551
disp
-0.0009370091
hp
-0.03115655
wt
-3.800891 创建回归模型的方程
基于上述截距和系数值，我们创建了数学方程。
Y = a+Xdisp.x1+Xhp.x2+Xwt.x3
or
Y = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3应用方程预测新值
当提供一组新的位移，马力和重量值时，我们可以使用上面创建的回归方程来预测里程数。
对于disp = 221，hp = 102和wt = 2.91的汽车，预测里程为 -
Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.71044.逻辑回归
逻辑回归是回归模型，其中响应变量（因变量）具有诸如True / False或0/1的分类值。它实际上基于将其与预测变量相关的数学方程测量二元响应的概率作为响应变量的值。
逻辑回归的一般数学方程为 -
y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))以下是所使用的参数的描述 -
Ÿ是响应变量。
X是预测变量。
一和b是作为数字常数的系数。
用于创建回归模型的函数是GLM（）函数。
###语法
逻辑回归中glm（）函数的基本语法是 -
glm(formula,data,family)以下是所使用的参数的描述 -
式是表示变量之间的关系的符号。
数据是给出这些变量的值的数据集。
family是R语言对象来指定模型的细节。它的值是二项逻辑回归。
例
内置数据集“mtcars”描述具有各种发动机规格的汽车的不同型号。在“mtcars”数据集中，传输模式（自动或手动）由am列描述，它是一个二进制值（0或1）。我们可以在列“是”和其他3列（马力，重量和CYL）之间创建逻辑回归模型。
# Select some columns form mtcars.
input <- mtcars[,c("am","cyl","hp","wt")]
print(head(input))当我们执行上面的代码，它产生以下结果 -
am cyl hp wt
Mazda RX4 1 6 110 2.620
Mazda RX4 Wag 1 6 110 2.875
Datsun 710 1 4 93 2.320
Hornet 4 Drive 0 6 110 3.215
Hornet Sportabout 0 8 175 3.440
Valiant 0 6 105 3.460创建回归模型
我们使用GLM（）函数创建回归模型，并得到其摘要进行分析。
input <- mtcars[,c("am","cyl","hp","wt")]
am.data = glm(formula = am ~ cyl + hp + wt, data = input, family = binomial)
print(summary(am.data))当我们执行上面的代码，它产生以下结果 -
Call:
glm(formula = am ~ cyl + hp + wt, family = binomial, data = input)
Deviance Residuals:
Min 1Q Median 3Q Max
-2.17272 -0.14907 -0.01464 0.14116 1.27641
Coefficients:
Estimate Std. Error z value Pr(>|z|)
(Intercept) 19.70288 8.11637 2.428 0.0152 *
cyl 0.48760 1.07162 0.455 0.6491
hp 0.03259 0.01886 1.728 0.0840 .
wt -9.14947 4.15332 -2.203 0.0276 *
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
(Dispersion parameter for binomial family taken to be 1)
Null deviance: 43.2297 on 31 degrees of freedom
Residual deviance: 9.8415 on 28 degrees of freedom
AIC: 17.841
Number of Fisher Scoring iterations: 8结论
在总结中，对于变量“cyl”和“hp”，最后一列中的p值大于0.05，我们认为它们对变量“am”的值有贡献是无关紧要的。只有重量（wt）影响该回归模型中的“是”值。
5.标准分布
在来自独立源的数据的随机集合中，通常观察到数据的分布是正常的。这意味着，在绘制水平轴上的变量值和垂直轴上的值的计数的图形时，我们得到钟形曲线。曲线的中心表示数据集的平均值。在图中，50％的值位于平均值的左侧，另外50％位于图表的右侧。这在统计学中被称为正态分布。
R语言有四个内置函数来产生正态分布。它们描述如下。
dnorm(x, mean, sd)
pnorm(x, mean, sd)
qnorm(p, mean, sd)
rnorm(n, mean, sd)以下是在上述功能中使用的参数的描述 -
X是数字的向量。
p是概率的向量。
Ñ是观察的数量（样本大小）。
mean是样本数据的平均值。它的默认值为零。
sd是标准偏差。它的默认值为1。
dnorm（）
该函数给出给定平均值和标准偏差在每个点的概率分布的高度。
# Create a sequence of numbers between -10 and 10 incrementing by 0.1.
x <- seq(-10, 10, by = .1)
# Choose the mean as 2.5 and standard deviation as 0.5.
y <- dnorm(x, mean = 2.5, sd = 0.5)
# Give the chart file a name.
png(file = "dnorm.png")
plot(x,y)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
pnorm（）
该函数给出正态分布随机数的概率小于给定数的值。它也被称为“累积分布函数”。
# Create a sequence of numbers between -10 and 10 incrementing by 0.2.
x <- seq(-10,10,by = .2)
# Choose the mean as 2.5 and standard deviation as 2\.
y <- pnorm(x, mean = 2.5, sd = 2)
# Give the chart file a name.
png(file = "pnorm.png")
# Plot the graph.
plot(x,y)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
qnorm（）
该函数采用概率值，并给出累积值与概率值匹配的数字。
# Create a sequence of probability values incrementing by 0.02.
x <- seq(0, 1, by = 0.02)
# Choose the mean as 2 and standard deviation as 3.
y <- qnorm(x, mean = 2, sd = 1)
# Give the chart file a name.
png(file = "qnorm.png")
# Plot the graph.
plot(x,y)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
RNORM（）
此函数用于生成分布正常的随机数。它将样本大小作为输入，并生成许多随机数。我们绘制一个直方图来显示生成的数字的分布。
# Create a sample of 50 numbers which are normally distributed.
y <- rnorm(50)
# Give the chart file a name.
png(file = "rnorm.png")
# Plot the histogram for this sample.
hist(y, main = "Normal DIstribution")
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
6.二项分布
二项分布模型处理在一系列实验中仅发现两个可能结果的事件的成功概率。 例如，掷硬币总是给出头或尾。 在二项分布期间估计在10次重复抛掷硬币中精确找到3个头的概率。
R语言有四个内置函数来生成二项分布。 它们描述如下。
dbinom(x, size, prob)
pbinom(x, size, prob)
qbinom(p, size, prob)
rbinom(n, size, prob)以下是所使用的参数的描述 -
x是数字的向量。
p是概率向量。
n是观察的数量。
size是试验的数量。
prob是每个试验成功的概率。
dbinom（）
该函数给出每个点的概率密度分布。
# Create a sample of 50 numbers which are incremented by 1.
x <- seq(0,50,by = 1)
# Create the binomial distribution.
y <- dbinom(x,50,0.5)
# Give the chart file a name.
png(file = "dbinom.png")
# Plot the graph for this sample.
plot(x,y)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
pbinom（）
此函数给出事件的累积概率。 它是表示概率的单个值。
# Probability of getting 26 or less heads from a 51 tosses of a coin.
x <- pbinom(26,51,0.5)
print(x)当我们执行上面的代码，它产生以下结果 -
[1] 0.610116qbinom（）
该函数采用概率值，并给出累积值与概率值匹配的数字。
# 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] 23rbinom（）
该函数从给定样本产生给定概率的所需数量的随机值。
# 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 677.泊松回归
泊松回归包括回归模型，其中响应变量是计数而不是分数的形式。 例如，足球比赛系列中的出生次数或胜利次数。 此外，响应变量的值遵循泊松分布。
泊松回归的一般数学方程为 -
log(y) = a + b1x1 + b2x2 + bnxn.....以下是所使用的参数的描述 -
y是响应变量。
a和b是数字系数。
x是预测变量。
###用于创建泊松回归模型的函数是glm()函数。
语法
在泊松回归中glm()函数的基本语法是 -
glm(formula,data,family)以下是在上述功能中使用的参数的描述 -
formula是表示变量之间的关系的符号。
data是给出这些变量的值的数据集。
family是R语言对象来指定模型的细节。 它的值是“泊松”的逻辑回归。
例
我们有内置的数据集“warpbreaks”，其描述了羊毛类型（A或B）和张力（低，中或高）对每个织机的经纱断裂数量的影响。 让我们考虑“休息”作为响应变量，它是休息次数的计数。 羊毛“类型”和“张力”作为预测变量。
输入数据
input <- warpbreaks
print(head(input))当我们执行上面的代码，它产生以下结果 -
breaks wool tension
1 26 A L
2 30 A L
3 54 A L
4 25 A L
5 70 A L
6 52 A L创建回归模型
output <-glm(formula = breaks ~ wool+tension,
data = warpbreaks,
family = poisson)
print(summary(output))当我们执行上面的代码，它产生以下结果 -
Call:
glm(formula = breaks ~ wool + tension, family = poisson, data = warpbreaks)
Deviance Residuals:
Min 1Q Median 3Q Max
-3.6871 -1.6503 -0.4269 1.1902 4.2616
Coefficients:
Estimate Std. Error z value Pr(>|z|)
(Intercept) 3.69196 0.04541 81.302 < 2e-16 ***
woolB -0.20599 0.05157 -3.994 6.49e-05 ***
tensionM -0.32132 0.06027 -5.332 9.73e-08 ***
tensionH -0.51849 0.06396 -8.107 5.21e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
(Dispersion parameter for poisson family taken to be 1)
Null deviance: 297.37 on 53 degrees of freedom
Residual deviance: 210.39 on 50 degrees of freedom
AIC: 493.06
Number of Fisher Scoring iterations: 4在摘要中，我们查找最后一列中的p值小于0.05，以考虑预测变量对响应变量的影响。 如图所示，具有张力类型M和H的羊毛类型B对断裂计数有影响。
8.协方差分析
我们使用回归分析创建模型，描述变量在预测变量对响应变量的影响。 有时，如果我们有一个类别变量，如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 hp
Mazda RX4 1 21.0 110
Mazda RX4 Wag 1 21.0 110
Datsun 710 1 22.8 93
Hornet 4 Drive 0 21.4 110
Hornet Sportabout 0 18.7 175
Valiant 0 18.1 105协方差分析
我们创建一个回归模型，以“hp”作为预测变量，“mpg”作为响应变量，考虑“am”和“hp”之间的相互作用。
模型与分类变量和预测变量之间的相互作用
# Get the dataset.
input <- mtcars
# Create the regression model.
result <- aov(mpg~hp*am,data = input)
print(summary(result))当我们执行上面的代码，它产生以下结果 -
Df Sum Sq Mean Sq F value Pr(>F)
hp 1 678.4 678.4 77.391 1.50e-09 ***
am 1 202.2 202.2 23.072 4.75e-05 ***
hp:am 1 0.0 0.0 0.001 0.981
Residuals 28 245.4 8.8
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1这个结果表明，马力和传输类型对每加仑的英里有显着的影响，因为两种情况下的p值都小于0.05。 但是这两个变量之间的相互作用不显着，因为p值大于0.05。
没有分类变量和预测变量之间相互作用的模型
# Get the dataset.
input <- mtcars
# Create the regression model.
result <- aov(mpg~hp+am,data = input)
print(summary(result))当我们执行上面的代码，它产生以下结果 -
Df Sum Sq Mean Sq F value Pr(>F)
hp 1 678.4 678.4 80.15 7.63e-10 ***
am 1 202.2 202.2 23.89 3.46e-05 ***
Residuals 29 245.4 8.5
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1这个结果表明，马力和传输类型对每加仑的英里有显着的影响，因为两种情况下的p值都小于0.05。
比较两个模型
现在我们可以比较两个模型来得出结论，变量的相互作用是否真正重要。 为此，我们使用anova()函数。
# Get the dataset.
input <- mtcars
# Create the regression models.
result1 <- aov(mpg~hp*am,data = input)
result2 <- aov(mpg~hp+am,data = input)
# Compare the two models.
print(anova(result1,result2))当我们执行上面的代码，它产生以下结果 -
Model 1: mpg ~ hp * am
Model 2: mpg ~ hp + am
Res.Df RSS Df Sum of Sq F Pr(>F)
1 28 245.43
2 29 245.44 -1 -0.0052515 6e-04 0.9806由于p值大于0.05，我们得出结论，马力和传播类型之间的相互作用不显着。 因此，在汽车和手动变速器模式下，每加仑的里程将以类似的方式取决于汽车的马力。
9.时间序列分析
时间序列是一系列数据点，其中每个数据点与时间戳相关联。 一个简单的例子是股票在某一天的不同时间点的股票价格。 另一个例子是一个地区在一年中不同月份的降雨量。 R语言使用许多函数来创建，操作和绘制时间序列数据。 时间序列的数据存储在称为时间序列对象的R对象中。 它也是一个R语言数据对象，如矢量或数据帧。
使用ts()函数创建时间序列对象。
语法
时间序列分析中ts()函数的基本语法是 -
timeseries.object.name <- ts(data, start, end, frequency)以下是所使用的参数的描述 -
data是包含在时间序列中使用的值的向量或矩阵。
start以时间序列指定第一次观察的开始时间。
end指定时间序列中最后一次观测的结束时间。
frequency指定每单位时间的观测数。
除了参数“data”，所有其他参数是可选的。
例
考虑从2012年1月开始的一个地方的年降雨量细节。我们创建一个R时间序列对象为期12个月并绘制它。
# Get the data points in form of a R vector.
rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)
# Convert it to a time series object.
rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)
# Print the timeseries data.
print(rainfall.timeseries)
# Give the chart file a name.
png(file = "rainfall.png")
# Plot a graph of the time series.
plot(rainfall.timeseries)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果及图表 -
Jan Feb Mar Apr May Jun Jul Aug Sep
2012 799.0 1174.8 865.1 1334.6 635.4 918.5 685.5 998.6 784.2
Oct Nov Dec
2012 985.0 882.8 1071.0时间序列图 -
不同的时间间隔
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 2
Jan 2012 799.0 655.0
Feb 2012 1174.8 1306.9
Mar 2012 865.1 1323.4
Apr 2012 1334.6 1172.2
May 2012 635.4 562.2
Jun 2012 918.5 824.0
Jul 2012 685.5 822.4
Aug 2012 998.6 1265.5
Sep 2012 784.2 799.6
Oct 2012 985.0 1105.6
Nov 2012 882.8 1106.7
Dec 2012 1071.0 1337.8多时间序列图 -
10.非线性最小二乘
当模拟真实世界数据用于回归分析时，我们观察到，很少情况下，模型的方程是给出线性图的线性方程。大多数时候，真实世界数据模型的方程涉及更高程度的数学函数，如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.081935
Waiting for profiling to be done...
2.5% 97.5%
b1 1.137708 1.253135
b2 1.497364 2.496484
我们可以得出结论，b1的值更接近1，而b2的值更接近2而不是3。
11.决策树
决策树是以树的形式表示选择及其结果的图。图中的节点表示事件或选择，并且图的边缘表示决策规则或条件。它主要用于使用R的机器学习和数据挖掘应用程序。
决策树的使用的例子是 - 预测电子邮件是垃圾邮件或非垃圾邮件，预测肿瘤癌变，或者基于这些因素预测贷款的信用风险。通常，使用观测数据（也称为训练数据）来创建模型。然后使用一组验证数据来验证和改进模型。 R具有用于创建和可视化决策树的包。对于新的预测变量集合，我们使用此模型来确定R包“party”用于创建决策树。
安装R语言包
在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 score
1 yes 5 24.83189 32.29385
2 yes 6 25.95238 36.63105
3 no 11 30.42170 49.60593
4 yes 7 28.66450 40.28456
5 yes 11 31.88207 55.46085
6 yes 10 30.07843 52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................例
我们将使用ctree()函数创建决策树并查看其图形。
# Load the party package. It will automatically load other dependent packages.
library(party)
# Create the input data frame.
input.dat <- readingSkills[c(1:105),]
# Give the chart file a name.
png(file = "decision_tree.png")
# Create the tree.
output.tree <- ctree(
nativeSpeaker ~ age + shoeSize + score,
data = input.dat)
# Plot the tree.
plot(output.tree)
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果 -
null device
1
Loading required package: methods
Loading required package: grid
Loading required package: mvtnorm
Loading required package: modeltools
Loading required package: stats4
Loading required package: strucchange
Loading required package: zoo
Attaching package: ‘zoo’
The following objects are masked from ‘package:base’:
as.Date, as.Date.numeric
Loading required package: sandwich
结论
从上面显示的决策树，我们可以得出结论，其readingSkills分数低于38.3和年龄超过6的人不是一个母语者。
12.随机森林算法
在随机森林方法中，创建大量的决策树。每个观察被馈入每个决策树。每个观察的最常见的结果被用作最终输出。新的观察结果被馈入所有的树并且对 - 个分类模型取多数投票。
对构建树时未使用的情况进行错误估计。这称为OOB（袋外）误差估计，其被提及为百分比。
[R语言包“随机森林”用于创建随机森林。
安装 - [R包
在R语言控制台中使用以下命令安装软件包。您还必须安装相关软件包（如果有）。
install.packages("randomForest)包“随机森林”具有函数随机森林（），用于创建和分析随机森林。
语法
在R语言中创建随机森林的基本语法是 -
randomForest(formula, data)以下是所使用的参数的描述 -
式是描述预测变量和响应变量的公式。
数据是所使用的数据集的名称。
输入数据
我们将使用名为readingSkills的R语言内置数据集来创建决策树。它描述了某人的阅读技能的分数，如果我们知道变量“age”，“shoesize”，“score”，以及该人是否是母语。
以下是示例数据。
# Load the party package. It will automatically load other required packages.
library(party)
# Print some records from data set readingSkills.
print(head(readingSkills))当我们执行上面的代码，它产生以下结果及图表 -
nativeSpeaker age shoeSize score
1 yes 5 24.83189 32.29385
2 yes 6 25.95238 36.63105
3 no 11 30.42170 49.60593
4 yes 7 28.66450 40.28456
5 yes 11 31.88207 55.46085
6 yes 10 30.07843 52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................例
我们将使用随机森林（）函数来创建决策树并查看它的图。
# Load the party package. It will automatically load other required packages.
library(party)
library(randomForest)
# Create the forest.
output.forest <- randomForest(nativeSpeaker ~ age + shoeSize + score,
data = readingSkills)
# View the forest results.
print(output.forest)
# Importance of each predictor.
print(importance(fit,type = 2)) 当我们执行上面的代码，它产生以下结果 -
Call:
randomForest(formula = nativeSpeaker ~ age + shoeSize + score,
data = readingSkills)
Type of random forest: classification
Number of trees: 500
No. of variables tried at each split: 1
OOB estimate of error rate: 1%
Confusion matrix:
no yes class.error
no 99 1 0.01
yes 1 99 0.01
MeanDecreaseGini
age 13.95406
shoeSize 18.91006
score 56.73051结论
从上面显示的随机森林，我们可以得出结论，鞋码和成绩是决定如果某人是母语者或不是母语的重要因素。此外，该模型只有1％的误差，这意味着我们可以预测精度为99％。
13.生存分析
生存分析处理预测特定事件将要发生的时间。 它也被称为故障时间分析或分析死亡时间。 例如，预测患有癌症的人将存活的天数或预测机械系统将失败的时间。
命名为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 chol
1 1 400 2 1 58.76523 f 1 1 1 1.0 14.5 261
2 2 4500 0 1 56.44627 f 0 1 1 0.0 1.1 302
3 3 1012 2 1 70.07255 m 0 0 0 0.5 1.4 176
4 4 1925 2 1 54.74059 f 0 1 1 0.5 1.8 244
5 5 1504 1 2 38.10541 f 0 1 1 0.0 3.4 279
6 6 2503 2 2 66.25873 f 0 1 0 0.0 0.8 248
albumin copper alk.phos ast trig platelet protime stage
1 2.60 156 1718.0 137.95 172 190 12.2 4
2 4.14 54 7394.8 113.52 88 221 10.6 3
3 3.48 210 516.0 96.10 55 151 12.0 4
4 2.54 64 6121.8 60.63 92 183 10.3 4
5 3.53 143 671.0 113.15 72 136 10.9 3
6 3.98 50 944.0 93.00 63 NA 11.0 3从上述数据，我们正在考虑分析的时间和状态。
应用Surv（）和survfit（）函数
现在我们继续应用Surv()函数到上面的数据集，并创建一个将显示趋势图。
# Load the library.
library("survival")
# Create the survival object.
survfit(Surv(pbc$time,pbc$status == 2)~1)
# Give the chart file a name.
png(file = "survival.png")
# Plot the graph.
plot(survfit(Surv(pbc$time,pbc$status == 2)~1))
# Save the file.
dev.off()当我们执行上面的代码，它产生以下结果及图表 -
Call: survfit(formula = Surv(pbc$time, pbc$status == 2) ~ 1)
n events median 0.95LCL 0.95UCL
418 161 3395 3090 3853
上图中的趋势有助于我们预测在特定天数结束时的生存概率。
14.卡方检验
卡方检验是一种确定两个分类变量之间是否存在显着相关性的统计方法。这两个变量应该来自相同的人口，他们应该是类似 - 是/否，男/女，红/绿等。
例如，我们可以建立一个观察人们的冰淇淋购买模式的数据集，并尝试将一个人的性别与他们喜欢的冰淇淋的味道相关联。如果发现相关性，我们可以通过了解访问的人的性别的数量来计划适当的味道库存。
语法
用于执行卡方检验的函数是chisq.test（）。
在R语言中创建卡方检验的基本语法是 -
chisq.test(data)以下是所使用的参数的描述 -
- 数据是以包含观察中变量的计数值的表的形式的数据。
例
我们将在“大众”图书馆中获取Cars93数据，该图书馆代表1993年年不同型号汽车的销售额。
library("MASS")
print(str(Cars93))当我们执行上面的代码，它产生以下结果 -
'data.frame': 93 obs. of 27 variables:
$ Manufacturer : Factor w/ 32 levels "Acura","Audi",..: 1 1 2 2 3 4 4 4 4 5 ...
$ Model : Factor w/ 93 levels "100","190E","240",..: 49 56 9 1 6 24 54 74 73 35 ...
$ Type : Factor w/ 6 levels "Compact","Large",..: 4 3 1 3 3 3 2 2 3 2 ...
$ Min.Price : num 12.9 29.2 25.9 30.8 23.7 14.2 19.9 22.6 26.3 33 ...
$ Price : num 15.9 33.9 29.1 37.7 30 15.7 20.8 23.7 26.3 34.7 ...
$ Max.Price : num 18.8 38.7 32.3 44.6 36.2 17.3 21.7 24.9 26.3 36.3 ...
$ MPG.city : int 25 18 20 19 22 22 19 16 19 16 ...
$ MPG.highway : int 31 25 26 26 30 31 28 25 27 25 ...
$ AirBags : Factor w/ 3 levels "Driver & Passenger",..: 3 1 2 1 2 2 2 2 2 2 ...
$ DriveTrain : Factor w/ 3 levels "4WD","Front",..: 2 2 2 2 3 2 2 3 2 2 ...
$ Cylinders : Factor w/ 6 levels "3","4","5","6",..: 2 4 4 4 2 2 4 4 4 5 ...
$ EngineSize : num 1.8 3.2 2.8 2.8 3.5 2.2 3.8 5.7 3.8 4.9 ...
$ Horsepower : int 140 200 172 172 208 110 170 180 170 200 ...
$ RPM : int 6300 5500 5500 5500 5700 5200 4800 4000 4800 4100 ...
$ Rev.per.mile : int 2890 2335 2280 2535 2545 2565 1570 1320 1690 1510 ...
$ Man.trans.avail : Factor w/ 2 levels "No","Yes": 2 2 2 2 2 1 1 1 1 1 ...
$ Fuel.tank.capacity: num 13.2 18 16.9 21.1 21.1 16.4 18 23 18.8 18 ...
$ Passengers : int 5 5 5 6 4 6 6 6 5 6 ...
$ Length : int 177 195 180 193 186 189 200 216 198 206 ...
$ Wheelbase : int 102 115 102 106 109 105 111 116 108 114 ...
$ Width : int 68 71 67 70 69 69 74 78 73 73 ...
$ Turn.circle : int 37 38 37 37 39 41 42 45 41 43 ...
$ Rear.seat.room : num 26.5 30 28 31 27 28 30.5 30.5 26.5 35 ...
$ Luggage.room : int 11 15 14 17 13 16 17 21 14 18 ...
$ Weight : int 2705 3560 3375 3405 3640 2880 3470 4105 3495 3620 ...
$ Origin : Factor w/ 2 levels "USA","non-USA": 2 2 2 2 2 1 1 1 1 1 ...
$ Make : Factor w/ 93 levels "Acura Integra",..: 1 2 4 3 5 6 7 9 8 10 ... 上述结果表明数据集有很多因素变量，可以被认为是分类变量。对于我们的模型，我们将考虑变量“AirBags”和“Type”。在这里，我们的目标是找出所售的汽车类型和安全如果观察到相关性，我们可以估计哪种类型的汽车可以更好地卖什么类型的气囊。
# Load the library.
library("MASS")
# Create a data frame from the main data set.
car.data <- data.frame(Cars93$AirBags, Cars93$Type)
# Create a table with the needed variables.
car.data = table(Cars93$AirBags, Cars93$Type)
print(car.data)
# Perform the Chi-Square test.
print(chisq.test(car.data))
当我们执行上面的代码，它产生以下结果 -
Compact Large Midsize Small Sporty Van
Driver & Passenger 2 4 7 0 3 0
Driver only 9 7 11 5 8 3
None 5 0 4 16 3 6
Pearson's Chi-squared test
data: car.data
X-squared = 33.001, df = 10, p-value = 0.0002723
Warning message:
In chisq.test(car.data) : Chi-squared approximation may be incorrect结论
结果显示p值小于0.05，这表明字符串相关。