R语言最基本的数据类型-向量（vector）
1、插入向量元素，同一向量中的所有的元素必须是相同的模式（数据类型），如整型、数值型（浮点数）、字符型（字符串）、逻辑型、复数型等。查看变量的类型可以用typeof(x)函数查询。
> #插入向量元素
> x <- c(88,5,12,13)
> x
[1] 88 5 12 13
> x <- c(x[1:3],168,x[4]) #插入168数字在13之前
> x
[1] 88 5 12 168 13
>
2、删除向量中的元素，由于R中的向量是连续存储的，因此不能插入或删除元素（故上面的插入代码实际上重新创建了一个新的向量然后将x指向新的向量，类似于C中的指针）
> #删除向量中的元素 ^_^
> x
[1] 88 5 12 168 13
> x <- c(88,5,168,13)
> x
[1] 88 5 168 13
>
3、获取向量的长量
> #获取向量的长量
> x
[1] 88 5 168 13
> length(x)
[1] 4
>
4、遍历向量里所有的元素
>#第一种方法 由于1：length(x)=(1,0),实际上做了两次迭代
> first1
function(x){
for(i in 1:length(x)){
if (x[i]==1) break
}
return(i)
}
> y
[1] 1 2 3 4 5 6 7 8
> first1(y)
[1] 1
>
>#第二种方法 用seq函数生成等差序列，元素间隔为1，解决了第一种效率不高的方法
> first2 <- function(x){
+ for(i in seq(x)){
+ if (x[i]==1) break
+ }
+ return(i)
+ }
>
> first2(y)
[1] 1
>
5、向量与数组、矩阵 数组与矩阵包括列表，在某种意义上实际上都是向量。只不过它们还有额外的类属性。如：矩阵有行数和更数等。
> m <- matrix(c(1,2,3,4),nrow = 2,byrow = T)
> m
[,1] [,2]
[1,] 1 2
[2,] 3 4
> m + 10:13
[,1] [,2]
[1,] 11 14
[2,] 14 17
>
在这里2x2的矩阵m中存储为一个四元向量，即（1，2，3，4），并且以存储为两行（默认是以列排序，以行排序加上byrow = T），然后对它加上（10，11，12，13），得最新的矩阵，等效于下面代码
> m <- matrix(c(1,3,2,4),nrow = 2)
> m
[,1] [,2]
[1,] 1 2
[2,] 3 4
> m + 10:13
[,1] [,2]
[1,] 11 14
[2,] 14 17
>
6、循环补齐 在对两个向量使用运算符时，如果要求这两个向量具有相同的长度，R会自动循环补齐（recycle），即重复较短的向量，直到它与另一个向量长度相匹配
> c(1,2,4) + c(6,0,9,20,22)
[1] 7 2 13 21 24
Warning message:
In c(1, 2, 4) + c(6, 0, 9, 20, 22) :
longer object length is not a multiple of shorter object length
>
等同于下列代码：
> c(1,2,4,1,2) + c(6,0,9,20,22)
[1] 7 2 13 21 24
>
#矩阵
> x <- matrix(c(1,2,3,4,5,6),nrow = 3)
> x
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
> x + c(1,2)
[,1] [,2]
[1,] 2 6
[2,] 4 6
[3,] 4 8
>
#矩阵循环补齐
> x <- matrix(c(1,2,3,4,5,6),nrow = 3)
> x
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
> y <- matrix(c(1,2,1,2,1,2),nrow = 3)
> y
[,1] [,2]
[1,] 1 2
[2,] 2 1
[3,] 1 2
> x +y
[,1] [,2]
[1,] 2 6
[2,] 4 6
[3,] 4 8
>
相当于：
7、常用的向量运算 包括算术和逻辑运算、向量索引、创建向量等
#R是一种函数式语言，它的每个运处符（+ - * / 。。。）实际上都是函数
#加法
> 2+3
[1] 5
> "+"(2,3)
[1] 5
>
>c(1,2) + c(3,4)
>[1] 4 6
>
> "+"(2,3,4)
Error in `+`(2, 3, 4) : operator needs one or two arguments >#乘法
> c(1,2) * c(3,4)
[1] 3 8
>#减法
> c(3,4) - c(1,2)
[1] 2 2
>#除法
> c(3,4) / c(1,2)
[1] 3 2
>#取余
> c(3,4) %% c(2,3)
[1] 1 1
>
8、向量索引 R中最重要也是最常的一个运算符就是索引，使用它来选择给定向量中特定索引的元素来构成子向量。索引向量的格式是 X[Y]（X,Y均是向量），它返回的结果是，X中索引为Y的那些元素。
> y <- c(1.2,3.9,0.4,0.12)
> y
[1] 1.20 3.90 0.40 0.12
> y[2:3] #取Y向量中的2-3元素
[1] 3.9 0.4
> v <- 3:4
> y[v]
[1] 0.40 0.12
> y[c(1,1,3)] #提取的元素是可以重复的
[1] 1.2 1.2 0.4
>
#负数的下标代表我们想剔除的元素，其它提取出来
> y
[1] 1.20 3.90 0.40 0.12
> y[-1] #除第一个元素外，提取其它所有的元素
[1] 3.90 0.40 0.12
> y[-1:-2] #除1：2元素外
[1] 0.40 0.12
>
9、用运算符创建向量
#用 ：能生成指定范围内数值构成的向量
> 5:8
[1] 5 6 7 8
> #注意运算符优先级别的问题
> i <- 5
> 1:i-1 #这个运算的意思是 (1:i)-1，不是1:(i-1)
[1] 0 1 2 3 4
> 1:(i-1)
[1] 1 2 3 4
> #查看运算符的优先级别
>?Syntax #可以在R帮助文档中查看
#用seq()创建向量
> seq(1:8)
[1] 1 2 3 4 5 6 7 8
> 1:8 #等同于以上代码
[1] 1 2 3 4 5 6 7 8
> seq(from=5,to=20, by=3) #生成从5-20，且元素间隔为3
[1] 5 8 11 14 17 20
> seq(from=5,to=10, by=0.1) #生成从5-10，且元素间隔为0.1
[1] 5.0 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 6.0 6.1 6.2
[14] 6.3 6.4 6.5 6.6 6.7 6.8 6.9 7.0 7.1 7.2 7.3 7.4 7.5
[27] 7.6 7.7 7.8 7.9 8.0 8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8
[40] 8.9 9.0 9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8 9.9 10.0
>
> seq(from =1.1, to=2, length=10)
[1] 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0
> seq(from =1.1, to=2, length=20) #生成1.1到2，共20个等比数列，常数为0.047368
[1] 1.100000 1.147368 1.194737 1.242105 1.289474 1.336842 1.384211
[8] 1.431579 1.478947 1.526316 1.573684 1.621053 1.668421 1.715789
[15] 1.763158 1.810526 1.857895 1.905263 1.952632 2.000000
>
#等比数列定义
参照：百度百科-等比数列
11、使用 rep()重复向量常数 可以把同一常数放在长向量中，rep(x,times)即创建times*length(x)个元素向量，这个向量是x重复times次构成
> x <- rep(8,4)
> x
[1] 8 8 8 8
> rep(c(5,12,13),3)
[1] 5 12 13 5 12 13 5 12 13
> rep(1:3,2)
[1] 1 2 3 1 2 3
>
#each参数，与times参数不同的是，它指定x交替重复的次数
> rep(c(5,12,13),each=2)
[1] 5 5 12 12 13 13
>
12、使用all()和any() 这两个函数分别判断其参数中是否至少有一个或全部为TRUE
> x <- 1:10
> any(x>8)
[1] TRUE
> all(x>8)
[1] FALSE
> any(x>20)
[1] FALSE
> all(x>20)
[1] FALSE
>
#any(x > 8) all(x > 8)，分解，先执行下面运算，得到每个元素的逻辑值，any只要判断只要有一个为TRUE，其返回结果为：TRUE，否则为FALSE。all则相反，所有为TRUE时返回值才为：TRUE，否则为FALSE。
> x>8
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE
[10] TRUE
>
13、向量化运算符
#向量输入、向量输出
向量化运算即使过运算符的（+，-，*，/，%%，>等），如果一个函数中使用了运算符，哪么这个函数就被向量化了，这样可以有效提高速度
# >运算符 >函数分别运用在u[1]和v[1]得到结果TRUE，然后u[2]和v[2]得到结果FALSE。。。
> u <- c(5,2,8)
> v <- c(1,3,9)
> u > v
[1] TRUE FALSE FALSE
>
#函数 平方根、对数、三角函数等都是向量化的
> w <- function(x) return(x + 1)
> w(u)
[1] 6 3 9
>
> sqrt(1:9)
[1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490
[7] 2.645751 2.828427 3.000000
>
#向量输入、矩阵输出
#matrix() 在z12函数中返回值就是一个八元向量（即输出结果是八个数组成的向量），需要通过matrix函数转换成矩阵，如以下代码，将结果转换成8*2的矩阵
> z12 <- function(z) return(c(z,z^2))
> x <- 1:8
> z12(x)
[1] 1 2 3 4 5 6 7 8 1 4 9 16 25 36 49 64
> matrix(z12(x),ncol = 2)
[,1] [,2]
[1,] 1 1
[2,] 2 4
[3,] 3 9
[4,] 4 16
[5,] 5 25
[6,] 6 36
[7,] 7 49
[8,] 8 64
>
#sapply() 该函数跟matrix功能一样，在这里转换成的是2*8的矩阵，其它参数以后再学习
> sapply(1:8,z12)
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,] 1 2 3 4 5 6 7 8
[2,] 1 4 9 16 25 36 49 64
>
14、NA与NULL值
在R中NA表示：缺失值；NULL表示：不存在的值（而不是存在但未知的值）
#NA
由于以下代码中包含了一个NA元素（缺失值），导致mean()无法计算均值，但是可以通过参数na.rm = T（移除NA）,计算其他元素的均值。
> x <- c(88,NA,12,168,13)
> x
[1] 88 NA 12 168 13
> mean(x)
[1] NA
>
>#NA在不同的向量中模式（数据类型）也不同
> x <- c(88,NA,12,168,13)
> x
[1] 88 NA 12 168 13
> mode(x[2])
[1] "numeric"
> x1 <- c("a","b",NA)
> x1
[1] "a" "b" NA
> mode(x1[3])
[1] "character"
>
#NULL
在R中会自动跳过NULL值，在R中NULL是一种特殊对象，没有类型，可用于变量的初始化值
> x <- c(88,NA,12,168,13)
> x
[1] 88 NA 12 168 13
> mean(x)
[1] NA
>
>#在R中NULL是一种特殊对象，没有类型
> x <- NULL
> mode(x)
[1] "NULL"
> x
NULL
>
15、筛选
反映R函数式语言特性的另一特征是“筛选”（filtering)，我们可以提取向量中满足一定条件的元素。
#生成筛选索引
>#要求R提取z中平方大于8的元素
>z <- c(5,2,-3,8)
> z
[1] 5 2 -3 8
> w <- z[z*z > 8]
> w
[1] 5 -3 8
>
> #等同于以下分解代码
>
> z <- c(5,2,-3,8)
> z
[1] 5 2 -3 8
> z*z > 8
[1] TRUE FALSE TRUE TRUE
> z[c(TRUE,FALSE,TRUE,TRUE)]
[1] 5 -3 8
>
>j <- z*z > 8
>z[j]
>[1] 5 -3 8
#用例：将x向量中所有大于>3的元素，替换为 0。
> x <- c(1,3,6,2,20)
> x
[1] 1 3 6 2 20
> x[x > 3] <- 0
> x
[1] 1 3 0 2 0
>
#使用subset()函数筛选
当对向量使用subset函数时，它与普通的筛选方法的区别在于处理NA值的方式上，可以自动移除NA值
>#筛选出x中元素平方大于5的
> x <- c(6,1:3,NA,12)
> x
[1] 6 1 2 3 NA 12
> x[x > 5]
[1] 6 NA 12
> subset(x,x > 5)
[1] 6 12
>
#选择函数which()
在向量中提取满足一定条件的元素，返回值是元素的所在的位置。
> x
[1] 6 1 2 3 NA 12
> which(x>5)
[1] 1 6 #返回元素位置
> x[which(x>5)]
[1] 6 12
>
16、向量化的ifelse()函数
在R语言中除了有“if-else"结构，还提供了另一个向量货的版本，ifelse()函数，格式为：ifelse(条件，为TRUE返回向量，为FALSE返回向量)
> x <- 1:10
> y <- ifelse(x %% 2 == 0,5,12)#对x值取模运算，偶数返回5，奇数返回12
> y
[1] 12 5 12 5 12 5 12 5 12 5
>
17、测试向量相等
”==“仅对向量元素的值进行比较，identical()函数不仅对比元素的值还对比向量元素的数据类型，正如它字面意思一样必须完全相同，从下面的代码可以看出，：产生的元素是整数，c()产生的是浮点数
> x <- 1:2
> y <-c(1,2)
> x==y
[1] TRUE TRUE
> identical(x,y)
[1] FALSE
> typeof(x)
[1] "integer"
> typeof(y)
[1] "double"
>
18、向量的名称
可以给向量元素随意指定名称，name()函数可以给向量中的元素命名，或查询向量元素的名称，将向量元素的名称赋值为NULL，可以将元素的名称移除
> x <- c(1,2,3,4)
> x
[1] 1 2 3 4
> names(x)
NULL
> names(x) <- c("a","b","c","d")
> names(x)
[1] "a" "b" "c" "d"
> x
a b c d
1 2 3 4
> names(x) <- NULL
> x
[1] 1 2 3 4
> names(x)
NULL
>
19、c()函数扩展
当传递到c()函数中的参数有不同类型时，则会被降级为同一类型，该类型最大限度地保留它们的共同的特性。各种类型的优先级排序是：NULL<raw<逻辑类型<整型<实数类型<复数类型<列表<表达式（把配对列表(pairlist)当作普通列表）
> c(1,2,"a")
[1] "1" "2" "a"
> c(1,2,list(a=3,b=4))
[[1]]
[1] 1 [[2]]
[1] 2 $a
[1] 3 $b
[1] 4 > c(1,2,c(3.1,4))
[1] 1.0 2.0 3.1 4.0
>
补充c(1,2,list(a=3,b=4))
> x<-c(1,2,list(a=3,b=4))
> x
[[1]]
[1] 1 [[2]]
[1] 2 $a
[1] 3 $b
[1] 4 > x[[1]]
[1] 1
> x[[2]]
[1] 2
> x[3][1]
$a
[1] 3 > x[4][1]
$b
[1] 4 >