R基础

Posted 2020-10-17

R命令提示符

当安装好了R开发环境以后，那么通过在命令提示符下键入以下命令，就可以启动R命令提示符 -

$ R

或者，在Windows系统下 -

C:\\Users\\Administrator> R

这将启动R解释器，您将获得一个提示>您可以在以下开始编写程序 -

上图程序中，第一个语句定义了一个字符串变量str，然后分配一个字符串“Hello，World~！”，下一个语句print()用于打印存储在变量str中的值。

R脚本文件

通常，我们通过在脚本文件中编写R代码，然后再通过名为Rscript的R解释器的帮助下，在命令提示符下执行这些脚本。 所以下面演示如何在一个名为helloR.R的文本中编写代码，如下 -

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

print ( myString)

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

$ Rscript test.R

当我们运行上述程序时，会产生以下结果(Windows)

E:\\Travle2R
λ Rscript helloR.R
[1] "hello the cruel world!"

注释

注释就像在R程序中帮助文本，并且在执行实际程序时被解释器忽略。单个注释在语句的开头使用#写成如下：

# My first program in R Programming

R不支持多行注释，但可以执行以下操作：

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

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

虽然上述注释由R解释器执行，但不会干扰您的实际编程代码。所以我们可以把要注释的内容放入单引号或双引号中。

R语言与其他编程语言(如C语言和Java)相反，变量不会被声明为某些数据类型。 变量被分配给R对象，并且R对象的数据类型转变为变量的数据类型。 有很多类型的R对象。 常用R对象是 -

• 向量
• 列表
• 矩阵
• 数组
• 因子
• 数据帧

这些对象中最简单的是向量对象，并且向量对象有六种数据类型的原子向量，也称为六类向量。 其他R对象是建立在原子向量之上的。六类向量类型如下表所示 -

数据类型	示例	验证代码	输出结果
逻辑	TRUE, FALSE	v <- TRUE ; print(class(v));	[1] "logical"
数字值	12.3, 5, 999	v <- 23.5 ; print(class(v));	[1] "numeric"
整数	2L, 34L, 0L	v <- 2L ; print(class(v));	[1] "integer"
复数	3 + 2i	v <- 2+5i ; print(class(v));	[1] "complex"
字符	‘a’ , ‘“good”, “TRUE”, ‘23.4’	v <- "TRUE" ; print(class(v));	[1] "character"
原生	"Hello"存储值为： 48 65 6c 6c 6f	v <- charToRaw("Hello"); print(class(v));	[1] "raw"

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

向量

当要创建具有多个元素的向量时，应该使用c()函数，表示将元素组合成一个向量。

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

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

上面示例代码，执行结果如下 -

