自2019年9月30日以来，本页面已被访问20004人次。

为了方便学习，教程中把执行代码后打印在屏幕上的信息，附在代码后边，前边加上两个#号及两个空格。练习时不用输入#号及其后边的内容。比如：

print("欢迎一起学习R语言！")
##  [1] "欢迎一起学习R语言！"

这里[1] “欢迎一起学习R语言！”就是print(“欢迎一起学习R语言！”)这条命令执行后打印到屏幕上的信息。

若对R语言的历史和特点等感兴趣可以看看R官网的介绍。

这里只讲Windows下的安装，能用Linux系统的基本上也就不太可能不会安装软件。我没用过Mac，不明确其中可能会遇到的问题，这里就不介绍了。

到R官网或者国内（比如清华或同济）的镜像下载安装文件进行安装。建议不要安在C盘，不然可能遇到一些权限问题，安装路径中避免有非英文字符。如果已经安装在C盘，当安装R包的时候如果遇到不可写的问题，则需要修改安装目录下library文件夹的权限。 启动选项选择“Yes(自定义启动)”，显示模式选择“SDI（多个分开的窗户）”，帮助风格选择“HTML帮助”，这样的选择以后用起来可能会方便一些。可以观看R的安装微课进一步熟悉。

R包的安装详见R包安装一节。

通常，为了在使用R的过程中更轻松和愉快，可以添加一些装备，我喜欢用独立的纯文本编辑器。Notepad++作为纯文本编辑器与NppToR组合，对于编写代码和推送到R控制台执行都是非常方便的。Notepad++在GitHub上的页面有时候连不上，可以试试Notepad++在SourceForge上的镜像和NppToR在SourceForge上的镜像。可以观看R的安装微课进一步熟悉。

控制台的上边的菜单栏里有很多的选项，自己去尝试点开看看都有哪些功能。比如尝试一下把控制台的字号改大一点。(注：这里是个示例，并不是这个4.2.0版有什么特殊的。大家安装最新的版本用于学习即可。)

如上图所示，在R控制台中，>后边输入新的命令，当>出现时，说明先前的命令已经执行完成，等待新命令的输入。命令输入完成之后，按Enter键命令就得到了执行，当命令执行完成后，出现新的>。
而+出现时，说明当前的命令输入不完整，这时候如果按Enter键将会不断出现+，直到命令输入完整后，按Enter键才执行。 当自认为命令输入完整后，依然出现+时，可能是什么地方漏掉了括号、引号等成对出现的符号，从而导致控制台认为输入不完整，应该细心检查。
命令执行完成后，有的会在屏幕上打印一些信息，这些信息根据不同的命令而有所不同。对于打印出的结果是向量的时候，每一行会显示本行第一个元素的索引。比如上图中1:100这个命令创建了一个包含1~100这100个数字的向量，这个命令运算结果并没有赋值给任何对象，默认就是将它print到屏幕上，因此我们看到print出来的结果。
当命令中出现错误的时候，错误信息会展示出来，另外还可能有警告信息。

R控制台里有一些快捷键可以使用：

通过help序列的函数，可以调出R内在的对象的文档。在安装的时候选取“HTML帮助”的话，这个帮助手册还有许多超链接到相关的内容。

? c
 
? t.test

?后边接函数名，用于查看其使用说明，比如这里? c 查看c函数的使用说明。? t.test查看t.test函数的使用手册，这等同于help(t.test)，

? "for"
 
? "+"

对于操作符以及for、if、function等具有句法意义的词，必须要加上引号，不然可能报错或者后边出现+号说明命令未输入完成。如果报错，就试试加上引号。

?? plot 

当查询的函数所在的包没有加载，可以用??来搜索，这等同于help.search(“plot”), help.search里边的引号是必须加上的。

有的函数的用法可以用example函数调出示例，比如example(plot)可以查看plot函数的示例，这里注意留意R控制台的提示和画图设备上的效果。
help.start()命令，可以调出一个页面，此页面上有连接到别的帮助页面。 其中“An Introduction to R”是很好的入门指南，而“Search Engine & Keywords”也很有用。 开卷有益，页面上的连接都可以点开看看。
RSiteSearch函数用于在R网站上搜索，比如RSiteSearch(“ggplot”)可搜索ggplot这个函数，注意，这里的引号不能省略。

在往后的学习或工作中遇到不理解的地方，即可使用这节的方法快速查看参考文档。

用好搜索引擎，很多时候我们所遇到的问题都是别人遇到过的，网上搜一下很容易就找到答案了。 也可以到StackOverflow上进行搜索或者提问。

另外一个重要的提问的地方是我们的QQ，每个学期会有一个QQ群，大家可以相互交流。

R的基本命令由表达式、赋值之一或者两者组成：单独的表达式作为命令的时候，表达式将被执行并且将结果打印到屏幕上（除非专门设置不打印），也就是调用了print函数，所获得的结果将丢失；而赋值命令将执行表达式，并且将所得的值传递给一个对象，但是结果不会自动打印（除非专门设置）。
R命令中的字母是区分大小写的，字符是区分全角和半角的，输入的时候要小心，避免输错。当命令输错的时候，会有报错信息，仔细阅读，看看错误的地方在哪里。

3 + 5 - 2 * 0 
##  [1] 8

这是一个表达式，作为命令时将被执行，然后结果print到屏幕上，然后这个计算结果没法调用了。

x <- 3 + 5 - 2 * 0    
x
##  [1] 8
x^2  
##  [1] 64
 
(y <- sin(pi*3/4))
##  [1] 0.7071068
y
##  [1] 0.7071068

表达式运算的结果被赋值给一个叫x的对象，不再将其值print到屏幕上，但是结果可以通过x用于后续的运算 。 如果要将运算结果的信息print的屏幕上，可以将x作为命令。 如果要同时复制且又把信息print到屏幕上，那么可以把命令用小括号括起来。

对于不同class的对象，print的信息是不一样的，有的print整个对象的值，比如这里对于一个向量，就是把向量所有值print出来；有的print的是一些特定的信息，这个在后边的学习中会进一步体会。

多个命令可以放在同一行，中间用分号;隔开，将依次执行：

x <- 1:10; y <- 2:5; x; y^2
##   [1]  1  2  3  4  5  6  7  8  9 10
##  [1]  4  9 16 25

多行命令要在同等条件下执行，使用花括号{ } 括起来：

{
  c(1,2,3)
  9:7
  5:7
}
##  [1] 5 6 7

花括号用于将一组命令组合在一起，可以看到只有最后一个命名的结果会被值被print出来了。

{
print(c(1,2,3))    
9:7
5:7
}
##  [1] 1 2 3
##  [1] 5 6 7

print不管放在哪里都会把结果print到屏幕。

R里赋值习惯使用←，而使用=和→也可以的，另外还能连续赋值。试试：

Y = 1:5
Y
##  [1] 1 2 3 4 5
1:5 -> Z
Z
##  [1] 1 2 3 4 5
X <- Y <- Z <- 1:10
X;Y;Z
##   [1]  1  2  3  4  5  6  7  8  9 10
##   [1]  1  2  3  4  5  6  7  8  9 10
##   [1]  1  2  3  4  5  6  7  8  9 10

除了用赋值运算符以外，还可以用assign函数，如下：

assign("object_name", expression)

这里的“object_name”是用引号引起来的,这里需要一个字符，这和不引的时候是有区别的，这就牵涉到R的数据类型（data type）的问题。

所有的计算机语言都通过变量（variable）取用内存中的数据，R中的变量不直接取用内存中的数据，而是取用专门数据结构——称为对象（object）。R里的一切都是对象，对象通过符号（symbols）或变量指及，R中发生的一切都是函数调用（function call）。函数(function)本身也是对象。 function也可以是运算符的形式，也可以省略（也就是直接在控制台输入对象或者其名称时，就会返回相应的结果，比如对象的值或者摘要）。这样在编程的时候实际上是处理对象之间的相互作用，称为面向对象的编程（Object Oriented Programming, OOP）。

每个对象都有模式（mode）和长度（length）这两个内在属性(Intrinsic attributes)。对象x模式用mode(x)查看，长度用length(x)查看。
模式(Mode)是基于对象的类型（Type）的。对象x的类型用typeof(x)函数查看，是对象在R语言内部的类型及储存模式。而mode()则是根据typeof()进行的互斥的归类。在使用者层面通常使用mode(), 而不去关注R语言层面更细分的typeof()。每个对象只属于一个mode。在typeof层面区分整数（integer）、实数（double），而mode层面都是数值型(numeric)。mode层面的函数（function）在typeof层面又区分为closure、builtin、special等类型。很显然，我们在后续在讨论对象的类型的时候，是在mode层面来说的。

x <- 1:10
x
##   [1]  1  2  3  4  5  6  7  8  9 10
mode(x)
##  [1] "numeric"
length(x)
##  [1] 10
 
y <- character(length=0)
y
##  character(0)
length(y)
##  [1] 0
mode(y)
##  [1] "character"
 
length(x) <- 20
x
##   [1]  1  2  3  4  5  6  7  8  9 10 NA NA NA NA NA NA NA NA NA NA
length(x) <- 5
x
##  [1] 1 2 3 4 5
mode(x) <- "character"
x
##  [1] "1" "2" "3" "4" "5"
 
typeof(x)
##  [1] "character"
typeof(x)  <- "integer"
##  Error in typeof(x) <- "integer" : 没有"typeof<-"这个函数
mode(x) <- "integer"
mode(x)
##  [1] "numeric"

每个对象都至少属于一个类别（class），class可以有多个，针对每种class定义了一些方法，也就是函数的执行形式。对于一些一般的函数，用于不同的类的对象效果不同，这是在定义类的时候就定义了这个函数的用法。 具有同样class的对象在一些操作上可以同等对待。 对于简单的向量，类别(class)就是其模式(mode)，元素全为整数的向量其class为integer，而mode依然是numeric。

x <- 1:10
class(x)
##  [1] "integer"
set.seed(2022); y <- sample(1:10)
y
##  [1]  4  3  6  7  9 10  2  8  5  1
 
fit <- lm(y~x)
class(fit)
##  [1] "lm"

print(x)
##   [1]  1  2  3  4  5  6  7  8  9 10
 
print(fit)
##  
##  Call:
##  lm(formula = y ~ x)
##  
##  Coefficients:
##  (Intercept)            x  
##       4.7333       0.1394  
##  

print函数对不同的class的对象效果不一样的。

x <- 1:10
class(x)
##  [1] "integer"
class(x)  <- "lm"
class(x)
##  [1] "lm"
str(x)
##   'lm' int [1:10] 1 2 3 4 5 6 7 8 9 10
print(x)
##  错误: $ operator is invalid for atomic vectors
x
##  错误: $ operator is invalid for atomic vectors

改变对象的class并没有改变对象的结构，print按照class标签进行而数据结构不对，就不能够正确print。

X <- data.frame(A=1:10, B=y)
mode(X)
##  [1] "list"
class(X) 
##  [1] "data.frame"

数据框的mode是列表，而class是数据框。

一些对象还具有非内在的附加属性(attributes)，也就是给对象加上的一些标签，class也是一种attribute。通过attributes函数可以查看或添加，通过attr函数可以增加特定的attributes。通过attributes和attr查看和改变的只是属性的标签，这个标签申明的属性可以不是对象本身所具备或者适用的。正常情况下对象具有相应的属性才会有相应的标签。

x <- 1:10
attributes(x)
##  NULL
attr(x, "dim")
##  NULL

对于简单的向量，没有其它的属性，class用class()函数查看。

attr(x, "dim") <- c(2, 5)
x
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]    1    3    5    7    9
##  [2,]    2    4    6    8   10
class(x)
##  [1] "matrix" "array" 
attributes(x)  <- NULL
x
##   [1]  1  2  3  4  5  6  7  8  9 10
class(x)
##  [1] "integer"

添加了dim这个属性，dim即dimension，这里指定x为2行5列。增加dim属性之后，x的class也变成了matrix，这时候，适合于matrix的方法将适合于x 。而去掉了sttributes，x又变回了简单的向量。

X <- data.frame(A = 1:10, B=letters[1:10])
mode(X)
##  [1] "list"
class(X)
##  [1] "data.frame"
attributes(X)
##  $names
##  [1] "A" "B"
##  
##  $class
##  [1] "data.frame"
##  
##  $row.names
##   [1]  1  2  3  4  5  6  7  8  9 10
 
attributes(X) <- NULL
X
##  [[1]]
##   [1]  1  2  3  4  5  6  7  8  9 10
##  
##  [[2]]
##   [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
 
class(X)
##  [1] "list"

可以看到，数据框的mode是list，而其attributes包括names、class、row.names这些，如果去掉了这些attributes，就变成了一般的list。

