R - 快速指南

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 - 环境设置

本地环境设置

如果您仍然愿意为 R 设置环境，可以按照以下步骤操作。

Windows安装

您可以从R-3.2.2 for Windows（32/64 位）下载 R 的 Windows 安装程序版本，并将其保存在本地目录中。

因为它是一个名为“R-version-win.exe”的 Windows 安装程序 (.exe)。您只需双击并运行安装程序并接受默认设置即可。如果您的 Windows 是 32 位版本，则会安装 32 位版本。但如果您的 Windows 是 64 位，那么它会同时安装 32 位和 64 位版本。

安装后，您可以在 Windows Program Files 下的目录结构“R\R3.2.2\bin\i386\Rgui.exe”中找到运行程序的图标。单击此图标将弹出 R-GUI，这是进行 R 编程的 R 控制台。

Linux安装

R 可作为适用于许多版本 Linux 的二进制文件，位于R Binaries位置。

安装 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 - 基本语法

按照惯例，我们将从编写“Hello, World!”开始学习 R 编程。程序。根据需要，您可以在 R 命令提示符下编程，也可以使用 R 脚本文件来编写程序。让我们一一检查一下。

R 命令提示符

设置 R 环境后，只需在命令提示符处键入以下命令即可轻松启动 R 命令提示符 -

$ R

这将启动 R 解释器，您将收到提示 > 您可以在其中开始输入程序，如下所示 -

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

这里第一条语句定义了一个字符串变量 myString，我们在其中分配一个字符串“Hello, World!” 然后下一个语句 print() 用于打印变量 myString 中存储的值。

R 脚本文件

通常，您将通过在脚本文件中编写程序来进行编程，然后在名为Rscript的 R 解释器的帮助下在命令提示符下执行这些脚本。因此，让我们开始在名为 test.R 的文本文件中编写以下代码，如下所示 -

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

print ( myString)

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

$ Rscript test.R 

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

[1] "Hello, World!"

评论

注释就像 R 程序中的帮助文本，在执行实际程序时解释器会忽略它们。单个注释在语句开头使用 # 编写，如下所示 -

# My first program in R Programming

R 不支持多行注释，但您可以执行如下技巧 -

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

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

[1] "Hello, World!"

虽然上述注释将由 R 解释器执行，但它们不会干扰您的实际程序。您应该将此类注释放入单引号或双引号中。

R - 数据类型

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

您可能喜欢存储各种数据类型的信息，如字符、宽字符、整数、浮点、双浮点、布尔值等。操作系统根据变量的数据类型分配内存并决定可以存储的内容保留内存。

与 R 中的 C 和 java 等其他编程语言相比，变量没有声明为某种数据类型。变量被分配有 R 对象，并且 R 对象的数据类型成为变量的数据类型。R 对象有多种类型。常用的是 -

• 向量
• 列表
• 矩阵
• 数组
• 因素
• 数据框

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

v <- TRUE 
print(class(v))

[1] "logical" 

v <- 23.5
print(class(v))

[1] "numeric"

v <- 2L
print(class(v))

[1] "integer"

v <- 2+5i
print(class(v))

[1] "complex"

v <- "TRUE"
print(class(v))

[1] "character"

v <- charToRaw("Hello")
print(class(v))

[1] "raw" 

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

向量

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

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

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

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

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

列表

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

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

# Print the list.
print(list1)

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

[[1]]
[1] 2 5 3

[[2]]
[1] 21.3

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

矩阵

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

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

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

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

数组

虽然矩阵仅限于二维，但数组可以是任意数量的维度。数组函数采用一个 dim 属性来创建所需的维数。在下面的示例中，我们创建一个包含两个元素的数组，每个元素都是 3x3 矩阵。

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

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

, , 1

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

, , 2

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

因素

因子是使用向量创建的 r 对象。它将向量以及向量中元素的不同值存储为标签。标签始终是字符，无论输入向量中是数字、字符还是布尔值等。它们在统计建模中很有用。

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

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

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

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

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

[1] green  green  yellow red    red    red    green 
Levels: green red yellow
[1] 3

数据框

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

数据框是使用data.frame()函数创建的。

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

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

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

R - 变量

变量为我们提供了程序可以操作的命名存储。R 中的变量可以存储一个Atomics向量、一组Atomics向量或多个 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 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")

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

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

注意- 向量 c(TRUE,1) 具有逻辑类和数字类的混合。因此逻辑类被强制转换为数字类，使得 TRUE 为 1。

变量的数据类型

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

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

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

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

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

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

寻找变量

要了解工作区中当前可用的所有变量，我们使用ls()函数。ls() 函数还可以使用模式来匹配变量名称。

print(ls())

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

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

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

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

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

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

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

以点(.)开头的变量是隐藏的，可以使用 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 语言支持的算术运算符。运算符作用于向量的每个元素。

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。

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

v <- c(3,1,TRUE,2+3i)
t <- c(4,1,FALSE,2+3i)
print(v&t)

