概述

R 的简介

  • R 语言是用于统计分析，图形表示和报告的编程语言和软件环境。R 语言由 Ross Ihaka 和 Robert Gentleman 在新西兰奥克兰大学创建，目前由 R 语言开发核心团队开发。
  • R 语言的核心是解释计算机语言，其允许分支和循环以及使用函数的模块化编程。R 语言允许与以 C，C ++，.Net，Python 或 FORTRAN 语言编写的过程集成以提高效率。
  • R 语言在 GNU 通用公共许可证下免费提供，并为各种操作系统（如 Linux，Windows 和 Mac）提供预编译的二进制版本。
  • R 是一个在 GNU 风格的副本左侧的自由软件，GNU 项目的官方部分叫做 GNU S.

R 的演变

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

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

R 的特点

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

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

R 语言是世界上最广泛使用的统计编程语言。它是数据科学家的第一选择，并由一个充满活力和有才华的贡献者社区支持。

基本语法

根据需要，您可以在 R 语言命令提示符处编程，也可以使用 R 语言脚本文件编写程序。

命令提示符

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

1
$ R

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

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

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

脚本文件

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

1
2
3
# My first program in R Programming
myString <- "Hello, World!"
print(myString)

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

1
$ Rscript test.R

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

1
[1] "Hello, World!"

注释

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

1
# My first program in R Programming

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

1
2
3
4
5
6
7
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, FALSEv <- TRUE
print(class(v))
[1] "logical"
Numeric（数字）12.3，5，999v <- 23.5
print(class(v))
[1] "numeric"
Integer（整型）2L，34L，0Lv <- 2L
print(class(v))
[1] "integer"
Complex（复合型）3 + 2iv <- 2+5i
print(class(v))
[1] "complex"
Character（字符）'a' , "good", "TRUE", '23.4'v <- "TRUE"
print(class(v))
[1] "character"
Raw（原型）"Hello" 被存储为 48 65 6c 6c 6fv <- charToRaw("Hello")
print(class(v))
[1] "raw"

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

Vectors 向量

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

1
2
3
4
5
6
7
8
9
10
11
# Create a vector.
apple <- c("red", "green", "yellow")
print(apple)

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

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

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

更多方法实例请点击查看 R 语言向量章节。

Lists 列表

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 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")

更多方法实例请点击查看 R 语言列表章节。

Matrices 矩阵

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

1
2
3
4
5
6
7
8
9
# 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"

更多方法实例请点击查看 R 语言矩阵章节。

Arrays 数组

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Create an array.
a <- array(c('green', 'yellow'), dim = c(3, 3, 2))
print(a)

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

, , 1

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

, , 2

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

更多方法实例请点击查看 R 语言数组章节。

Factors 因子

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Create a vector.
apple_colors <- c('green', 'green', 'yellow', 'red', 'red', 'red', 'green')

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

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

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

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

更多方法实例请点击查看 R 语言因子章节。

Data Frames 数据框

数据框是表格数据对象。与数据框中的矩阵不同，每列可以包含不同的数据模式。第一列可以是数字，而第二列可以是字符，第三列可以是逻辑的。它是等长度的向量的列表。 使用 data.frame() 函数创建数据框。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Create the data frame.
BMI <-  | data.frame(
   gender = c("Male", "Male", "Female"),
   height = c(152, 171.5, 165),
   weight = c(81, 93, 78),
   Age = c(42, 38, 26)
)
print(BMI)

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

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

更多方法实例请点击查看 R 语言数据框章节。

变量

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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() 函数也可以使用模式来匹配变量名。

1
2
3
4
5
6
7
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() 函数可以使用模式来匹配变量名。

1
2
3
4
5
6
7
8
# 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 参数列出。

1
2
3
4
5
6
7
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。打印时，抛出变量错误的值。

1
2
3
4
5
6
7
rm(var.3)
print(var.3)
 
# 当我们执行上面的代码，它产生以下结果：

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

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

1
2
3
4
5
6
rm(list = ls())
print(ls())

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

character(0)

运算符

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

运算符的类型

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

算术运算符

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

运算符描述实例
+两个向量相加v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v+t)
它产生以下结果：
[1] 10.0 8.5 10.0
-两个向量相减v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v-t)
它产生以下结果：
[1] -6.0 2.5 2.0
*两个向量相乘v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v*t)
它产生以下结果：
[1] 16.0 16.5 24.0
/将第一个向量与第二个向量相除v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v/t)
它产生以下结果：
[1] 0.250000 1.833333 1.500000
%%两个向量求余v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v%%t)
它产生以下结果：
[1] 2.0 2.5 2.0
%/%两个向量相除求商v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v%/%t)
它产生以下结果：
[1] 0 1 1
^将第二向量作为第一向量的指数v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v^t)
它产生以下结果：
[1] 256.000 166.375 1296.000