(x <- 1:10)
attributes(x) <- list(names="A", row.names=c("B", "C"), class="data.frame")
mode(x)
##  [1] "numeric"
class(x)
##  [1] "data.frame"
 
print(x) 
##  > x         
##       A   NA   NA   NA   NA   NA   NA   NA   NA   NA
##  B    1    2    3    4    5    6    7    8    9   10
##  C <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA>
##  Warning message:
##  In format.data.frame(if (omit) x[seq_len(n0), , drop = FALSE] else x,  :
##    破损的数据框：縮短列的长度或用NA来填充空白

而如果强行的给一个向量data.frame的这些attributes，那么并不会改变它的mode，而其class发生了改变，这也改变了print的效果。

对象都有内部结构structure，通过str函数查看

x <- 1:10
str(x)   
##   int [1:10] 1 2 3 4 5 6 7 8 9 10
 
X <- data.frame(A = 1:10, B=letters[1:10])
str(X)
##  'data.frame':   10 obs. of  2 variables:
##   $ A: int  1 2 3 4 5 6 7 8 9 10
##   $ B: chr  "a" "b" "c" "d" ...

需要注意，structure函数是用来根据附加的属性来结构化数据的，并不是用来查看数据的结构的。

x <- 1:10
y <- structure(x, dim=c(2, 5))
y
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]    1    3    5    7    9
##  [2,]    2    4    6    8   10
str(y)
##    int [1:2, 1:5] 1 2 3 4 5 6 7 8 9 10
 
z <- str(x)
##   int [1:10] 1 2 3 4 5 6 7 8 9 10
str(z)
##   NULL

str函数把结果打印到屏幕上，而不会返回一个值，所以我们看到并没有值赋值给z。

R的值类型（value type）有数值(Numeric)、字符(Character) 、复数（Complex）逻辑（Logical） 等。R里并没有标量（Scalar），而单一的值被看作长度为1的向量。向量是原子型的，向量的类型就是其中值的类型。使用mode查看向量中的值类型。不同类型的值能够进行的运算或者操作是不一样的，比如字符型的就没法求和，也没法开平方。

(x <- c(1, 3, 5))
##  [1] 1 3 5
mode(x)
##  [1] "numeric"
is.numeric(x)
##  [1] TRUE
sum(x)
##  [1] 9

用is.numeric来判断x是否为数值型，同样可以使用is.character、is.complex、is.logical等判断值是否是字符、复数、逻辑型。
x是数值型的，可以进行针对数值型的运算，这里x所有元素的加和,类似的mean、median、var、sd函数秋x的均值、中位数、方差、标准差。

(y <- as.character(x))
##  [1] "1" "3" "5"
sum(y)
##  Error in sum(y) : 'type'(character)参数不对

字符型的值都是带引号的。使用as.character将向量x变为数值型，原先x并没有改变，而是新产生一个向量，如果不赋值给x，就不会给变x的值。同样也可以使用as.numeric、as.complex、as.logical等等将其它类型的值转换为数值、复数、逻辑型的值。
字符型的向量不能使用针对数值型的函数，因为没有办法对字符型的向量求和（比如）。

(X <- c("1", "0.001", "A", NA)) 
##  [1] "1"     "0.001" "A"     NA     
as.numeric(X) 
##  [1] 1.000 0.001    NA    NA
##  Warning message:
##  强制改变过程中产生了NA 
as.complex(X) 
##  [1] 1.000+0i 0.001+0i       NA       NA
##  Warning message:
##  强制改变过程中产生了NA 

字符型的向量转为数值型的时候，如果字符不是数字的形式，那么没有对应的数字，转化的时候就会产生NA。

(z <- c(-1, 0, 1, 0.0003, NA))
##  [1] -1.0000  0.0000  1.0000  0.0003      NA
(Z <- as.logical(z))
##  [1]  TRUE FALSE  TRUE  TRUE    NA
as.numeric(Z)
##  [1]  1  0  1  1 NA
as.character(Z)
##  [1] "TRUE"  "FALSE" "TRUE"  "TRUE"  NA     

在数值转化为逻辑型的时候，0是FALSE，非0都是TRUE。 逻辑型只有TRUE和FALSE两个值。逻辑值也存在NA值。转化为数值时，变成0和1，NA依然是NA。 转换成字符型则加上了引号，NA除外。

sqrt(-1)
##  [1] NaN
##  Warning message:
##  In sqrt(-1) : 产生了NaNs
sqrt(as.complex(-1))
##  [1] 0+1i
sqrt(-1 + 0i)
##  [1] 0+1i
1 + 2
##  [1] 3
1 + "2"
##  Error in 1 + "2" : 二进列运算符中有非数值参数
TRUE + 0
##  [1] 1
TRUE & 1i
##  [1] TRUE
TRUE & "1"
##  Error in TRUE & "1" : 此运算只适用于数值，逻辑值或复数值种类

数值型的-1是没法开根号的，转成复数型的，就可以开根号了。+ xi （x为数值）这样的形式，也能得到复数型的值。 数值型之间可以相加等数学运算，字符型的不能进行数学运算。逻辑型的可以和数值型进行数学运算，逻辑型的可以和数值型、复数型的进行逻辑运算，字符型的不能进行逻辑运算。这里不一一列举，如果有不能进行的运算，要留意报错信息。

(x <- c(TRUE, FALSE, 0))
##  [1] 1 0 0
mode(x)
##  [1] "numeric"
 
(y <- c(TRUE, FALSE, 0, 10 + 0i))
##  [1]  1+0i  0+0i  0+0i 10+0i
mode(y)
##  [1] "complex"
 
(z <- c(TRUE, FALSE, 0, 10 + 0i, "A"))
##  [1] "TRUE"  "FALSE" "0"     "10+0i" "A"
mode(z)
##  [1] "character"

在使用c()函数创建向量的时候，如果将不同类型的值放在一起，会有一个转化，这种优先级是这样的：字符型 > 复数型 > 数值型 > 逻辑型 。一个向量只有一种类型，在列表读入的时候，也会遇到这种同一列里可能有几种类型的情况，这时候也会有转化，比如一列数字里如果具有含有标点的字符，这时候就会被当作字符型的读入。 而在老版本的R中，默认情情况下会将字符转为因子型，这样如果直接使用as.numeric转换成数值型，就会发生错误，需要先转成字符型再转成数字型。现在的新版本R中不存在这个问题了，大家在一些老机器上如果遇到一些旧版本的R需要留意。

除了mode和class以外，对象的类型还有typeof和storage.mode两个函数返回的值，typeof函数和mode函数的类型大都具有相同的名称，除了：typeof的integer和double在mode里都是numeric；typeof的special和builtin在mode里是function；typeof里的symbol在mode里叫name；typeof的language在mode里是(或者call。storage.mode通常和mode的值是一样的，而是这两个都是基于typeof的。typeof是R内部的type，storage.mode是mode初级版本，更高效，也更接近于底层，比如storage.mode的integer和double和typeof是一样的。

typeof 
##  function (x) 
##  .Internal(typeof(x))
##  <bytecode: 0x00000257fac88030>
##  <environment: namespace:base>

可以看到typeof函数是一个内部函数，具体怎么实现的就不是我们这样的运用层面需要去弄清楚的了。

mode
##  function (x) 
##  {
##      if (is.expression(x)) 
##          return("expression")
##      if (is.call(x)) 
##          return(switch(deparse(x[[1L]])[1L], `(` = "(", "call"))
##      if (is.name(x)) 
##          "name"
##      else switch(tx <- typeof(x), double = , integer = "numeric", 
##          closure = , builtin = , special = "function", tx)
##  }
##  <bytecode: 0x00000257fabe4c38>
##  <environment: namespace:base>

可以看到mode是基于typeof的。

storage.mode
##  function (x) 
##  switch(tx <- typeof(x), closure = , builtin = , special = "function", 
##      tx)
##  <bytecode: 0x00000257fae5b978>
##  <environment: namespace:base>

storage.mode 函数也是基于typeof函数返回的结果的。

NA意为Not Available，表示变量值未知。数据中包含缺失的值的时候，R将之设置为NA，比如将一个不是数字样式的字符强行转为数值型的，没有与之对应的数字，得到NA。NA不等于任何值。NA默认是一个逻辑型的。

as.numeric(c("3.14", "pi"))
##  [1] 3.14   NA
##  Warning message:
##  强制改变过程中产生了NA 
mode(NA)
##  [1] "logical"
1==NA
##  [1] NA
TRUE & NA
##  [1] NA
TRUE | NA
##  [1] TRUE
FALSE | NA
##  [1] NA
is.na(NA)
##  [1] TRUE
1 + NA
##  [1] NA

通过is.na来判断一个值是否是NA，NA和数值型的进行运算，得到的还是NA，需要留意的是TRUE | NA得到的结果是TRUE。

NaN意为Not a Number，表示未定义的数学运算结果。

Inf - Inf
##  [1] NaN
0/0
##  [1] NaN
mode(NaN)
##  [1] "numeric"
is.na(NaN)
##  [1] TRUE

NaN是NA的一种特殊形式。

NULL是R里的一个特殊对象，其值为NULL，由NULL指向，其模式为NULL， 用于表示一个对象或者元素是不存在的。

NULL
##  NULL
NULL <- 0             
##  Error in NULL <- 0 : (do_set)赋值公式左手不对
is.null(NULL)
##  [1] TRUE
is.na(NULL)
##  logical(0)
c(1, 2, NULL)
##  [1] 1 2
c(1, 2, NA)
##  [1]  1  2 NA

没法给NULL赋值，NULL是一个特殊的保留的符号。

计算结果超过R数字的极限时，结果为Inf，意为Infinity。通常因为除以0而产生。

10^1000
##  [1] Inf
1/0
##  [1] Inf
-1/0
##  [1] -Inf

R的对象有许多类型，其中向量（vector）称为原子型的结构，因为同一个向量中的所有元素都只能是一个模式。向量中的元素可以是数值型(numeric)、复数型(complex)、逻辑型(logical)、字符型(character)以及原始型（raw）。
另外R中的对象类型还有因子(factor)、数据框(data frame)、矩阵(array)、列表(list)、函数(function)、表达式（expression）、调用(call)、S3、S4等等的。

向量（vector）可以看作一系列装着数据的连续的小格，可以通过小格的序号来取出数据。可以通过c来创建。seq等函数的结果也是向量。
向量是原子型的结构，同一个向量中所有的元素都只能是一个类型，向量的类型就是其元素的类型。 而每个元素单独拿出来，实际上就是一个长度为1的向量。 给向量元素加上名称之后，向量可当字典用。

(x <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) 
##   [1]  1  2  3  4  5  6  7  8  9 10
str(x)
##   num [1:10] 1 2 3 4 5 6 7 8 9 10
mode(x)
##  [1] "numeric"
class(x)
##  [1] "numeric"
attributes(x)
##  NULL
 
names(x) <- LETTERS[1:10]    
x
##   A  B  C  D  E  F  G  H  I  J 
##   1  2  3  4  5  6  7  8  9 10 
str(x)
##   Named num [1:10] 1 2 3 4 5 6 7 8 9 10
##   - attr(*, "names")= chr [1:10] "A" "B" "C" "D" ...
mode(x)
##  [1] "numeric"
class(x)
##  [1] "numeric"
 
x["A"]
##  A 
##  1 
x[c("C", "D", "B", "A")]
##  C D B A 
##  3 4 2 1 
 
is.vector(x)
##  [1] TRUE
is.numeric(x)
##  [1] TRUE
 
(y <- as.character(x))
##   [1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"
str(y)
##   chr [1:10] "1" "2" "3" "4" "5" "6" "7" "8" "9" "10"
mode(y)
##  [1] "character"
class(y)
##  [1] "character"
 
(x <- c(c("cat", "dog"),  "mouse", c("human")))
##  [1] "cat"   "dog"   "mouse" "human"

根据数值的类型，R里有六种基本的向量类型：字符型(character)、逻辑型(logical)、整数型(integer)、实数型(double)、复数型(complex)、原始型(raw)。而整数型和实数型又都是数值型（numeric）。用is序列函数（is.character、is.numeric、is.integer、is.double、is.complex、is.raw）来判断是否是相应的类型，而用as系列函数（as.character、as.numeric、as.integer、as.double、as.complex、as.raw）来在这些类型间进行转换，转换时需要注意是否确实可以转换。

矩阵（matrix）是按行和列排列的一组数值。 给向量加上dim()附加属性就可以得到矩阵。通过matrix函数创建。

(x  <- matrix(1:10, nrow=2))
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]    1    3    5    7    9
##  [2,]    2    4    6    8   10
mode(x)
##  [1] "numeric"
class(x)
##  [1] "matrix" "array" 
attributes(x)
##  $dim
##  [1] 2 5
str(x)
##   int [1:2, 1:5] 1 2 3 4 5 6 7 8 9 10
length(x)
##  [1] 10
nrow(x)
##  [1] 2
ncol(x)                             
##  [1] 5