[1]  TRUE  TRUE FALSE  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

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

v <- c(3,0,TRUE,2+2i)
t <- c(1,3,TRUE,2+3i)
print(v&&t)

[1] 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

v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t) 
print(v2 %in% t) 

[1] TRUE
[1] FALSE

M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

      [,1] [,2]
[1,]   65   82
[2,]   82  117

R-决策

决策结构要求程序员指定程序要评估或测试的一个或多个条件，以及在条件确定为 true 时要执行的一条或多条语句，以及可选的在条件确定时要执行的其他语句确定是假的。

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

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

R - 循环

可能存在这样的情况：您需要多次执行一段代码。一般来说，语句是按顺序执行的。首先执行函数中的第一条语句，然后执行第二条语句，依此类推。

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

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

R 编程语言提供以下类型的循环来处理循环需求。单击以下链接查看其详细信息。

循环控制语句

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

R 支持以下控制语句。单击以下链接查看其详细信息。

R-函数

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

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

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

功能定义

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

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

功能组件

函数的不同部分是 -

• 函数名称- 这是函数的实际名称。它作为具有该名称的对象存储在 R 环境中。

• 参数- 参数是一个占位符。当调用函数时，您将一个值传递给参数。参数是可选的；也就是说，函数可以不包含参数。参数也可以有默认值。

• 函数体- 函数体包含定义函数功能的语句集合。

• 返回值- 函数的返回值是函数体中要计算的最后一个表达式。

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

内置功能

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

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

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

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

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

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

用户自定义函数

我们可以在 R 中创建用户定义的函数。它们特定于用户的需求，一旦创建，就可以像内置函数一样使用。以下是如何创建和使用函数的示例。

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

调用函数

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

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

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

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

不带参数调用函数

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

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

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

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

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

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

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

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

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

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

[1] 26
[1] 58

使用默认参数调用函数

我们可以在函数定义中定义参数的值，并在不提供任何参数的情况下调用该函数以获得默认结果。但我们也可以通过提供新的参数值来调用此类函数并获得非默认结果。

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

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

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

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

[1] 18
[1] 45

函数的惰性求值

函数的参数是惰性求值的，这意味着它们仅在函数体需要时才求值。

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

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

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

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

R - 弦乐

R 中一对单引号或双引号内写入的任何值都被视为字符串。R 在内部将每个字符串存储在双引号内，即使您使用单引号创建它们也是如此。

字符串构造中应用的规则

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

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

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

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

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

有效字符串的示例

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

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

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

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

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

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

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

无效字符串的示例

e <- 'Mixed quotes" 
print(e)

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

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

当我们运行脚本时，它无法给出以下结果。

Error: unexpected symbol in:
"print(e)
f <- 'Single"
Execution halted

字符串操作

连接字符串 - Paste() 函数

R 中的许多字符串都是使用Paste()函数组合的。它可以将任意数量的参数组合在一起。

句法

粘贴函数的基本语法是 -

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

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

• ...表示要组合的任意数量的参数。

• sep表示参数之间的任何分隔符。它是可选的。

• 折叠用于消除两个字符串之间的空间。但不是一个字符串的两个单词内的空格。

例子

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

print(paste(a,b,c))

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

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

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

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

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

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

句法

格式函数的基本语法是 -

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

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

• x是向量输入。

• digits是显示的总位数。

• nsmall是小数点右侧的最小位数。

• Scientific设置为 TRUE 以显示科学记数法。

• width表示开头补空格后显示的最小宽度。

• justify是将字符串向左、向右或居中显示。

例子

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

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

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

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

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

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

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

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

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

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

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

句法

nchar() 函数的基本语法是 -

nchar(x)

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

• x是向量输入。

例子

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

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

[1] 30

更改大小写 - toupper() 和 tolower() 函数

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

句法

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

toupper(x)
tolower(x)

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

• x是向量输入。

例子

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

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

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

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

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

该函数提取字符串的一部分。

句法

substring() 函数的基本语法是 -

substring(x,first,last)

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

• x是字符向量输入。

• first是要提取的第一个字符的位置。

• last是要提取的最后一个字符的位置。

例子

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

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

[1] "act"

R - 向量

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

矢量创建

单元素向量

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

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

# Atomic vector of type double.
print(12.5)

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

# Atomic vector of type logical.
print(TRUE)

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

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

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

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

多元素向量

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

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

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

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

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

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

使用序列（Seq.）运算符

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

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

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

使用 c() 函数

如果元素之一是字符，则非字符值将被强制为字符类型。

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

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

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

访问向量元素

使用索引来访问 Vector 的元素。[ ] 括号用于索引。索引从位置 1 开始。在索引中给出负值会将该元素从结果中删除。TRUE、FALSE或0和1也可用于索引。

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

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

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

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

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

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

矢量处理

向量运算

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

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

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

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

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

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

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

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

向量元素回收

如果我们对两个长度不等的向量进行算术运算，则较短向量的元素将被回收来完成运算。