关系运算符

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

运算符描述实例
>检查第一向量的每个元素是否大于第二向量的相应元素。v <- c(2, 5.5, 6, 9)
t <- c(8, 2.5, 14, 9)
print(v>t)
它产生以下结果：
[1] FALSE TRUE FALSE FALSE
<检查第一个向量的每个元素是否小于第二个向量的相应元素。v <- c(2, 5.5, 6, 9)
t <- c(8, 2.5, 14, 9)
print(v < t)
它产生以下结果：
[1] TRUE FALSE TRUE FALSE
==检查第一个向量的每个元素是否等于第二个向量的相应元素。v <- c(2, 5.5, 6, 9)
t <- c(8, 2.5, 14, 9)
print(v == t)
它产生以下结果：
[1] FALSE FALSE FALSE TRUE
<=检查第一向量的每个元素是否小于或等于第二向量的相应元素。v <- c(2, 5.5, 6, 9)
t <- c(8, 2.5, 14, 9)
print(v<=t)
它产生以下结果：
[1] TRUE FALSE TRUE TRUE
>=检查第一向量的每个元素是否大于或等于第二向量的相应元素。v <- c(2, 5.5, 6, 9)
t <- c(8, 2.5, 14, 9)
print(v>=t)
它产生以下结果：
[1] FALSE TRUE FALSE TRUE
!=检查第一个向量的每个元素是否不等于第二个向量的相应元素。v <- c(2, 5.5, 6, 9
t <- c(8, 2.5, 14, 9)
print(v!=t)
它产生以下结果：
[1] TRUE TRUE TRUE FALSE

逻辑运算符

下表显示了 R 语言支持的逻辑运算符。它只适用于逻辑，数字或复杂类型的向量。所有大于 1 的数字被认为是逻辑值 TRUE。

将第一向量的每个元素与第二向量的相应元素进行比较。比较的结果是布尔值。

运算符描述实例
&它被称为元素逻辑 AND 运算符。
它将第一向量的每个元素与第二向量的相应元素组合，
并且如果两个元素都为 TRUE，则给出输出 TRUE。		v <- c(3, 1, TRUE, 2+3i)
t <- c(4, 1, FALSE, 2+3i)
print(v&t)
它产生以下结果：
[1] TRUE TRUE FALSE TRUE
&vert；它被称为元素逻辑或运算符。
它将第一向量的每个元素与第二向量的相应元素组合，
并且如果元素为真，则给出输出 TRUE。		v <- c(3, 0, TRUE, 2+2i)
t <- c(4, 0, FALSE, 2+3i)
print(v|t)
它产生以下结果：
[1] TRUE FALSE TRUE TRUE
!它被称为逻辑非运算符。取得向量的每个元素，并给出相反的逻辑值。v <- c(3, 0, TRUE, 2+2i)
print(!v)
它产生以下结果：
[1] FALSE TRUE FALSE FALSE

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

运算符描述实例
&&称为逻辑 AND 运算符。取两个向量的第一个元素，
并且只有两个都为 TRUE 时才给出 TRUE。		v <- c(3, 0, TRUE, 2+2i)
t <- c(1, 3, TRUE, 2+3i)
print(v&&t)
它产生以下结果：
[1] TRUE
|&vert；称为逻辑 OR 运算符。取两个向量的第一个元素，
如果其中一个为 TRUE，则给出 TRUE。		v <- c(0, 0, TRUE, 2+2i)
t <- c(0, 3, TRUE, 2+3i)
print(v||t)
它产生以下结果：
[1] FALSE

赋值运算符

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

运算符描述实例
<−
=
<<−
称为左分配v1 <- c(3, 1, TRUE, 2+3i)
v2 <<- c(3, 1, TRUE, 2+3i)
v3 = c(3, 1, TRUE, 2+3i)
print(v1)
print(v2)
print(v3)
它产生以下结果：
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i
->
->>		称为右分配c(3, 1, TRUE, 2+3i) -> v1
c(3, 1, TRUE, 2+3i) ->> v2
print(v1)
print(v2)
它产生以下结果：
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

其他运算符

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

运算符描述实例
:冒号运算符。它为向量按顺序创建一系列数字。v <- 2:8
print(v)
它产生以下结果：
[1] 2 3 4 5 6 7 8
%in%此运算符用于标识元素是否属于向量。v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t)
print(v2 %in% t)
它产生以下结果：
[1] TRUE
[1] FALSE
%*%此运算符用于将矩阵与其转置相乘。M = matrix(c(2, 6, 5, 1, 10, 4),
nrow = 2, ncol = 3, byrow = TRUE)
t = M %*% t(M)
print(t)
它产生以下结果：
            [,1] [,2]