可以使用matrix()来创建矩阵，矩阵的mode还是numeric，本质上是向量。其class为matrix和array ，具有一般向量所不具有的特征。

x <- 1:10
dim(x) <- c(2, 5)
x
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]    1    3    5    7    9
##  [2,]    2    4    6    8   10
 
str(x)
##   int [1:2, 1:5] 1 2 3 4 5 6 7 8 9 10
rownames(x) <- letters[1:2]
colnames(x) <- LETTERS[1:5]
x
##    A B C D  E
##  a 1 3 5 7  9
##  b 2 4 6 8 10
attributes(x)
##  $dim
##  [1] 2 5
##  
##  $dimnames
##  $dimnames[[1]]
##  [1] "a" "b"
##  
##  $dimnames[[2]]
##  [1] "A" "B" "C" "D" "E"

通过给一个向量dim个attributes也可以创建矩阵。通过dim函数来设置dim附加属性，也可以用attr(x, “dim”) ← c(2, 5)，另外，有dimnames这一attributes，可以通过rownames和colnames来获取或者添加。 。

(x <- matrix(1:10, nrow=2, byrow=TRUE))
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]    1    2    3    4    5
##  [2,]    6    7    8    9   10
attributes(x) <- NULL
x
##   [1]  1  6  2  7  3  8  4  9  5 10

去掉矩阵的attributes之后，矩阵变成了一般的向量，还是先按列排，第一列然后第二列，以此类推。使用matrix函数创建矩阵的时候，byrow=TRUE使得元素的排列先排行再排列，在创建matrix的时候byrow=TRUE只是在创建的时候起效，创建之后这一信息并未保存在对象信息中。 # 显然，

矩阵可以看作二维的数组(array) ，因此推广一下理解更高维数组。在平时的工作中很少用到。

(x <- array(1:10, c(2, 5)))
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]    1    3    5    7    9
##  [2,]    2    4    6    8   10
 
(x <- array(1:24, c(2, 3, 4)))
##  , , 1
##  
##       [,1] [,2] [,3]
##  [1,]    1    3    5
##  [2,]    2    4    6
##  
##  , , 2
##  
##       [,1] [,2] [,3]
##  [1,]    7    9   11
##  [2,]    8   10   12
##  
##  , , 3
##  
##       [,1] [,2] [,3]
##  [1,]   13   15   17
##  [2,]   14   16   18
##  
##  , , 4
##  
##       [,1] [,2] [,3]
##  [1,]   19   21   23
##  [2,]   20   22   24
 
(x <- array(1:40, c(2, 5, 2, 2)))
##  , , 1, 1
##  
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]    1    3    5    7    9
##  [2,]    2    4    6    8   10
##  
##  , , 2, 1
##  
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]   11   13   15   17   19
##  [2,]   12   14   16   18   20
##  
##  , , 1, 2
##  
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]   21   23   25   27   29
##  [2,]   22   24   26   28   30
##  
##  , , 2, 2
##  
##       [,1] [,2] [,3] [,4] [,5]
##  [1,]   31   33   35   37   39
##  [2,]   32   34   36   38   40
 
mode(x) 
##  [1] "numeric"
class(x)
##  [1] "array"
attributes(x)
##  $dim
##  [1] 2 5 2 2
str(x)
##   int [1:2, 1:5, 1:2, 1:2] 1 2 3 4 5 6 7 8 9 10 ...

列表(list) 可以看作一般化的向量，只是其元素可以是不同类型，甚至是list。

(x <- list(A=1:3, B=letters[1:10]) )
##  $A
##  [1] 1 2 3
##  
##  $B
##   [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
str(x)
##  List of 2
##   $ A: int [1:3] 1 2 3
##   $ B: chr [1:10] "a" "b" "c" "d" ...
mode(x)
##  [1] "list"
class(x)
##  [1] "list"
attributes(x)
##  $names
##  [1] "A" "B"
attributes(x) <- NULL
x
##  [[1]]
##  [1] 1 2 3
##  
##  [[2]]
##   [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"

数据框(data frame)由一系列等长/等行数的向量、因子、及/或矩阵组成，是一种特殊的list。数据框通常具有names和row.names两个附加属性，即为列名和行名。数据库是R里常用的数据结构类型。 可以用data.frame函数来创建，大的表格通常从硬盘中的表格文件读取。

(x <- data.frame(A=1:10, B=letters[1:10]))
##      A B
##  1   1 a
##  2   2 b
##  3   3 c
##  4   4 d
##  5   5 e
##  6   6 f
##  7   7 g
##  8   8 h
##  9   9 i
##  10 10 j
str(x)
##  'data.frame':   10 obs. of  2 variables:
##   $ A: int  1 2 3 4 5 6 7 8 9 10
##   $ B: chr  "a" "b" "c" "d" ...
mode(x)
##  [1] "list"
class(x)
##  [1] "data.frame"
attributes(x)
##  $names
##  [1] "A" "B"
##  
##  $class
##  [1] "data.frame"
##  
##  $row.names
##   [1]  1  2  3  4  5  6  7  8  9 10
is.list(x)
##  [1] TRUE
is.data.frame(x)
##  [1] TRUE
(y <- unclass(x))
##  $A
##   [1]  1  2  3  4  5  6  7  8  9 10
##  
##  $B
##   [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
##  
##  attr(,"row.names")
##   [1]  1  2  3  4  5  6  7  8  9 10
str(y)
##  List of 2
##   $ A: int [1:10] 1 2 3 4 5 6 7 8 9 10
##   $ B: chr [1:10] "a" "b" "c" "d" ...
##   - attr(*, "row.names")= int [1:10] 1 2 3 4 5 6 7 8 9 10
mode(y)
##  [1] "list"
attributes(y)         
##  $names
##  [1] "A" "B"
##  
##  $row.names
##   [1]  1  2  3  4  5  6  7  8  9 10

将一系列代码放在一起，就成为函数(function)，函数可以预设参数。将函数f的名称f作为命令得到的是f的内容，而要调用函数f必须要要用f()的形式，需要指定的参数放在括号里。

f <- function(){
    print("A")
    print("Z")
    1+2
}
 
f
##  function(){
##      print("A")
##      print("Z")
##      1+2
##  }
 
f()
##  [1] "A"
##  [1] "Z"
##  [1] 3

函数里可以设置参数，参数可以在函数中的代码里引用：

kf <- function(X) sqrt(X)
kf()
##  Error in kf() : 缺少参数"X",也没有缺省值
kf(X=4)
##  [1] 2

可以给定一个默认值，这样在调用函数的时候如果不给指定参数的值，函数就采用默认值。

kf <- function(X=4) sqrt(X)
kf()
##  [1] 2
kf(X=4)
##  [1] 2
kf(X=9)
##  [1] 3

可以设定很多的参数，在函数中采用：

f <- function(x="A", y="B", a=1, b=2){
    print(x)
    print(y)
    a+b
}
 
f()
##  [1] "A"
##  [1] "B"
##  [1] 3
 
f("a", "b", 3, 5)
##  [1] "a"
##  [1] "b"
##  [1] 8
 
f(b=10, x="OK")
##  [1] "OK"
##  [1] "B"
##  [1] 11

函数里的参数可以按顺序写，也可以不安顺序但是指明谁是谁。

R的函数分为向量化的和非向量化的，向量化的函数对参数中的向量逐个元素地进行运算，逐一返回运算结果组成新的向量。运算符也是一种函数，只是用法和一般的函数有别。在使用函数时需要区分向量化的和非向量化的区别。 一般来说，常用的一些函数用习惯了就知道怎么用了。

函数默认返回最后一个表达式的值，如果需要指定返回的值，使用return()函数。

f <- function(x=3, y=4){
    X <- x^2 
    Y <- y^2
    Y
    Z <- X + Y
    z <- Z^(1/2)
}
 
f()

当函数中没有return语句指定返回值的时候，如果最后一个命令也不是对象名时，那么函数将不会返回值。

f <- function(x=3, y=4){
    X <- x^2 
    Y <- y^2
    Z <- X + Y
    Z
    z <- Z^(1/2)
    z
}
 
f()
##  [1] 5

当函数中没有return语句指定返回值的时候，如果最后一个命令是对象名时，那么函数将返此对象的值。

f <- function(x=3, y=4){
    X <- x^2 
    Y <- y^2
    Z <- X + Y
    return(Z)
    z <- Z^(1/2)
    z
}
 
f()
##  [1] 25
 
f <- function(x=3, y=4){
    X <- x^2 
    Y <- y^2
    Z <- X + Y
    return(Z)
    z <- Z^(1/2)
    return(z)
}
 
f()
##  [1] 25

当函数中有return语句指定返回值的时候，将返回第一个return返回的值。

除了上边提到的比较基本的类型以外，还有一些在基本的类型上增加了不同的class和attributes的对象，这些对象有不同的用途。

因子(factor) 是一个特殊的复合对象，可以看做特殊的向量，只能含有特定的值，用于存储分类数据。因子的模式是整数型的向量，具有有levels附加属性和factor class。 factor类型让因子与常规的整数型向量不同，而levels定义允许的值。用factor函数创建因子，将一个普通的向量转为因子,可以通过levels参数来改变levels及其顺序。

x <- c("家畜", "家畜", "家畜", "家禽", "家禽")
(y <- factor(x))
##  [1] 家畜 家畜 家畜 家禽 家禽
##  Levels: 家畜 家禽
mode(y)
##  [1] "numeric"
class(y)
##  [1] "factor"
attributes(y)
##  $levels
##  [1] "家畜" "家禽"
##  
##  $class
##  [1] "factor"
##  
str(y)
##   Factor w/ 2 levels "家畜","家禽": 1 1 1 2 2
as.numeric(y) 
##  [1] 1 1 1 2 2
as.character(y)
##  [1] "家畜" "家畜" "家畜" "家禽" "家禽"

y[6] <- "家禽"
y[7] <- "野鸟"
##  Warning message:
##  In `[<-.factor`(`*tmp*`, 7, value = "野鸟") : 因子层次有错，产生了NA
c(factor(c("a", "b")), factor(c("c", "d")))
##  [1] a b c d
##  Levels: a b c d

不能增加levels里没有的元素，野鸟并不在y的levels之中，因此这里无法将y中的值换成野鸟，因而产生NA。可以用c将两个向量合并，levels也合并了

y <- factor(x, levels=c("家畜", "家禽"))
order(y)
##  [1] 1 2 3 4 5
sort(y)
##  [1] 家畜 家畜 家畜 家禽 家禽
##  Levels: 家畜 家禽
z <- factor(x, levels=c("家禽", "家畜"))
order(z)
##  [1] 4 5 1 2 3
sort(z)
##  [1] 家禽 家禽 家畜 家畜 家畜
##  Levels: 家禽 家畜
 
table(x)
##  x
##  家畜 家禽 
##     3    2 
table(factor(x, levels=c("家禽", "家畜"))) 
##  
##  家禽 家畜 
##     2    3 
table(factor(x, levels=c("家禽", "家畜", "野鸟")))
##  
##  家禽 家畜 野鸟 
##     2    3    0 

(z <- factor(c(1, 2,  4, 5, 7))) 
##  [1] 1 2 4 5 7
##  Levels: 1 2 4 5 7
as.numeric(z)
##  [1] 1 2 3 4 5
as.character(z)
##  [1] "1" "2" "4" "5" "7"
as.numeric(as.character(z)) 
##  [1] 1 2 4 5 7
 
attr(z, "class") <- "numeric"
as.character(z) 
##  [1] "1" "2" "3" "4" "5"

因子的本质是整数型的向量，只是因子的每个整数都对应着一个level，而level是字符型的。因此，如果把一个数值型向量转成因子，再由因子转回来的时候就要注意，可能得到的数字全变了。 如果强行将class改成numeric，这时候转换为character的时候就不按factor来了。

(X <- c(4, 6, 8))
##  [1] 4 6 8
str(X)
##   num [1:3] 4 6 8
(Y <- as.factor(X))
##  [1] 4 6 8
##  Levels: 4 6 8
str(Y)
##   Factor w/ 3 levels "4","6","8": 1 2 3
mode(Y)
##  [1] "numeric"
(Z <- as.numeric(Y))
##  [1] 1 2 3
str(Z) 
##   num [1:3] 1 2 3
(U <- as.character(Y))
##  [1] "4" "6" "8"
str(U) 
##   chr [1:3] "4" "6" "8"
(V <- as.numeric(U))
##  [1] 4 6 8
str(V)
##   num [1:3] 4 6 8
(W <- as.numeric(as.character(Y)))
##  [1] 4 6 8