> apple <- c('red','green',"yellow");
> print(apple);
[1] "red"    "green"  "yellow"
> print(class(apple));
[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
# applying the nlevels function we can know the number of distinct values
[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对象的组合。有效的变量名称应该是由字母，数字和点或下划线字符组成。 变量名称以字母开头，或者点后面不带数字。如下一些示例 -

变量名	合法性	原因
var_name2.	有效	由字母，数字，点和下划线组成
var_name%	无效	含有字符“%”因此无效。只允许点(.)和下划线(_)组成。
2var_name	无效	以数字开头，因此无效。
.var_name, var.name	有效	可以以点(.)开头，但点(.)后面不应是数字。
.2var_name	无效	以点(.)但后跟一个数字使其无效。
_var_name	无效	以下划(_)开始因此无效。

变量赋值

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

# Assignment using equal operator.
var.1 = c(0,1,2,3)           

# Assignment using leftward operator.
var.2 <- c("learn","R")   

# Assignment using rightward operator.   
c(TRUE,1) -> var.3           

print(var.1)
cat ("var.1 is ", var.1 ,"\\n")
cat ("var.2 is ", var.2 ,"\\n")
cat ("var.3 is ", var.3 ,"\\n")

执行上面示例代码，得到以下结果 -

> print(var.1)
[1] 0 1 2 3
> cat ("var.1 is ", var.1 ,"\\n")
var.1 is  0 1 2 3 
> cat ("var.2 is ", var.2 ,"\\n")
var.2 is  learn R 
> cat ("var.3 is ", var.3 ,"\\n")
var.3 is  1 1


Shell

注 - 向量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")

执行上面示例代码，得到以下结果 -

> var_x <- "Hello"
> cat("The class of var_x is ",class(var_x),"\\n")
The class of var_x is  character 
>
> var_x <- 34.5
> cat("  Now the class of var_x is ",class(var_x),"\\n")
  Now the class of var_x is  numeric 
>
> var_x <- 27L
> cat("   Next the class of var_x becomes ",class(var_x),"\\n")
   Next the class of var_x becomes  integer 
>

查找变量

如想要知道工作区中当前可用的所有变量，可使用ls()函数。ls()函数也可以使用模式来匹配变量名。

print(ls());

执行上面示例代码，得到以下结果 -

> print(ls());
[1] "string" "var.1"  "var.2"  "var.3"  "var_x"

注意 - 根据您的环境中声明的变量可能所有不同，所以您的输出和这里输出结果可能不太一样。

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

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

执行上面示例代码，得到以下结果 -

> print(ls(pattern = "var")) 
[1] "var.1" "var.2" "var.3" "var_x"


Shell

以点(.)开头的变量是隐藏的，它们可以使用ls()函数的“all.names = TRUE”参数列出。如下所示 -

print(ls(all.names = TRUE));

执行上面示例代码，得到以下结果 -

> print(ls(all.names = TRUE));
[1] ".var_no" ".var1"   "string"  "var.1"   "var.2"   "var.3"   "var_x"  
>

删除变量

可以使用rm()函数删除变量。下面假设要删除变量var.3。 在打印时抛出变量错误的值。

rm(var.3)
print(var.3)

执行上面查询代码，得到以下结果 -

> rm(var.3)
> print(var.3)
Error in print(var.3) : 找不到对象'var.3'

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

rm(list = ls())
print(ls())

执行上面示例代码，得到以下结果 -

> rm(list = ls())
> print(ls())
character(0)

运算符

在R编程中有以下类型的运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

算术运算符

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

• 加法(+)， 相加两个向量。
  示例代码：

  v <- c( 2,5.5,6);
  t <- c(8, 3, 4);
  print(v+t);

执行上面示例代码，得到以下结果 -

  [1] 10.0  8.5 10.0

• 减法(-)， 将一个向量减去另一个向量。
  示例代码：

  v <- c( 2,5.5,6);
  t <- c(8, 3, 4);
  print(v-t);

执行上面示例代码，得到以下结果 -

  [1] -6.0  2.5  2.0

• 乘法(*)， 将两向量相乘。
  示例代码：

  v <- c( 2,5.5,6);
  t <- c(8, 3, 4);
  print(v*t);

执行上面示例代码，得到以下结果 -

  [1] 16.0 16.5 24.0

• 除法(/)， 将第一个向量除以第二个向量。
  示例代码：

  v <- c( 2,5.5,6);
  t <- c(8, 3, 4);
  print(v/t);

执行上面示例代码，得到以下结果 -

  [1] 0.250000 1.833333 1.500000

• 求余(%%)， 将第一个向量除以第二个向量得到余数。
  示例代码：

  v <- c( 2,5.5,6);
  t <- c(8, 3, 4);
  print(v%%t);

执行上面示例代码，得到以下结果 -

  [1] 2.0 2.5 2.0

• 求模数(%/%)， 将第一个向量除以第二个向量得到模数。
  示例代码：

  v <- c( 2,5.5,6);
  t <- c(8, 3, 4);
  print(v%/%t);

执行上面示例代码，得到以下结果 -

  [1] 0 1 1

• 求指数幂(^)， 将第一个向量除以第二个向量得到幂值。
  示例代码：

  v <- c( 2,5.5,6);
  t <- c(8, 3, 4);
  print(v^t);

执行上面示例代码，得到以下结果 -

  [1]  256.000  166.375 1296.000

关系运算符

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

• 大于(>) - 检查第一个向量的每个元素是否大于第二个向量中的相应元素。
  示例代码：

  v <- c(2,5.5,6,9);
  t <- c(8,2.5,14,9);
  print(v>t);

执行上面示例代码，得到以下结果 -

  [1] FALSE  TRUE FALSE FALSE

• 小于(<) - 检查第一个向量的每个元素是否小于第二个向量中的相应元素。
  示例代码：

  v <- c(2,5.5,6,9);
  t <- c(8,2.5,14,9);
  print(v < t);

执行上面示例代码，得到以下结果 -

  [1]  TRUE FALSE  TRUE FALSE

• 等于(==) - 检查第一个向量的每个元素是否等于第二个向量中的相应元素。
  示例代码：

  v <- c(2,5.5,6,9);
  t <- c(8,2.5,14,9);
  print(v == t);

执行上面示例代码，得到以下结果 -

  [1] FALSE FALSE FALSE  TRUE

• 小于或等于(<=) - 检查第一个向量的每个元素是否小于或等于第二个向量中的相应元素。
  示例代码：

  v <- c(2,5.5,6,9);
  t <- c(8,2.5,14,9);
  print(v<=t);

执行上面示例代码，得到以下结果 -

  [1]  TRUE FALSE  TRUE  TRUE

• 大于或等于(>=) - 检查第一个向量的每个元素是否大于或等于第二个向量中的相应元素。
  示例代码：

  v <- c(2,5.5,6,9);
  t <- c(8,2.5,14,9);
  print(v>=t);

执行上面示例代码，得到以下结果 -

  [1] FALSE  TRUE FALSE  TRUE

• 不等于(!=) - 检查第一个向量的每个元素是否不等于第二个向量中的相应元素。
  示例代码：

  v <- c(2,5.5,6,9);
  t <- c(8,2.5,14,9);
  print(v!=t);

执行上面示例代码，得到以下结果 -

  [1]  TRUE  TRUE  TRUE FALSE

逻辑运算符

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

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

• 逻辑与(&) - 它被称为元素逻辑与运算符。它将第一个向量的每个元素与第二个向量的相应元素相结合，如果两个元素都为真，则输出为TRUE。
  示例代码：

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

执行上面示例代码，得到以下结果 -

  [1]  TRUE  TRUE FALSE  TRUE

• 逻辑或(|) - 它被称为元素逻辑或运算符。它将第一个向量的每个元素与第二个向量的相应元素相结合，如果两个元素中有一个为真，则输出为TRUE。
  示例代码：

  v <- c(3,0,TRUE,2+2i);
  t <- c(4,0,FALSE,2+3i);
  print(v|t);

执行上面示例代码，得到以下结果 -

  [1]  TRUE FALSE  TRUE  TRUE

• 逻辑非(!) - 它被称为元素逻辑非运算符。获取向量的每个元素并给出相反的逻辑值。
  示例代码：

  v <- c(3,0,TRUE,2+2i);
  print(!v);

执行上面示例代码，得到以下结果 -

  [1] FALSE  TRUE FALSE FALSE

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

• 逻辑与运算符(&&) - 取两个向量的第一个元素，并且只有在两个都为TRUE时结果才为TRUE值。

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

执行上面示例代码，得到以下结果 -

  [1] TRUE

• 逻辑或运算符(||) - 取两个向量的第一个元素，并且如果有一个为TRUE时，结果为TRUE值。

  v <- c(0,0,TRUE,2+2i);
  t <- c(0,3,TRUE,2+3i);
  print(v||t);

执行上面示例代码，得到以下结果 -

  [1] FALSE

赋值运算符

这些运算符用于向向量分配值。

• <?，<<?和= - 叫作左分配符。参考以下代码 -

  v1 <- c(3,1,TRUE,2+3i);
  v2 <<- c(3,1,TRUE,2+3i);
  v3 = c(3,1,TRUE,2+3i);
  print(v1);
  print(v2);
  print(v3);

执行上面示例代码，得到以下结果 -

  [1] 3+0i 1+0i 1+0i 2+3i
  [1] 3+0i 1+0i 1+0i 2+3i
  [1] 3+0i 1+0i 1+0i 2+3i

• ->和->> - 叫作右分配符。参考以下代码 -

  c(3,1,TRUE,2+3i) -> v1;
  c(3,1,TRUE,2+3i) ->> v2;
  print(v1);
  print(v2);

执行上面示例代码，得到以下结果 -

  [1] 3+0i 1+0i 1+0i 2+3i
  [1] 3+0i 1+0i 1+0i 2+3i

其他运算符

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

• 冒号运算符(:) - 它为向量创建一系列数字。参考以下代码 -

  v <- 2:8;
  print(v);

执行上面示例代码，得到以下结果 -

  [1] 2 3 4 5 6 7 8

• 成员运算符(%in%) - 该运算符用于识别元素是否属于向量。参考以下代码 -

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

执行上面示例代码，得到以下结果 -

  [1] TRUE
  [1] FALSE

• 转置相乘(%*%) - 该运算符用于将矩阵与其转置相乘。参考以下代码 -

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

执行上面示例代码，得到以下结果 -

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