[1,]    65    82
[2,]    82    117

包

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

所有可用的 R 语言包都列在 R 语言的包。

下面是用于检查，验证和使用 R 包的命令列表。

检查可用 R 语言的包

获取包含 R 包的库位置

1
2
3
4
5
.libPaths()

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 环境中加载的所有包

1
2
3
4
5
6
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 环境中。可能会提示您选择最近的镜像。根据您的位置选择一个。

1
2
3
4
install.packages("Package Name")

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

手动安装包

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

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

1
2
3
4
install.packages(file_name_with_path, repos = NULL, type = "source")

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

装载包到库中

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

使用以下命令加载包：

1
2
3
4
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 提供以下类型的决策语句。

  • if 语句
  • if ... else 语句
  • switch 语句

if 语句

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

语法

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

1
2
3
if(boolean_expression) {
   # statement(s) will execute if the boolean expression is true.
}

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

流程图

if 语句

实例

1
2
3
4
5
6
7
8
x <- 30L
if(is.integer(x)) {
   print("X is an Integer")
}

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

[1] "X is an Integer"

if...else 语句

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

语法

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

1
2
3
4
5
if(boolean_expression) {
   # statement(s) will execute if the boolean expression is true.
} else {
   # statement(s) will execute if the boolean expression is false.
}

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

流程图

if...else 语句

实例

1
2
3
4
5
6
7
8
9
10
11
x <- c("what", "is", "truth")

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

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

[1] "Truth is not found"

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

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

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

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

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

语法

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

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

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
x <- c("what", "is", "truth")

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

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

[1] "truth is found the second time"

switch ​语句

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

语法

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

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

以下规则适用于 ​switch ​语句：

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

流程图

switch ​语句

实例 1

1
2
3
4
5
6
7
8
9
10
11
x <- switch(
   3,
   "first",
   "second",
   "third",
   "fourth"
)
print(x)
# 当上面的代码被编译和执行时，它产生以下结果：

[1] "third"

实例 2

​runif()​ 函数用于生成从 ​0 ​到 ​1 ​区间范围内的服从正态分布的随机数：

1
2
3
4
5
6
7
8
9
switch(1, 2*3, sd(1:5), runif(3))  #返回 (2*3, sd(1:5), runif(3)) list 中的第一个成分 
switch(2, 2*3, sd(1:5), runif(3))  #返回第二个成分
switch(3, 2*3, sd(1:5), runif(3))  #返回第三个成分

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

[1] 6
[1] 1.581139
[1] 0.31508117 0.04610938 0.19489747

循环

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

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

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

循环

循环控制语句

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

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

  • break
  • next

Repeat 语句

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

语法

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

1
2
3
4
5
6
repeat { 
   commands 
   if(condition) {
      break
   }
}

流程图

Repeat 语句

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
v <- c("Hello", "loop")
cnt <- 2

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

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

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

while 语句

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

语法

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

1
2
3
while (test_expression) {
   statement
}

流程图

while 语句

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

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
v <- c("Hello","while loop")
cnt <- 2

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

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

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

for 语句

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

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

语法

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

1
2
3
for (变量 in 条件) {
   循环体
}

流程图

for 语句

实例

1
2
3
4
5
6
7
8
9
10
11
v <- LETTERS[1:4]
for ( i in v) {
   print(i)
}

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

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

break 语句

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

当在循环中遇到 break 语句时，循环立即终止，并且程序控制在循环之后的下一语句处恢复。 它可以用于终止 switch 语句中的情况。 语法 在 R 中创建 break 语句的基本语法是：

1
break

流程图

break 语句

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
v <- c("Hello","loop")
cnt <- 2

repeat {
   print(v)
   cnt <- cnt + 1

   if(cnt > 5) {
      break
   }
}

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

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

next 语句

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

语法

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

1
next

流程图

next 语句

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
v <- LETTERS[1:6]
for ( i in v) {
   
   if (i == "D") {
      next
   }
   print(i)
}

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

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