在先前的一些版本的R中，默认情况下，在读入表格到data.frame或者创建data.frame的时候，会默认将字符型的向量转成因子，因此，当读数的数字一列中参杂字符的时候，原本应该当作数字读入的数据可能被转成了因子。 这时候如果要转成数值型的，就需要留意，以免出错。

Sys.time()得到当前的时间，得到的对象本质上还是数值型的，其class是“POSIXct” “POSIXt”。

(x <- Sys.time())
##  [1] "2022-12-05 00:54:00 CST"
mode(x)
##  [1] "numeric"
class(x)
##  [1] "POSIXct" "POSIXt"
 
(x <- Sys.Date()) 
##  [1] "2022-12-05"
mode(x)                
##  [1] "numeric"
class(x)
##  [1] "Date"
 
as.Date("1949-10-01")
##  [1] "1949-10-01"
Sys.Date() - as.Date("1949-10-01")
##  Time difference of 26728 days
 
as.Date("2049-10-01") - Sys.Date()
##  [1] "2022-12-10"
 
as.Date("25/10/2022", format="%d/%d/%Y")
 
(X <- Sys.Date()) 
##  [1] "2022-12-05"
(Y <- as.numeric(x))        
##  [1] 19331
X - Y
##  [1] "1970-01-01"
(Z <- as.Date(Y, origin="1970-01-01"))
##  [1] "2022-12-05"

默认情况下转化为数字是从“1970-01-01”算第一天的。从数字转为日期的时候，一定要正确设置origin。从EXCEL读入日期数据的时候，得到的是数值，这时候就需要转换成日期，需要注意的是Windows 下EXCEL日期origin=“1899-12-30”， Mac的EXCEL的为“1904-01-01”，如果不明确文件来源的时候，转换之后需要核对一下是否正确。

table将统计因子中levels各个分类的数目。如果给定的是可以转化为因子的向量，那么table将之转化为因子并作出统计。

set.seed(2022)
(x <- sample(LETTERS[1:5], 10, replace=TRUE))
##  [1] "D" "C" "C" "D" "D" "C" "A" "E" "B" "E"
(y <- table(x))
##  x
##  A B C D E 
##  1 1 3 3 2 
mode(y)
##  [1] "numeric"
class(y)
##  [1] "table"
str(y)
##   'table' int [1:5(1d)] 1 1 3 3 2
##   - attr(*, "dimnames")=List of 1
##    ..$ x: chr [1:5] "A" "B" "C" "D" ...
y[x]
##  x
##  D C C D D C A E B E 
##  3 3 3 3 3 3 1 2 1 2 