数据重塑

R 语言中的数据重塑是关于改变数据被组织成行和列的方式。

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

数据框中加入列和行

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# 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() 函数合并两个数据框。数据框必须具有相同的列名称，在其上进行合并。

在下面的例子中，我们考虑使用 library() 函数加载 MASS 第三方包，使用 MASS 中有关 Pima Indian Women 的糖尿病的数据集。我们基于血压（bp）和体重指数（bmi）的值合并两个数据集。在选择这两列用于合并时，其中这两个变量的值在两个数据集中匹配的记录被组合在一起以形成单个数据框。

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

[1] 17

有时，电子表格数据的格式很紧凑，可以给出每个主题的协变量，然后是该主题的所有观测值。R 的建函数需要在单个列中进行观察。考虑以下来自重复 MRI 脑测量的数据样本：

1
2
3
4
5
6
7
8
Status   Age    V1     V2     V3    V4
     P 23646 45190  50333  55166 56271
    CC 26174 35535  38227  37911 41184
    CC 27723 25691  25712  26144 26398
    CC 27193 30949  29693  29754 30772
    CC 24370 50542  51966  54341 54273
    CC 28359 58591  58803  59435 61292
    CC 25136 45801  45389  47197 47126

在每个主题上有两个协变量和多达四个测量值。数据从 Excel 导出为 mr.csv 文件。

我们可以使用堆栈来帮助操纵这些数据以给出单个响应。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
zz <- read.csv("mr.csv", strip.white = TRUE)
zzz <- cbind(zz[gl(nrow(zz), 1, 4*nrow(zz)), 1:2], stack(zz[, 3:6]))

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

      Status   Age values ind
X1         P 23646  45190  V1
X2        CC 26174  35535  V1
X3        CC 27723  25691  V1
X4        CC 27193  30949  V1
X5        CC 24370  50542  V1
X6        CC 28359  58591  V1
X7        CC 25136  45801  V1
X11        P 23646  50333  V2
...

函数 unstack 的方向相反，可能对导出数据很有用。

另一种方法是使用函数重塑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
reshape(zz, idvar="id", timevar="var", varying=list(c("V1", "V2", "V3", "V4")), direction="long")

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

    Status   Age var    V1 id
1.1      P 23646   1 45190  1
2.1     CC 26174   1 35535  2
3.1     CC 27723   1 25691  3
4.1     CC 27193   1 30949  4
5.1     CC 24370   1 50542  5
6.1     CC 28359   1 58591  6
7.1     CC 25136   1 45801  7
1.2      P 23646   2 50333  1
2.2     CC 26174   2 38227  2
...

重塑函数的语法比堆栈更复杂，但可以用于 long 表单中不止一列的数据。如果 direction="width"，重塑还可以执行相反的转换。

函数

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

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

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

函数定义

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

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

函数组件

函数的不同部分：

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

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

内置函数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 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 语言中创建用户定义的函数。它们特定于用户想要的，一旦创建，它们就可以像内置函数一样使用。下面是一个创建和使用函数的例子。

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

调用函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 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(4)

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

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

调用没有参数的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 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

使用默认参数调用函数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 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

函数的延迟计算

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Create a function with arguments.
new.function <- function(a, b) {
   print(a^2)
   print(a)
   print(b)
}

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

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

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

字符串

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

字符串构造规则

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

  • 双引号可以插入以单引号开头和结尾的字符串中。
  • 单引号可以插入以双引号开头和结尾的字符串中。
  • 双引号不能插入以双引号开头和结尾的字符串中。
  • 单引号不能插入以单引号开头和结尾的字符串中。

有效字符串的示例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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"

无效字符串的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

字符串操作

连接字符串

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

语法

函数的基本语法是：

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

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

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

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
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() 函数将数字和字符串格式化为特定样式。

语法

函数的基本语法是：

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

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

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

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 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() 函数可以计算字符串中包含空格的字符数。

语法

函数的基本语法是：

1
nchar(x)

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

  • x 是向量输入。

实例

1
2
3
4
5
6
result <- nchar("Count the number of characters")
print(result)

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

[1] 30

更改大小写

使用 toupper() 和 tolower() 函数可以改变字符串的字符的大小写。

语法

函数的基本语法是：

1
2
toupper(x)
tolower(x)

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

  • x 是向量输入。

实例

1
2
3
4
5
6
7
8
9
10
11
12
# 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() 函数可以用于提取字符串的部分。

语法

函数的基本语法是：

1
substring(x, first, last)

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

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

实例

1
2
3
4
5
6
7
# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)

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

[1] "act"

向量

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

创建向量

单元素向量

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 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

多元素向量

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 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.) 序列运算符

1
2
3
4
5
6
# 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() 函数

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

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

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

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

访问向量元素

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 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"

向量操作

向量运算

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 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

向量元素回收

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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() 函数排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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() 函数创建的。

创建列表

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 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

命名列表元素

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 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

访问列表元素

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 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

操作列表元素

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan", "Feb", "Mar"), matrix(c(3, 9, 5, 1, -2, 8), nrow = 2), list("green", 12.3))

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

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

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

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

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

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

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

$
NULL

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

合并列表

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 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() 函数完成这个转换。它将列表作为输入并生成向量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# Create lists.
list1 <- list(1:5)
print(list1)

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

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

print(v1)
print(v2)

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

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

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

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

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

矩阵

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

创建矩阵

R 语言中使用 matrix() 函数创建一个矩阵。

语法

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

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

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

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

实例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 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 找到下面的具体元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 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 运算符对矩阵执行各种数学运算。操作的结果也是一个矩阵。

对于操作中涉及的矩阵，维度（行数和列数）应该相同。

加法和减法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 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

乘法和除法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 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 列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 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 参数给数组中的行，列和矩阵命名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 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

访问数组元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 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

操作数组元素

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 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() 函数在数组中的元素上进行计算。

语法

1
apply(x, margin, fun)

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

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

实例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 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() 函数通过将向量作为输入创建因子。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 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 语言将文本列视为分类数据并在其上创建因子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 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

更改级别顺序

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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() 函数生成因子级别。它需要两个整数作为输入，指示每个级别有多少级别和多少次。

语法

1
gl(n, k, labels)

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

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

实例

1
2
3
4
5
6
7
v <- gl(3, 4, labels = c("Tampa", "Seattle", "Boston"))
print(v)

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

 [1] Tampa   Tampa   Tampa   Tampa   Seattle Seattle Seattle Seattle Boston  Boston  Boston  Boston 
Levels: Tampa Seattle Boston

数据框

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

以下是数据框的特性。

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

创建数据框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 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() 函数可以看到数据框的结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 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() 函数获取数据的统计摘要和性质。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 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

从数据框提取数据

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 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 行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 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

扩展数据框

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

添加列

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 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() 函数。

在下面的示例中，我们创建一个包含新行的数据框，并将其与现有数据框合并以创建最终数据框。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# Create the first data frame.
emp.data <- data.frame(
   emp_id = c(1:5), 
   emp_name = c("Rick", "Dan", "Michelle", "Ryan", "Gary"), 
   salary = c(623.3, 515.2, 611.0, 729.0, 843.25), 
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), 
   dept = c("IT", "Operations", "IT", "HR", "Finance"),
   stringsAsFactors = FALSE
)

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

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

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

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

自带数据集

使用以下命令可以查询 R 语言自带的数据集：

1
data()

向量数据集

数据集内容
euro欧元汇率，长度为 11，每个元素都有命名
landmasses48 个陆地的面积，每个都有命名
precip长度为 70 的命名向量
rivers北美 141 条河流长度
state.abb美国 50 个州的双字母缩写
state.area美国 50 个州的面积
state.name美国 50 个州的全称

因子数据集

数据集内容
state.division美国 50 个州的分类，9 个类别
state.region美国 50 个州的地理分类

矩阵、数组数据集

数据集内容
euro.cross11 种货币的汇率矩阵
freeny每个季度影响收入四个因素的记录
state.x77美国 50 个州的八个指标
USPersonalExpenditure5 个年份在 5 个消费方向的数据
VADeaths1940 年弗吉尼亚州死亡率（每千人）
volcano某火山区的地理信息（10 米 × 10 米的网格）
WorldPhones8 个区域在 7 个年份的电话总数
iris33 种鸢尾花形态数据
Titanic泰坦尼克乘员统计
UCBAdmissions伯克利分校 1973 年院系、录取和性别的频数
crimtab3000 个男性罪犯左手中指长度和身高关系
HairEyeColor592 人头发颜色、眼睛颜色和性别的频数
occupationalStatus英国男性父子职业联系

类矩阵数据集

数据集内容
eurodist欧洲 12 个城市的距离矩阵，只有下三角部分
Harman23.cor305 个女孩 8 个形态指标的相关系数矩阵
Harman74.cor145 个儿童 24 个心理指标的相关系数矩阵