前边已经说到了对象取子集，取出对象的部分元素可以通过[、[[、$来，同时也可以对这部分进行赋值从而将其替换。基本用法如下：

x[i]
x[i, j, ... , drop = TRUE]
x[[i, exact = TRUE]]
x[[i, j, ..., exact = TRUE]]
x$name
getElement(object, name)

取出对象x的部分，取子集不改变x，其中，向量i、j、……代表行、列、……（第三维、第四维、……），其取值可以是如下三种值：
1. 使用位置向量，向量前边加“-“表示不包括
2. 使用等长的逻辑向量，TRUE对应需要取出的
3. 使用元素名称向量，当元素无名称时就不好用了

x[i] <- value
x[i, j, ...] <- value
x[[i]] <- value
x$name <- value

可以通过赋值改变相应的部分，这时候会改变x。

用如下命令了解更多关于对象部分提取或替换 (Extract or Replace Parts of an Object)的用法：

 ? "["

使用索引序号(index)来取出向量的部分，依次按照向量中的序号取出：

X <- c(1, 3, 5, 7, 9, 2, 4, 6,8, 10)
names(X) <- LETTERS[1:10]
X
##   A  B  C  D  E  F  G  H  I  J 
##   1  3  5  7  9  2  4  6  8 10
X[]
##   A  B  C  D  E  F  G  H  I  J 
##   1  3  5  7  9  2  4  6  8 10 
X[0]
##   named numeric(0)
X[1:4]
##  A B C D 
##  1 3 5 7 
X[c(1, 2, 4, 3, 3)]
##   A B D C C 
##   1 3 7 5 5 
X[-c(1:4)]
##   E  F  G  H  I  J 
##   9  2  4  6  8 10 
X[-1:4]
##  Error in X[-1:4] : 只有负下标里才能有零
X[c(1,3,5,8,6,5,4,2,50)]
##     A    C    E    H    F    E    D    B <NA> 
##     1    5    9    6    2    9    7    3   NA 
X[-c(1,3,5,8,6,5,4,2,50)]
##   G  I  J 
##   4  8 10

保持空的时候得到的就是对象本身。index是从1开始的，给0就得到长度为0向量。

X[1, 2, 4]
##  Error in X[1, 2, 4] : 量度数目不对

这里的索引需要给一个向量，如上这样就是给三个向量了，对于向量取子集来说就会报错了。这是比较常见的一种错误，需要注意。

根据索引序号来取子集可以用于对向量进行排序：

X[order(X)]
##   A  F  B  G  C  H  D  I  E  J 
##   1  2  3  4  5  6  7  8  9 10 
X[order(X, decreasing=TRUE)]
##   J  E  I  D  H  C  G  B  F  A 
##  10  9  8  7  6  5  4  3  2  1 

order这个函数得到的是对给定向量进行排序时取子集的序号的向量。

Y <- c(3, 5, 1, 7)
order(Y)
##  [1] 3 1 2 4
order(Y, decreasing = TRUE)
##  [1] 4 2 1 3

对Y进行升序排序时，放在第一位的是原来的第3为，放在第二位的是原来的第2位，依次类推。默认是升序排列，降序排序需要加上参数 decreasing = TRUE

使用逻辑向量来取，对应TRUE的位置的元素被取出：

X > 5
##      A     B     C     D     E     F     G     H     I     J 
##  FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE  TRUE  TRUE  TRUE 
X[X > 5]
##   D  E  H  I  J 
##   7  9  6  8 10

使用元素名称向量取子集，对应名称被取出：

X[c("B", "F", "J")]
##   B  F  J 
##   3  2 10 

这样使得向量可以被当做字典来用。

取子集的时候赋值，可以改变向量中的部分元素：

X <- 1:10
names(X) <- LETTERS[1:10]
X
##   A  B  C  D  E  F  G  H  I  J 
##   1  2  3  4  5  6  7  8  9 10 
 
X[5]  <- 1000
X
##     A    B    C    D    E    F    G    H    I    J 
##     1    2    3    4 1000    6    7    8    9   10 
 
X[1:5] <- 11:15
X
##   A  B  C  D  E  F  G  H  I  J 
##  11 12 13 14 15  6  7  8  9 10 
 
X[c("B", "C")] <- c("b", "c", "d")
##  Warning message:
##  In X[c("B", "C")] <- c("b", "c", "d") : 被替换的项目不是替换值长度的倍数
 
X
##     A    B    C    D    E    F    G    H    I    J 
##  "11"  "b"  "c" "14" "15"  "6"  "7"  "8"  "9" "10"

矩阵是二维的，可以通过行列的序号来取：

M <- matrix(1:20, ncol=5, byrow=TRUE, dimnames=list(letters[1:4], LETTERS[1:5]))
M
##     A  B  C  D  E
##  a  1  2  3  4  5
##  b  6  7  8  9 10
##  c 11 12 13 14 15
##  d 16 17 18 19 20
 
M[1:2, c(1, 3, 5)]
##    A C  E
##  a 1 3  5
##  b 6 8 10
 
M[4, 4]
##  [1] 19

可以通过行列的名称来取:

M[c("a", "c"), c("D", "E")]
##     D  E
##  a  4  5
##  c 14 15

可以通过行列等长的逻辑向量来取：

M[c(TRUE, FALSE, TRUE, FALSE), c(FALSE, TRUE, TRUE, FALSE, FALSE)]
##     B  C
##  a  2  3
##  c 12 13
 
M[rownames(M) %in% c("a", "B", "c"), colnames(M) %in% c("a", "B", "c", "D")]
##     B  D
##  a  2  4
##  c 12 14

同样可以通过赋值来对其部分进行替换：

M[1:2, c(1, 3, 5)] <- 0
M
##     A  B  C  D  E
##  a  0  2  0  4  0
##  b  0  7  0  9  0
##  c 11 12 13 14 15
##  d 16 17 18 19 20
 
M[1:2, 1:2] <- matrix(101:104, ncol=2, byrow=TRUE)
M
##      A   B  C  D  E
##  a 101 102  0  4  0
##  b 103 104  0  9  0
##  c  11  12 13 14 15
##  d  16  17 18 19 20
 
M[3:4, 3:4] <- NA
M
##      A   B  C  D  E
##  a 101 102  0  4  0
##  b 103 104  0  9  0
##  c  11  12 NA NA 15
##  d  16  17 NA NA 20

矩阵也可以本质上是向量，可以用一维的方式来进行取值和替换，这时候序号是像第一行然后第二行这样依次排序：

M[is.na(M)] <- 50
M
##      A   B  C  D  E
##  a 101 102  0  4  0
##  b 103 104  0  9  0
##  c  11  12 50 50 15
##  d  16  17 50 50 20
 
which(M > 50)
[1]  1  2  5  6 11 12 15 16

比较实用的情况就是对NA值进行替换。

列表当做一维的来看，可以用方括号[]取子集，也可以用$或者[[]]取出其中的元素。

Y <- list(A=1:3, B=letters[1:5], C=LETTERS[6:10])
Y
##  $A
##  [1] 1 2 3
##  
##  $B
##  [1] "a" "b" "c" "d" "e"
##  
##  $C
##  [1] "F" "G" "H" "I" "J"
 
Y[1]
##  $A
##  [1] 1 2 3
 
Y[c("A","B")]
##  $A
##  [1] 1 2 3
##  
##  $B
##  [1] "a" "b" "c" "d" "e"
 
Y[1:2]
##  $A
##  [1] 1 2 3
##  
##  $B
##  [1] "a" "b" "c" "d" "e"

可以使用$加元素的名称来取出列表的元素，$后边时元素的名称:

Y$A
##  [1] 1 2 3
 
Y$B
##  [1] "a" "b" "c" "d" "e"
 
Y$A[2]
##  [1] 2
 
Y$B[2:3]    
##  [1] "b" "c"

双重方括号[[]]可用于取出单一的元素:

Y[[1]]
##  [1] 1 2 3
 
Y[["B"]]
##  [1] "a" "b" "c" "d" "e"

请注意Y[1]和Y[[1]]的区别，Y["B"]和Y[["B"]]。

[[]]取元素可递归：

Z <- list(
    a = list(
        b = 9, 
        c = "hello",
        d = list(
            e = "3rd",
            f = list(
                g="4th"))),
    h = 1:5)
Z
##  $a
##  $a$b
##  [1] 9
##  
##  $a$c
##  [1] "hello"
##  
##  $a$d
##  $a$d$e
##  [1] "3rd"
##  
##  $a$d$f
##  $a$d$f$g
##  [1] "4th"
 
Z[[c("a", "b")]]
##  [1] 9
 
Z[[c("a", "b", "c")]]
##  Error in Z[[c("a", "b", "c")]] : 下标出界
 
Z[[c("a", "d", "f")]]
##  $g
##  [1] "4th"
 
Z[[c("a", "d", "f", "g")]]
##  [1] "4th"
 
Z$a$d$f$g
##  [1] "4th"
 
Y[[c("A","B")]]
##  Error in Y[[c("A", "B")]] : 下标出界
 
Y[c(1, 2)]
##  $A
##  [1] 1 2 3
##  
##  $B
##  [1] "a" "b" "c" "d" "e"
 
Y[[c(1, 2)]]
##  [1] 2

Z[[c("a", "b")]]递归就是先取Z的元素a，再取a的元素b，依次往后推。Z[[c("a", "d", "f")]]中选取出a，然后取出a中的d，然后d中没有f，所以报错说下标出界。其实这种递归的方式并没有连用$的方式直观和清晰。要留意Y[c(1, 2)]和Y[[c(1, 2)]]的区别。

Y <- list(A=1:3, B=letters[1:5], C=LETTERS[6:10])
Y
##  $A
##  [1] 1 2 3
##  
##  $B
##  [1] "a" "b" "c" "d" "e"
##  
##  $C
##  [1] "F" "G" "H" "I" "J"
 
Y[1:2] <- list(D=1:5, E=10:6)
Y

数据框本质上是列表，适合于列表的取子集的方式也适合于数据框，同时，数据框又像矩阵一样是二维的，可以通过行和列来取：

X <- data.frame(
    N = 11:16,
    S = c("a", "b", "a", "c", "a", "b"))
row.names(X) <- LETTERS[1:6]
X 
##     N S
##  A 11 a
##  B 12 b
##  C 13 a
##  D 14 c
##  E 15 a
##  F 16 b

可以通过$或者[[]]来取出某列：

X$N
##  [1] 11 12 13 14 15 16
 
X[["S"]]
##  [1] "a" "b" "a" "c" "a" "b"

可以通过行列的序号来取出部分：

X[c(1, 3, 6), ]
##     N S
##  A 11 a
##  C 13 a
##  F 16 b

利用序号取子集，可用于对数据框进行排序：

X[order(X$N, decreasing=TRUE), ]
##     N S
##  F 16 b
##  E 15 a
##  D 14 c
##  C 13 a
##  B 12 b
##  A 11 a
 
X[order(factor(X$S, levels=c("b", "a", "c"))), ]
##     N S
##  B 12 b
##  F 16 b
##  A 11 a
##  C 13 a
##  E 15 a
##  D 14 c
 
X <- X[order(factor(X$S, levels=c("b", "a", "c"))), ]
X
##     N S
##  B 12 b
##  F 16 b
##  A 11 a
##  C 13 a
##  E 15 a
##  D 14 c

通过逻辑向量来取：

X$N < 15 & X$N > 11
##  [1] FALSE  TRUE  TRUE  TRUE FALSE FALSE
 
X[c(FALSE, TRUE, TRUE, TRUE, FALSE, FALSE), ]
##     N S
##  B 12 b
##  C 13 a
##  D 14 c
 
X[X$N < 15 & X$N > 11,  ]
##     N S
##  B 12 b
##  C 13 a
##  D 14 c
 
X[X$S %in% c("b", "c"),  ]
##     N S
##  B 12 b
##  D 14 c
##  F 16 b
 
X[X$S == "a",  ]
##     N S
##  A 11 a
##  C 13 a
##  E 15 a
 
X[ , names(X) %in% c("S")]
##  [1] "b" "b" "a" "a" "a" "c"
X[X$N < 5, names(X) %in% c("S")]
##  character(0)

通过行列的名称来取子集：

X[c("D", "E", "A"), ]
##     N S
##  D 14 c
##  E 15 a
##  A 11 a
 
X[ , c("S", "N")]
##    S  N
##  B b 12
##  F b 16
##  A a 11
##  C a 13
##  E a 15
##  D c 14
X[ , c(2, 1)]
##    S  N
##  B b 12
##  F b 16
##  A a 11
##  C a 13
##  E a 15
##  D c 14

当取单行或者单列的时候，需要留意取出来的时候是不是对象类型改变了。用[]取单列的时候，默认得到的是本列的向量，而不是一个单列的数据框。

X[ , "N"]
##  [1] 11 12 13 14 15 16
 
X[ , "N", drop=TRUE]
##  [1] 11 12 13 14 15 16
 
X[ , "N", drop=FALSE]
##     N
##  A 11
##  B 12
##  C 13
##  D 14
##  E 15
##  F 16
 
X["A", ]
##     N S
##  A 11 a
 
X["A", , drop=FALSE]
##     N S
##  A 11 a
 
X["A", , drop=TRUE]
##  $N
##  [1] 11
##  
##  $S
##  [1] "a"

取子集与赋值合用，实现对象中子集值的改变：

X <- data.frame(N=1:6, S=c("a", "b", "a", "c", "a", "b"))
X
##    N S
##  1 1 a
##  2 2 b
##  3 3 a
##  4 4 c
##  5 5 a
##  6 6 b
 
X[X$S == "a", ]$N <- 10
X
##     N S
##  1 10 a
##  2  2 b
##  3 10 a
##  4  4 c
##  5 10 a
##  6  6 b
 
X$X <- "Y"
X
##     N S X
##  1 10 a Y
##  2  2 b Y
##  3 10 a Y
##  4  4 c Y
##  5 10 a Y
##  6  6 b Y
 
X$Y <- 1:10
##  Error in `$<-.data.frame`(`*tmp*`, Y, value = 1:10) : 
##    替换数据里有10行，但数据有6
 
X$Y <- 11:16
X
##     N S X  Y
##  1 10 a Y 11
##  2  2 b Y 12
##  3 10 a Y 13
##  4  4 c Y 14
##  5 10 a Y 15
##  6  6 b Y 16

同样，有时候要对整个数据框里的NA值进行替换，也可以像矩阵里替换一样：

X <- data.frame(A=1:6, B=letters[1:6], C=LETTERS[1:6], D=6:1)
X
##    A B C D
##  1 1 a A 6
##  2 2 b B 5
##  3 3 c C 4
##  4 4 d D 3
##  5 5 e E 2
##  6 6 f F 1
 
X$A[c(1, 3, 5)] <- NA
X$C[c(2, 4, 6)] <- NA
X
##     A B    C D
##  1 NA a    A 6
##  2  2 b <NA> 5
##  3 NA c    C 4
##  4  4 d <NA> 3
##  5 NA e    E 2
##  6  6 f <NA> 1
 
which(is.na(X))
##  [1]  1  3  5 14 16 18
 
X[is.na(X)] <- 0
X
##    A B C D
##  1 0 a A 6
##  2 2 b 0 5
##  3 0 c C 4
##  4 4 d 0 3
##  5 0 e E 2
##  6 6 f 0 1

需要注意，赋值时，不能把sample函数直接放到Index的位置，这样得不到预期：

X <- data.frame(N=1:6, S=c("a", "b", "a", "c", "a", "b"), U=LETTERS[1:6])
X
##    N S U
##  1 1 a A
##  2 2 b B
##  3 3 a C
##  4 4 c D
##  5 5 a E
##  6 6 b F
 
set.seed(1); sample(1:6, 3)
##  [1] 1 4 3
set.seed(1); X[sample(1:6, 3), ]$N <- 8:10            
X
##     N S U
##  1  8 a A
##  2  9 c D
##  3  3 a C
##  4  4 c D
##  5  5 a E
##  6 10 a C
set.seed(1); I <- sample(1:6, 3)
X[I, ]$N <- 8:10            
X
##     N S U
##  1  8 a A
##  2  9 c D
##  3 10 a C
##  4  9 c D
##  5  5 a E
##  6 10 a C

如果是要随机改变某列的一些行，那么需要先把随机数产生出来，再放到Index的位置。

data.frame是一个特殊的列表，通过如下例子，也能够更好地理解[]和[[]]的区别：

D <- data.frame(X=1:2, Y=3:4)
D
##    X Y
##  1 1 3
##  2 2 4
D["X"]
##    X
##  1 1
##  2 2
D[c("X", "Y")]
##    X Y
##  1 1 3
##  2 2 4
D$X
##  [1] 1 2
D[["X"]]
##  [1] 1 2
class(D["X"])
##  [1] "data.frame"
class(D[["X"]])
##  [1] "integer"

可以看到，D[“X”]得到的依然还是一个数据框，含有X一列，而D[["X"]]得到的是X这一列，是D的元素，是个向量。

CJ <- read.delim("ftp://ftp.biolab.wang/data/各科成绩.tsv", fileEncoding="GBK")
head(CJ)
##         学号   姓名   专业   班级 性别       科目 成绩
##  1 101200101 罗诗超 专业01 2001班   男 细胞生物学   57
##  2 101200102 韦海凤 专业01 2001班   女 细胞生物学   77
##  3 101200103 徐钧月 专业01 2001班   男 细胞生物学   71
##  4 101200104 黄妮亨 专业01 2001班   女 细胞生物学   85
##  5 101200105 欧炳彤 专业01 2001班   男 细胞生物学   64
##  6 101200106   潘叶 专业01 2001班   女 细胞生物学   73
str(CJ)
##  'data.frame':   4848 obs. of  7 variables:
##   $ 学号: int  101200101 101200102 101200103 101200104 101200105 101200106 101200107 101200108 101200109 101200110 ...
##   $ 姓名: chr  "罗诗超" "韦海凤" "徐钧月" "黄妮亨" ...
##   $ 专业: chr  "专业01" "专业01" "专业01" "专业01" ...
##   $ 班级: chr  "2001班" "2001班" "2001班" "2001班" ...
##   $ 性别: chr  "男" "女" "男" "女" ...
##   $ 科目: chr  "细胞生物学" "细胞生物学" "细胞生物学" "细胞生物学" ...
##   $ 成绩: int  57 77 71 85 64 73 77 78 81 56 ...

拿到一个数据框，首先通过head和str看看基本的信息。

CJ2001 <- CJ[CJ$班级 == "2001班", ]
head(CJ2001)
##         学号   姓名   专业   班级 性别       科目 成绩
##  1 101200101 罗诗超 专业01 2001班   男 细胞生物学   57
##  2 101200102 韦海凤 专业01 2001班   女 细胞生物学   77
##  3 101200103 徐钧月 专业01 2001班   男 细胞生物学   71
##  4 101200104 黄妮亨 专业01 2001班   女 细胞生物学   85
##  5 101200105 欧炳彤 专业01 2001班   男 细胞生物学   64
##  6 101200106   潘叶 专业01 2001班   女 细胞生物学   73
CJ2001 <- CJ2001[order(CJ2001$成绩, decreasing = TRUE), ]
head(CJ2001)
##            学号   姓名   专业   班级 性别       科目 成绩
##  1238 101200126   刘丽 专业01 2001班   女       体育   94
##  1844 101200126   刘丽 专业01 2001班   女   微生物学   94
##  4268 101200126   刘丽 专业01 2001班   女 分子生物学   94
##  1822 101200104 黄妮亨 专业01 2001班   女   微生物学   93
##  1225 101200113 黄建华 专业01 2001班   女       体育   91
##  1216 101200104 黄妮亨 专业01 2001班   女       体育   90
tail(CJ2001)
##            学号   姓名   专业   班级 性别       科目 成绩
##  2480 101200156 江雨宇 专业01 2001班   男   生物化学   46
##  661  101200155 黄佳涛 专业01 2001班   女     解剖学   45
##  649  101200143   桂泳 专业01 2001班   女     解剖学   43
##  1874 101200156 江雨宇 专业01 2001班   男   微生物学   43
##  4298 101200156 江雨宇 专业01 2001班   男 分子生物学   43
##  3691 101200155 黄佳涛 专业01 2001班   女     生理学   42
 
CJ[CJ$姓名 == "陆双全", ]
##            学号   姓名   专业   班级 性别       科目 成绩
##  47   101200147 陆双全 专业01 2001班   女 细胞生物学   61
##  653  101200147 陆双全 专业01 2001班   女     解剖学   60
##  1259 101200147 陆双全 专业01 2001班   女       体育   68
##  1865 101200147 陆双全 专业01 2001班   女   微生物学   64
##  2471 101200147 陆双全 专业01 2001班   女   生物化学   64
##  3077 101200147 陆双全 专业01 2001班   女     遗传学   63
##  3683 101200147 陆双全 专业01 2001班   女     生理学   66
##  4289 101200147 陆双全 专业01 2001班   女 分子生物学   57
CJ[CJ$姓名 == "陆双全" & CJ$成绩 < 60, ]$成绩 <- 60
CJ[CJ$姓名 == "陆双全", ]
##            学号   姓名   专业   班级 性别       科目 成绩
##  47   101200147 陆双全 专业01 2001班   女 细胞生物学   61
##  653  101200147 陆双全 专业01 2001班   女     解剖学   60
##  1259 101200147 陆双全 专业01 2001班   女       体育   68
##  1865 101200147 陆双全 专业01 2001班   女   微生物学   64
##  2471 101200147 陆双全 专业01 2001班   女   生物化学   64
##  3077 101200147 陆双全 专业01 2001班   女     遗传学   63
##  3683 101200147 陆双全 专业01 2001班   女     生理学   66
##  4289 101200147 陆双全 专业01 2001班   女 分子生物学   60

算术运算：加(+)、减(-)、乘(*)、除以(/)、指数(^)、整除(%/%)、取模(%%)
比较运算：相等(==)、不等(!=)、大于(>)、小于(<)、大于等于(>=)、小于等于(<=)
逻辑运算：或(|)、且(&)、非(!)
算术运算针对数值型或者复数型的对象进行加减乘数的基本算术，比较运算、逻辑运算结果为逻辑型。如：

10 + 2*3 + 4/5 -2*6 + 2^3
##  [1] 12.8
11.3/2
##  [1] 5.65
11.3 %/% 2
##  [1] 5
11.3 %% 2
##  [1] 1.3
1 == 2
##  [1] FALSE
1 <= 2
##  [1] TRUE
1 <= 2 & 1 == 2
##  [1] FALSE
1 <= 2 | 1 == 2
##  [1] TRUE
!(1 <= 2 & 1 == 2)
##  [1] TRUE

如上提到的运算符都可以用于向量和向量之间，两个向量之前相同位置上的数值之间进行运算，运算结果按顺序返回生成新的向量。当两个向量长度不等时，较短的向量将重新从第一个元素开始重复使用，如此直到较长的向量所有元素都完成。这样当一个向量与长度为1的向量进行运算时，相当于每个元素都与这个值做同样的运算。

1:5 + 10:14
##  [1] 11 13 15 17 19
 
1:5 + 10:19
##   [1] 11 13 15 17 19 16 18 20 22 24
 
1:5 + 10:23
##   [1] 11 13 15 17 19 16 18 20 22 24 21 23 25 27
##  Warning message:
##  In 1:5 + 10:23 : 长的对象长度不是短的对象长度的整倍数

&& (且，非向量化的，用于长度为1的向量)， || (或，非向量化的，用于长度为1的向量) ，一般用于 if() 中。 %in% (前一个向量的元素是否出现在后一个向量里,对前一个向量中每个元素依次判断返回向量结果)
<- (向左赋值)
-> (向右赋值)

TRUE && c(TRUE, FALSE)
##  [1] TRUE
##  Warning message:
##  In TRUE && c(TRUE, FALSE) : 'length(x) = 2 > 1' in coercion to 'logical(1)'
 
TRUE && c(FALSE, TRUE)
##  [1] FALSE
##  Warning message:
##  In TRUE && c(FALSE, TRUE) : 'length(x) = 2 > 1' in coercion to 'logical(1)'
 
FALSE || c(TRUE, FALSE)
##  [1] TRUE
##  Warning message:
##  In FALSE || c(TRUE, FALSE) :
##    'length(x) = 2 > 1' in coercion to 'logical(1)'
 
FALSE || c(FALSE, TRUE)
##  [1] FALSE
##  Warning message:
##  In FALSE || c(FALSE, TRUE) :
##    'length(x) = 2 > 1' in coercion to 'logical(1)'
 
c(1,3,5) %in% c(2,3,5,6)
##  [1] FALSE  TRUE  TRUE
 
c(2,3,5,6) %in% c(1,3,5)
##  [1] FALSE  TRUE  TRUE FALSE
 
y <- 1 -> x
y
##  [1] 1
 
x
##  [1] 1

我个人是不太建议使用%>%或|>这样的管道的，我认为还是经典的R的向左赋值更清晰明了。然而，管道却被不少人吹捧，因此，这里还是提一下，以便大家见到了能看懂。
管道操作符将其前边的表达式得到的值传递给它后边的表达式或者函数，作为后边函数的第一个参数，或者将值传到占位符（%>%对应.而|>对应_）所在的位置。

magrittr包使用管道操作符%>%等。使用install.packages('magrittr')命令安装，library(magrittr)加载后使用：
x %>% f(y) 等同于 f(x, y)，而x %>% f(y, arg=.) 等同于 f(y, arg=x)

1:10 %>% mean()
##  [1] 5.5
1:5 %>% round(3.1415926, digits=.)
##  [1] 3.10000 3.14000 3.14200 3.14160 3.14159
1:10 %>% sd
##  [1] 3.02765
 
CJ <- read.delim("ftp://ftp.biolab.wang/data/各科成绩.tsv", fileEncoding="GBK") 
CJ %>% subset(姓名=="罗诗超" & 科目=="细胞生物学")
##         学号   姓名   专业   班级 性别       科目 成绩
##  1 101200101 罗诗超 专业01 2001班   男 细胞生物学   57

现在R的base包已有其管道操作符|>, 用法与%>%一样，不一样的地方是|>后边不能只给函数名，而是需要是函数调用，也就是说括号不能省略。另外，占位符用的是下划线_。

1:10 |> sqrt()
##   [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427 3.000000 3.162278
 
1:5  |> round(3.01234567890, digits=_)
##  [1] 3.00000 3.01000 3.01200 3.01230 3.01235

流程控制结构控制代码的执行流程，主要包括‌循环‌和‌条件判断‌。循环用于重复执行一段代码，直到满足某个条件才终止。在一个循环中，对对重复执行的这一段代码的一次执行叫做一次迭代。通过多次迭代重复执行某个过程或者步骤，逐步改进或者逼近目标。常用的就是流程控制为for, repeat, while等，条件判断有if, if … else …等，终止一个循环用break，终止一次迭代用next。

对向量中的每个元素依次执行操作，执行的操作可以不用到这些元素。比如：

for(i in c(0, 11, 235, 812, 2134)){
    print(i)
}
##  [1] 0
##  [1] 11
##  [1] 235
##  [1] 812
##  [1] 2134
 
for(i in c(0, 11, 235, 812, 2134)){
    I <- sprintf("%04d", i)
    print(I)
}
##  [1] "0000"
##  [1] "0011"
##  [1] "0235"
##  [1] "0812"
##  [1] "2134"

如上依次进行格式化之后打印，当然还能有别的很多你自己希望的步骤，这里的i就是依次取用向量中的值。

for(i in c(0, 11, 235, 812, 2134)){
    I <- sample(base::LETTERS, 1)
    print(I)
}
##  [1] "B"
##  [1] "A"
##  [1] "G"
##  [1] "J"
##  [1] "B"

如上，操作可以不用到向量中的元素，这时候其实就是个简单的计数，运行向量长度那么多次。LETTERS是base包中内置的向量，元素为A-Z这26个大写的字母。sample用于从中随机抽出一个，大家练习的时候可能得到的不是这些字母。

在R中的for循环速度比较慢，有时候需要避免，而是采用向量化的运算比较合适。这个用system.time比较一下可以看出来:

# 如下是向量化的运算，可以看到，速度是比较快的
system.time({I <- sum((1:100000000)^2); print(I)})
 
# 如下用for来算，很显然使用了几十上百倍的时间
system.time({I <- 0; for(i in c(1:100000000)) I <- I + i^2; print(I)})

同样是对1~100000000这一亿个数进行求平方，用for来一个个算就比向量化的计算要慢得多。

while(当)满足条件时执行，比如

X <- c(0, 11, 235, 812, 2134)
i <- 1
while(i <= 4){
    print(X[i])
    i <- i+1
}
##  [1] 0
##  [1] 11
##  [1] 235
##  [1] 812

如上依次打印到屏幕，直到i大于5就停止了。 第一次判断，i是1，比4小，于是运行第一次迭代，运行之后，i变成了2，依然满足条件，于是第二次迭代，当进行了4次迭代之后，i变成了5，不再满足条件，就退出循环不再迭代了，所以X的第5个元素并没有被print出来。

X <- c(0, 11, 235, 812, 2134)
i <- 1
while(i <= 4){
    I <- sprintf("%04d", X[i])
    print(I)
    i <- i+1
}
##  [1] "0000"
##  [1] "0011"
##  [1] "0235"
##  [1] "0812"

如上依次进行格式化之后打印，当然还能有别的很多你自己希望的步骤，这里的i就是依次取用向量中的值。

很显然，这里while也能实现想要用for来做的事情，但不一定比for做得好。比如，我们如果要把1~10000000000这一百亿个数的平方和，那么试试如下三种做法，体会一下:

system.time({S <- sum((1:10000000000)^2); print(S)})
# 如上方法错误，比如我的电脑上显示错误为：“错误: 无法分配大小为74.5 Gb的矢量”
 
system.time({S <- 0; for(i in 1:10000000000){S <- S + i^2}; print(S)})
# 依然能够运行
 
system.time({S <-0; i <- 1; while(i <= 10000000000){S <- S + i^2; i <- i + 1}; print(S)})
# 依然能够运行，但是时间比如for要长一些，大概是因为这里每次迭代都多了一步i <- i+1的缘故

进行无条件的循环，因此需要在流程中制定退出机制。使用if和break决定什么时候退出：

X <- c(0, 11, 235, 812, 2134)
i <- 1
repeat{
    print(X[i])
    if(i >= 5) break
    i <- i+1
}
##  [1] 0
##  [1] 11
##  [1] 235
##  [1] 812
##  [1] 2134

每次repeat之后i的值都是变化的。注意break在不同的位置结果可能是不同的，需要留意程序中各个值的变化：

X <- c(0, 11, 235, 812, 2134)
i <- 1
repeat{
    print(X[i])
    i <- i+1
    if(i >= 5) break
}
##  [1] 0
##  [1] 11
##  [1] 235
##  [1] 812

当满足条件时执行一次, 后边可以用(也可以不用)else来指明不满足条件时执行的操作。 如下：

if(1 < 2 ) print("TRUE")
##  [1] "TRUE"
 
if(1 > 2 ) print("TRUE")
 
if(1 < 2 ) print("TRUE") else print("Not TRUE")
##  [1] "TRUE"
 
if(1 > 2 ) print("TRUE") else print("Not TRUE")
##  [1] "Not TRUE"

else 后边可以紧接着用if，这样就可以有很多的判断，很多的分支。如下这样，把TRUE换成适当的判断语句，把…换成需要执行的命名：

if(TRUE){
    ...
}else if(TRUE){
    ...
}else if(TRUE){
    ...
}else if(TRUE){
    ...
}esle{
    ...
}

比如：

i=1
while(i <= 20){                            
    if(i < 5){
        print(sprintf("i=%s, i < 5", i))                
        i = i + 2
    } else if(i < 8) {
        print(sprintf("i=%s, i >= 5 & i < 8", i))
        i = i + 1
    } else {
        print(sprintf("i=%s, i >= 8", i))
        i = i + 3
    }
}
##  [1] "i=1, i < 5"
##  [1] "i=3, i < 5"
##  [1] "i=5, i >= 5 & i < 8"
##  [1] "i=6, i >= 5 & i < 8"
##  [1] "i=7, i >= 5 & i < 8"
##  [1] "i=8, i >= 8"
##  [1] "i=11, i >= 8"
##  [1] "i=14, i >= 8"
##  [1] "i=17, i >= 8"
##  [1] "i=20, i >= 8"

满足条件的时候执行，需预先定义i，且循环中i应变化，否则即是死循环。

for(i in 1:10){
    if(i < 5){
        print(sprintf("i=%s, i < 5", i))                
    } else if(i < 8) {
        print(sprintf("i=%s, i >= 5 & i < 8", i))
    } else {
        print(sprintf("i=%s, i >= 8", i))
    }
}
##  [1] "i=1, i < 5"
##  [1] "i=2, i < 5"
##  [1] "i=3, i < 5"
##  [1] "i=4, i < 5"
##  [1] "i=5, i >= 5 & i < 8"
##  [1] "i=6, i >= 5 & i < 8"
##  [1] "i=7, i >= 5 & i < 8"
##  [1] "i=8, i >= 8"
##  [1] "i=9, i >= 8"
##  [1] "i=10, i >= 8"

for对所有的元素依次执行，if做出判断，else if 部分可以没有，也可以有多个。

for(i in 1:10){                                    
    if(i < 5){
        next
        print(sprintf("%s < 5", i))                
    } else if(i < 8) {
        print(sprintf("%s >= 5 & %s < 8", i, i))
    } else {
        print(sprintf("%s >= 8", i))
        break
    }
}
##  [1] "5 >= 5 & 5 < 8"
##  [1] "6 >= 5 & 6 < 8"
##  [1] "7 >= 5 & 7 < 8"
##  [1] "8 >= 8"

next是跳出循环的当前迭代，进入下一次迭代，而break是终止整个当前的循环，这里是for循环。

根据一个逻辑向量中的TRUE和FALSE对两个向量中的值进行选择，同样返回一个向量。比如：

ifelse(1:10 <= 5, "小", "大")
##  [1] "小" "小" "小" "小" "小" "大" "大" "大" "大" "大"
 
ifelse(c(1, 3, 5, 7, 9, 2, 4, 6, 8, 10) <= 5, "A", "B")
##  [1] "A" "A" "A" "B" "B" "A" "A" "B" "B" "B"
 
ifelse(1:10 <= 5, base::LETTERS, base::letters)
##  [1] "A" "B" "C" "D" "E" "f" "g" "h" "i" "j"
 
ifelse(1:10 <= 5, base::LETTERS[1:2], base::letters[1:3])
##  [1] "A" "B" "A" "B" "A" "c" "a" "b" "c" "a"

给ifelse的三个参数都是向量，如果后边的两个向量长度小于第一个向量(逻辑向量)的长度，则重复使用，直到与第一个向量等长。

ifelse(c(1, 3, 5, 7, 9, 2, 4, 6, 8, 10) <= 5, base::LETTERS[1:2], base::letters[1:3])
##  [1] "A" "B" "A" "a" "b" "B" "A" "b" "c" "a"

比如上边这个例子，将后边的两个向量重复之后与第一个向量的值对应如下,这样就很好理解结果了：

  TRUE    A    a
  TRUE    B    b
  TRUE    A    c
 FALSE    B    a
 FALSE    A    b
  TRUE    B    c
  TRUE    A    a
 FALSE    B    b
 FALSE    A    c
 FALSE    B    a

根据表达式(表达式的运算结果是一个数字或者字符串)来选择返回的值，使用? switch查看更多的。比如下边这些例子：

for(X in c("A", "CC", "DD")){
  Y <- switch(EXPR=substr(X, 1, 1), A="a", B="bb", C="ccc")
  print(Y)
}
##  [1] "a"
##  [1] "ccc"
##  NULL

switch用于根据EXPR的值来选择，当这个值并没有对应的值的时候，得到NULL。

for(X in c("A", "C", "D", "E")){
  Y <- switch(EXPR=X, A="a", B="bb", C="ccc", "dddd")
  print(Y)
}
##  [1] "a"
##  [1] "ccc"
##  [1] "dddd"
##  [1] "dddd"

而如果存在并没有名称的选项的时候，所有的没有对应项的值都会得到这个没有名称的值。

for(X in 1:5){
  Y <- switch(EXPR=X, A="a", B="bb", C="ccc", "dddd")
  print(Y)
}
##  [1] "a"
##  [1] "bb"
##  [1] "ccc"
##  [1] "dddd"
##  NULL

可以使用数字，当使用数字的时候，只是和顺序有关，而和选项是否有名称并没有多大的关系。

for(X in 0:10){
  Y <- switch(EXPR=sqrt(X), A="a", "dddd")
  print(Y)
}
##  NULL
##  [1] "a"
##  [1] "a"
##  [1] "a"
##  [1] "dddd"
##  [1] "dddd"
##  [1] "dddd"
##  [1] "dddd"
##  [1] "dddd"
##  NULL
##  NULL
 
for(X in 0:10){
  Y <- switch(EXPR=sqrt(X), A="a", "dddd")
  print(sprintf("EXPR=%f, Y gets %s", sqrt(X), Y))
}
##  character(0)
##  [1] "EXPR=1.000000, Y gets a"
##  [1] "EXPR=1.414214, Y gets a"
##  [1] "EXPR=1.732051, Y gets a"
##  [1] "EXPR=2.000000, Y gets dddd"
##  [1] "EXPR=2.236068, Y gets dddd"
##  [1] "EXPR=2.449490, Y gets dddd"
##  [1] "EXPR=2.645751, Y gets dddd"
##  [1] "EXPR=2.828427, Y gets dddd"
##  character(0)
##  character(0)

可以看到，当EXPR的值不是整数的时候，按照整数部分来取值。这些也能够用if…else…来实现。

break用于退出for、while或repeat循环，不再进行后续的迭代，next用于结束当前的迭代，进入下一次迭代。当多个循环套用时，break和next都只作用于所在的循环。使用时要注意终止的位置。

for(i in 1:10){
    if(i == 5) break
    print(i)
}
##  [1] 1
##  [1] 2
##  [1] 3
##  [1] 4

break是退出当前的循环，这里在第5次迭代的时候，判断满足i==5的条件了，于是退出循环，后边的print(i)没有被执行。

for(i in 1:10){
    if(i == 5) next
    print(i)
}
##  [1] 1
##  [1] 2
##  [1] 3
##  [1] 4
##  [1] 6
##  [1] 7
##  [1] 8
##  [1] 9
##  [1] 10

next是结束当前的迭代，进行下一次迭代。这里在第5次迭代的时候，发现满足了i==5，于是next到下一次迭代，第五次迭代中在next语句之后的print(i)并没有执行。

for(i in 1:3){
    for(j in 1:3){
        if(i == 2) break
        print(sprintf("i is %d, j is %d", i, j))
    }
}
##  [1] "i is 1, j is 1"
##  [1] "i is 1, j is 2"
##  [1] "i is 1, j is 3"
##  [1] "i is 3, j is 1"
##  [1] "i is 3, j is 2"
##  [1] "i is 3, j is 3"

break只影响直接包含它的循环，这里当i==2的时候，从里边的for循环break出来，外边的for依然在继续执行。

for(i in 1:3){
    if(i == 2) break
    for(j in 1:3){
        print(sprintf("i is %d, j is %d", i, j))
    }
}
##  [1] "i is 1, j is 1"
##  [1] "i is 1, j is 2"
##  [1] "i is 1, j is 3"

这里break了外边部的for循环，break之后里边的for循环也不再执行。

for(i in 1:3){
    if(i == 2) next
    for(j in 1:3){
        print(sprintf("i is %d, j is %d", i, j))
    }
}
##  [1] "i is 1, j is 1"
##  [1] "i is 1, j is 2"
##  [1] "i is 1, j is 3"
##  [1] "i is 3, j is 1"
##  [1] "i is 3, j is 2"
##  [1] "i is 3, j is 3"

next在这里只要i==2没有执行，后边i==3的时候得到执行。

编程就是将一系列的指令组合在一起，告诉电脑做什么，通常会用到上边学到的基本的函数以及流程控制。 我们前边已经学习了R的语法和词语，需要把它们组合，才能够实现丰富多彩的任务。这里展示一些例子。 同样的语法框架下，一个意思有不同的表达方法，使用不同的说法效果不同，这就造就了语言大师和语拙者之间的区别。

仅用加减乘除，求X的N次方。我们先从求10的5次方作为例子来看，我们用加减乘除来求10的五次方，那么我们分5次迭代来实现，如下:

第01次迭代：1*10
第02次迭代：1*10*10
第03次迭代：1*10*10*10
第04次迭代：1*10*10*10*10
第05次迭代：1*10*10*10*10*10

大家可以看出来，这里做了5次迭代，这里边有个规律，就是每次迭代是在上一次迭代的基础上乘以10，总的乘了5次，要知道乘了5次，我们需要一个对象来计数，每次迭代 + 1。当这个迭代次数到达5的时候，我们就停下来，用R语言写出来就是这样子：

# 初始化一个变量，用于随着迭代 + 1，从而实现对迭代次数的记录
die_dai_n <- 0
# 初始化一个变量，用于每次迭代在上一次迭代的基础上 × 10，从而实现5次迭代之后得到10的5次方
n_ci_fang <- 1
# 然后进行重复，到迭代次数die_dai_n 等于 5 的时候停下来
repeat {
  n_ci_fang <- n_ci_fang * 10
  die_dai_n <- die_dai_n + 1
  if(die_dai_n == 5) break
}
# 循环完成之后看看结果
n_ci_fang

R控制台运行效果如下

然后我们推广到，X的N次方，只要把10和5的地方分别换成X和N就可以了，但是要测试先随意定义一个X和N

X <- 2
N <- 3
die_dai_n <- 0
n_ci_fang <- 1
repeat {
  n_ci_fang <- n_ci_fang * X
  die_dai_n <- die_dai_n + 1
  if(die_dai_n == N) break
}
n_ci_fang
##  [1] 8

我们可以把上边这段代码一般化为一个函数，调用函数修改参数即可方便地求任何X的的任何N次方：

X_N_CiFang <- function(X, N){
  die_dai_n <- 0
  n_ci_fang <- 1
  repeat {
    n_ci_fang <- n_ci_fang * X
    die_dai_n <- die_dai_n + 1
    if(die_dai_n == N) break
  }
  return(n_ci_fang)
}
X_N_CiFang(X=10, N=5)
##  [1] 100000
X_N_CiFang(X=5, N=10)
##  [1] 9765625

# 当然，我们也可以用while或者for来实现：

I <- 1; 
for(i in 1:5) {
  I <- I*10
}
I
##  [1] 100000

看看每次迭代都进行了啥：

I <- 1; 
for(i in 1:5) {
  I <- I*10
  print(sprintf("i = %d, I = %d", i, I))
}
##  [1] "i = 1, I = 10"
##  [1] "i = 2, I = 100"
##  [1] "i = 3, I = 1000"
##  [1] "i = 4, I = 10000"
##  [1] "i = 5, I = 100000"

如果还不明白，那我们再来让它更清楚一些，引入一个叫迭代(DieDai)的变量，每次迭代这个变量加1：

CiFang <- 1; 
DieDai <- 0
for(i in 1:5) {
  DieDai <- DieDai + 1
  CiFang <- CiFang * 10
  print(sprintf("第%d次迭代，得到CiFang =  %d", DieDai, CiFang))
}
##  [1] "第1次迭代，得到CiFang =  10"
##  [1] "第2次迭代，得到CiFang =  100"
##  [1] "第3次迭代，得到CiFang =  1000"
##  [1] "第4次迭代，得到CiFang =  10000"
##  [1] "第5次迭代，得到CiFang =  100000"

很明显，这里的i是什么并不影响最后的结果，在后边的代码中并不需要用到i的值。

I <- i <- 1
while(i <= 5){
  I <- I*10 
  print(sprintf("i = %d, I = %d", i, I))
  i <- i + 1
}
##  [1] "i = 1, I = 10"
##  [1] "i = 2, I = 100"
##  [1] "i = 3, I = 1000"
##  [1] "i = 4, I = 10000"
##  [1] "i = 5, I = 100000"
 
I <- i <- 1
repeat{
  I <- I*10 
  print(sprintf("i = %d, I = %d", i, I))
  if(i == 5) break
  i <- i + 1
}
##  [1] "i = 1, I = 10"
##  [1] "i = 2, I = 100"
##  [1] "i = 3, I = 1000"
##  [1] "i = 4, I = 10000"
##  [1] "i = 5, I = 100000"

平时我们在求X的N次方的时候有现成的运算符可以用，表示为X^N即可。如上这样用加减乘除是为了让大家学习循环，锻炼编程思维。

对于正整数N，有N的阶乘，即、、、 。
比如求5的阶层，我们可以用循环分为五次迭代，如下：

第01次迭代：1*1
第02次迭代：1*1*2
第03次迭代：1*1*2*3
第04次迭代：1*1*2*3*4
第05次迭代：1*1*2*3*4*5

大家可以看出来，这里做了5次迭代，这里边有个规律，就是每次迭代是在上一次迭代的基础上乘以一个数字，这个数字每次迭代是在上一次数字的基础上+1。当这个数字为5的时候就停下来了。 我们用R语言写出来就是这样子。

# 首先定义一个对象，这个对象初始值是0，每次迭代在上一次迭代得到的值的基础上 + 1
die_dai_n <- 0
# 首先定义一个对象，这个对象初始值是1，每次迭代它在上一次迭代的值的基础上 * die_dai_n 
jie_cheng <- 1
# 然后用repeat进行重复，满足迭代次数 (die_dai_n) 是5的时候停下来，也就是break
repeat {
  die_dai_n <- die_dai_n + 1
  jie_cheng <- jie_cheng * die_dai_n
  if(die_dai_n == 5) break
}
# 循环结束之后我们看看jie_cheng的值对不对
jie_cheng 

看看R控制台运行的效果：

然后我们拓展成求N的阶乘，比如N=10，我们用N替换上边5的位置，把N在前边定义，这样每次可以在前边对N赋值之后运行，即可：

N <- 10
die_dai_n <- 0
jie_cheng <- 1
repeat {
  die_dai_n <- die_dai_n + 1
  jie_cheng <- jie_cheng * die_dai_n
  if(die_dai_n == N) break
}
jie_cheng 

然后我们可以把这个这个代码放到一个函数里边，方便调用求不同N的阶乘，就是把N当做参数即可：

JieCheng <- function(N){
  die_dai_n <- 0
  jie_cheng <- 1
  repeat {
    die_dai_n <- die_dai_n + 1
    jie_cheng <- jie_cheng * die_dai_n
    if(die_dai_n == N) break
  }
  return(jie_cheng)
}
 
JieCheng(5)
##  [1] 120
JieCheng(10)
##  [1] 3628800

除了用repeat以外，我们可以用while来写，也是一样的，比如求10的阶乘（10!）：

N <- 10
die_dai_n <- 0
jie_cheng <- 1
while(die_dai_n < N) {
  die_dai_n <- die_dai_n + 1
  jie_cheng <- jie_cheng * die_dai_n
}
jie_cheng 
##  [1] 3628800

注意，先die_dai_n + 1还是先jie_cheng * die_dai_n的顺序是有影响的，大家可以看看如下的写法，看看循环次数的区别：

N <- 10
die_dai_n <- 1
jie_cheng <- 1
while(die_dai_n <= N) {
  jie_cheng <- jie_cheng * die_dai_n
  die_dai_n <- die_dai_n + 1
}
jie_cheng
##  [1] 3628800

另外还能用for来实现。

jie_cheng <- 1
for(N in 1:10) jie_cheng <- jie_cheng * N
jie_cheng
##  [1] 3628800

当然，求阶乘还能使用prod或者factorial函数，这里用加减乘除为的是编程示例，现实编程中使用现成的函数可以更高效。一方面，现有的函数经过优化，执行效率更高，一方面，直接使用现成的函数也能节约自己的时间。

根据泰勒公式：
要算出这个问题，我们每次迭代加一项，每一项可以通过其前一项计算得到，每一项在其上项的基础上，在分子上乘以x，在分母上乘以n，也就是，而n通过上一迭代的n加+1得到。算到一定的精度就停下来，比如的绝对值比10*.Machine$double.eps要小即停下来。

edxcf <- function(x=1, delta=10*.Machine$double.eps){
  ex <- an <- n <- 1
  repeat{
    an <- an*(x/n)
    ex <- ex + an
    if(abs(an) < delta) break
    n  <- n+1
  }
  return(ex)
}
 
options(digits=22)
edxcf(1)
##  [1] 2.718281828459045534885
 
edxcf(2)
##  [1] 7.389056098930648630585
 
edxcf(-1)
##  [1] 0.3678794411714424450466

比如这里一个求斐波拉契数列(0, 1, 1, 2, 3, 5, 8, 13, 21, …… ,每项是前边两项之和)中不超过某个数(比如1000)的最大的数：

a <- 0; b <- 1
while(a <= 1000){
  print(a) 
  c <- a + b
  a <- b
  b <- c
}
##  [1] 0
##  [1] 1
##  [1] 1
##  [1] 2
##  [1] 3
##  [1] 5
##  [1] 8
##  [1] 13
##  [1] 21
##  [1] 34
##  [1] 55
##  [1] 89
##  [1] 144
##  [1] 233
##  [1] 377
##  [1] 610
##  [1] 987

在这段代码的运行中，a是我们要求的，初始值a1是0，初始的时候它的后一位b1是1，这个我们是知道的，于是设定这样的初始值。while后边的第一次运行的时候，我们把a打印到屏幕，也就是打印第一个元素，然后我们求出它的后一位的后一位，这里用c表示，c1=a1+b1。然后往后挪一位，a2=b1，b2=c1，这样就结束了第一个循环，接下来，第二个循环，首先打印到屏幕的a是a2，然后求出c2，然后往后挪一位得到a3，b3。这样到第三次循环的时候，打印出a3，如此往复，直到a大于1000的时候就不再运行了，也就是不打印出a来了。

另外，可以把这些数字放到一个向量F里边

F <- c(0, 1)
while(F[length(F)] < 1000){
    F <- c(F, F[length(F)] + F[length(F)-1])
}
print(F)
##  [1]    0    1    1    2    3    5    8   13   21   34   55   89  144  233  377  610  987 1597

取最后一个元素可以使用tail函数，但是似乎要更慢一些。一般轻量运用不用太考虑速度的问题，也可以写成这样：

F <- c(0, 1)
while(tail(F, n=1) < 1000){
    F <- c(F, sum(tail(F, n=2)))
}
print(F)
##  [1]    0    1    1    2    3    5    8   13   21   34   55   89  144  233  377  610  987 1597

如果大于1的自然数N，如果它不能被除了1和它自身以外的其它数整除，也即对于从2到N-1的整数n，都有N除以n的余数不为0，即 N%%n != 0 ，则N是质数，2是最小的质数。而在检验中我们不需要检验那么多，只需要检验2到N的平方根这个区间的n就可以了，因为，如果有一个大于sqrt(N)整数能够整除N，那么其乘数必然是小于sqrt(N)的，也就是在检验sqrt(N)之前的数字的时候已经发现了存在一个数n使得N%%n == 0。

N <- 20
N %% 2:sqrt(N) != 0
##  [1] FALSE  TRUE FALSE
 
N <- 17
N %% 2:sqrt(N) != 0
##  [1] TRUE TRUE TRUE
 
for(N in 3:20){
  if(all(N %% 2:sqrt(N) != 0)) {
    print(sprintf("%d是质数", N))
  } else {
    print(sprintf("%d不是是质数", N))
  }
}
##  [1] "3是质数"
##  [1] "4不是是质数"
##  [1] "5是质数"
##  [1] "6不是是质数"
##  [1] "7是质数"
##  [1] "8不是是质数"
##  [1] "9不是是质数"
##  [1] "10不是是质数"
##  [1] "11是质数"
##  [1] "12不是是质数"
##  [1] "13是质数"
##  [1] "14不是是质数"
##  [1] "15不是是质数"
##  [1] "16不是是质数"
##  [1] "17是质数"
##  [1] "18不是是质数"
##  [1] "19是质数"
##  [1] "20不是是质数"

对于比较大的数来说，我们不需要检验到其平方根那么多，只要找到第一个能够整除它的数就可以停止了。

N <- 20
 
X <- 1
n <- 2
while(n <= sqrt(N)){
  if(N %% n == 0) {
    X <- 0
    break
  }
  n <- n + 1
}
if(X == 0) {
  print("N不是质数")
} else {
  print("N是质数")
}
##  [1] "N不是质数"

while循环运行到找到能够整除N的n就停下来，如果找到了停下来，那么就会把X值改为0，而如果是运行结束了还没有找到能够整除N的n，这时候X的值没有改变，依然是1。 因此，while循环之后通过X的值来判断N是否是质数。

因此，可以写个函数，判断任意一个自然数N是否是质数。

ZS <- function(N, X=1, n=2){
  while(n <= sqrt(N)){
    if(N %% n == 0) {
      X <- 0
      break
    }
    n <- n + 1
  }
  if(X == 0) {
    print(sprintf("%d非质数", N))
  } else {
    print(sprintf("%d是质数", N))
  }
}
 
for(N in 10:20) ZS(N)
##  [1] "10非质数"
##  [1] "11是质数"
##  [1] "12非质数"
##  [1] "13是质数"
##  [1] "14非质数"
##  [1] "15非质数"
##  [1] "16非质数"
##  [1] "17是质数"
##  [1] "18非质数"
##  [1] "19是质数"
##  [1] "20非质数"

这里实际上用到取整和整除，一个数除以10得到的余数就是最后一位的数字，除以10得到的整数部分就是去掉最后一位数字的数，再一次求余得到十位数的数，以此类推，就能够得到每一位上的数,最后整除得到了0则停止。

N <- 789
N
##  [1] 789
N %% 10
##  [1] 9
N <- N %/% 10
N
##  [1] 78
N %%10
##  [1] 8
N <- N %/% 10
N
##  [1] 7
N %% 10
##  [1] 7
N <- N %/% 10  
N
##  [1] 0

这里以N为789为例，第一次求余，得到个位上的数；然后整除以10，得到去掉个位上的数剩下的数字，再第二次求余，十位上的数；然后整除以10，去掉十位上的数；然后再除以10求余，得到百位上的数；这时候在整除以10，得到0，说明去掉百位上的数字之后没有数字剩下了，也就停下来了。如此就把一个数字的各位的数字取出来了。

我们把上边的这些代码用while循环来写，仔细想想每一次迭代都做了什么：

N <- 789       
while(N > 0){
  print(N %% 10)
  N <- N %/% 10 
}
##  [1] 9
##  [1] 8
##  [1] 7

我们可以推广，那就是做成一个函数，这样对任意数字都可以方便的进行拆解：

SplitNum <- function(N){
  while(N > 0){
    print(N %% 10)
    N <- N %/% 10 
  }
}
 
SplitNum(56789)
##  [1] 9
##  [1] 8
##  [1] 7
##  [1] 6
##  [1] 5

我们可以把得到的这些数字放到一个向量里边：

SplitNum <- function(N){
  Out <- c()
  while(N > 0){
    Out <- c(N %% 10, Out)
    N <- N %/% 10 
  }
  return(Out)
}
 
SplitNum(56789)
##  [1] 5 6 7 8 9

先创建一个空的向量Out，每次迭代得到的数字附加到Out的前边 ，最后再把循环完成之后得到的结果作为整个函数运行的结果返回。

如果我要的不是得到每一位上的数字，而是希望对每一位数字进行相加，那么如下：

SumNum <- function(N){
  Out <- 0
  while(N > 0){
    Out <- Out + N %% 10
    N <- N %/% 10 
  }
  return(Out)                  
}
 
SumNum(56789)
##  [1] 35

除了上边的方法以为，可以先将数字转成字符，在是strsplit进行拆分，然后转为数字，然后求和，但是要慢一些，试试如下两行代码可以看出，转为字符拆分的方法要慢两三倍。

system.time(for(i in 1:100000) SumNum(5678))
##  用户 系统 流逝 
##  0.09 0.00 0.19 
system.time(for(i in 1:100000) sum(as.numeric(strsplit(as.character(5678), "")[[1]])))
##  用户 系统 流逝 
##  0.27 0.00 0.50 

除了使用循环以外，还能用向量化的运算：

789 %/% c(100, 10, 1)
##  [1]   7  78 789
(789 %/% c(100, 10, 1)) %% 10
##  [1] 7 8 9

向量化整除， 对于3位数，整除的是10^(2:0)，然后再求余，除以十

这是需要知道这个数字的位数的，不知道位数，对任意的正整数，那么可以使用求对数来得到，这样整合起来，做一个函数：

SumNum2 <- function(N){
    n <- log(N, 10) %/% 1 + 1
    d <- 10^((n-1):0)                        
    sum((N %/% d) %/% 10)                    
}
 
SumNum3 <- function(N){
    sum((N %/% 10^((log(N, 10) %/% 1):0)) %/% 10)                    
}
 
SumNum2(789)
##  [1] 85
 
SumNum3(789)
##  [1] 85

同样可以比较一下这种方法的效率

system.time(for(i in 1:100000000) SumNum(5678))
##    用户   系统   流逝 
##  111.90   0.19 164.34 
 
system.time(for(i in 1:100000000) SumNum2(5678))
##    用户   系统   流逝 
##  101.15   0.13 147.14 
 
system.time(for(i in 1:100000000) SumNum3(5678))
##    用户   系统   流逝 
##   88.14   0.12 127.79

我们通常写一个数字如果不说明默认是十进制的，也就是456=4×10² + 5×10¹ + 6×10⁰。而十六进制的456₁₆=4×16² + 5×16¹ + 6×16⁰。正如我们要求取一个十进制数字的各位数字一样，十进制的数转成16进制的时候，也是一个不断求余和整除的过程。对于16进制数，0~9还不够，后边接着用A-F表示10-15。
为了方便理解，我们先来看看怎么取出十进制数的各位上边的数。

N <- 456
while(N > 0){
  print(N %% 10)
  N <- N %/% 10
}
##  [1] 6
##  [1] 5
##  [1] 4

我们来分布展示计算结果，以便大家知道运行过程：

N <- 456
i <- 0
while(N > 0){
  i <- i + 1
  M <- N %% 10
  N <- N %/% 10
  print(sprintf("第%d次迭代，除以10取余数得%d，整除以10之后得到%d", i, M, N))
}
[1] "第1次迭代，除以10取余数得6，整除以10之后得到45"
[1] "第2次迭代，除以10取余数得5，整除以10之后得到4"
[1] "第3次迭代，除以10取余数得4，整除以10之后得到0"

同样得道理，在十进制转十六进制时，以16作为除数，这样来求十六进制各位上的数

N <- 2510
while(N > 0){
  print(N %% 16)
  N <- N %/% 16 
}
##  [1] 14
##  [1] 12
##  [1] 9

这里的2510是十进制数，这里依次得到14、12、9，对应16进制的数字未E、C、9，正好9×16^2+12×16^1+14×16^0 = 2510。

N <- 2510
i <- 0
while(N > 0){
  i <- i + 1
  M <- N %% 16
  N <- N %/% 16
  print(sprintf("第%d次迭代，除以16取余数得%d，整除以16之后得到%d", i, M, N))
}
##  [1] "第1次迭代，除以16取余数得14，整除以16之后得到156"
##  [1] "第2次迭代，除以16取余数得12，整除以16之后得到9"
##  [1] "第3次迭代，除以16取余数得9，整除以16之后得到0"

从上边计算的记过，就可以知道，十进制数2510表示为十六进制则为9CE。我们只需要把while循环中得到的余数转成十六进制表示，然后每一次迭代得到的加在前边即可。这样，我们可以写一个函数来转：

Dec2Hex <- function(N){
  D2H <- c(0:9, LETTERS[1:6])
  names(D2H) <- as.character(0:15)
  HEX <- ""
  while(N > 0){
    HEX <- paste(D2H[as.character(N %% 16)], HEX, sep="")
    N <- N %/% 16
  }
  return(HEX)
}
 
Dec2Hex(2510)
##  [1] "9CE"
Dec2Hex(3721)
##  [1] "E89"
Dec2Hex(255)
##  [1] "FF"