数据框数据集

数据集内容
airquality纽约 1973 年 5-9 月每日空气质量
anscombe四组 x-y 数据，虽有相似的统计量，但实际数据差别较大
attenu多个观测站对加利福尼亚 23 次地震的观测数据
attitude30 个部门在七个方面的调查结果，调查结果是同一部门 35 个职员赞成的百分比
beaver1一只海狸每 10 分钟的体温数据，共 114 条数据
beaver2另一只海狸每 10 分钟的体温数据，共 100 条数据
BOD随水质的提高，生化反应对氧的需求（mg/l）随时间（天）的变化
cars1920 年代汽车速度对刹车距离的影响
chickwts不同饮食种类对小鸡生长速度的影响
esoph法国的一个食管癌病例对照研究
faithful一个间歇泉的爆发时间和持续时间
Formaldehyde两种方法测定甲醛浓度时分光光度计的读数
Freeny每季度收入和其他四因素的记录
dating from配对的病例对照数据，用于条件 logistic 回归
InsectSprays使用不同杀虫剂时昆虫数目
iris3 种鸢尾花形态数据
LifeCycleSavings50 个国家的存款率
longley强共线性的宏观经济数据
morley光速测量试验数据
mtcars32 辆汽车在 11 个指标上的数据
OrchardSprays使用拉丁方设计研究不同喷雾剂对蜜蜂的影响
PlantGrowth三种处理方式对植物产量的影响
pressure温度和气压
Puromycin两种细胞中辅因子浓度对酶促反应的影响
quakes1000 次地震观测数据（震级 4）
randu使用 FORTRAN 中的 RANDU 三个一组生成随机数字，共 400 组。
rock48 块石头的形态数据
sleep两药物的催眠效果
stackloss化工厂将氨转为硝酸的数据
swiss瑞士生育率和社会经济指标
ToothGrowthVC 剂量和摄入方式对豚鼠牙齿的影响
trees树木形态指标
USArrests美国 50 个州的四个犯罪率指标
USJudgeRatings43 名律师的 12 个评价指标
warpbreaks织布机异常数据
women15 名女性的身高和体重

列表数据集

数据集内容
state.center美国 50 个州中心的经度和纬度

类数据框数据集

数据集内容
ChickWeight饮食对鸡生长的影响
CO2耐寒植物 CO2 摄取的差异
DNase若干次试验中，DNase 浓度和光密度的关系
Indometh某药物的药物动力学数据
Loblolly火炬松的高度、年龄和种源
Orange桔子树生长数据
Theoph茶碱药动学数据

时间序列数据集

数据集内容
airmiles美国 1937-1960 年客运里程营收（实际售出机位乘以飞行哩数）
AirPassengersBox & Jenkins 航空公司 1949-1960 年每月国际航线乘客数
austres澳大利亚 1971-1994 每季度人口数（以千为单位）
BJsales有关销售的一个时间序列
BJsales.lead前一指标的先行指标（leading indicator）
co21959-1997 年每月大气 co2 浓度（ppm）
discoveries1860-1959 年每年巨大发现或发明的个数
ldeaths1974-1979 年英国每月支气管炎、肺气肿和哮喘的死亡率
fdeaths前述死亡率的女性部分
mdeaths前述死亡率的男性部分
freeny.y每季度收入
JohnsonJohnson1960-1980 年每季度 Johnson & Johnson 股票的红利
LakeHuron1875-1972 年某一湖泊水位的记录
lh黄体生成素水平，10 分钟测量一次
lynx1821-1934 年加拿大猞猁数据
nhtemp1912-1971 年每年平均温度
Nile1871-1970 尼罗河流量
nottem1920-1939 每月大气温度
presidents1945-1974 年每季度美国总统支持率
UKDriverDeaths1969-1984 年每月英国司机死亡或严重伤害的数目
sunspot.month1749-1997 每月太阳黑子数
sunspot.year1700-1988 每年太阳黑子数
sunspots1749-1983 每月太阳黑子数
treering归一化的树木年轮数据
UKgas1960-1986 每月英国天然气消耗
USAccDeaths1973-1978 美国每月意外死亡人数
uspop1790–1970 美国每十年一次的人口总数（百万为单位）
WWWusage每分钟网络连接数
Seatbelts多变量时间序列。和 UKDriverDeaths 时间段相同，反映更多因素。
EuStockMarkets多变量时间序列。欧洲股市四个主要指标的每个工作日记录，共 1860 条记录。