R的向量类型和相关函数
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
R中数据类型
- 数值型，数值可以用于直接结算，加减乘除：
- 字符串型，可以进行连接，转换，提取等：
- 逻辑型，真或者假；
- 日期型等；
普通数据结构： 向量，标量、列表、数组、多维数组
特殊数据结构：
- perl中的哈希
- python中的字典
- C语言中的指针等
R对象
对象：object,它是指可以赋值给变量的任何事物,包括常量、数据结构、函数，甚至图形。对象都拥有某种模式，描述了此对象是如何存储的，以及某个类。
向量
向量，vector,是R中最重要的一个概念，它是构成其他数据结构的基础。R中的向量概念与数学中向量是不同的，类似于数学上的集合的概念，由一个或多个元素所构成。
向量其实是用于存储数值型、字符型或逻辑型数据的一维数组。
用函数c来创建向量。c代表concatenate连接，也可以理解为收集collect,或者合并combine
<- 赋值号快捷键 为 Alt 和— 号，字符串要加引号
> x <- c(1,4,5,2)
> x
[1] 1 4 5 2
> print(x)
[1] 1 4 5 2
> y <- c("one","two","three")
> y
[1] "one" "two" "three"
> print
> print(y)
[1] "one" "two" "three"
#逻辑型数据
> z <- c(T,T,F)
> z
可以用一些快捷方式构建向量 比如 ：可以用来构建等差数列
> c(1:100)
[1] 1 2 3 4 5 6 7 8
[9] 9 10 11 12 13 14 15 16
[17] 17 18 19 20 21 22 23 24
[25] 25 26 27 28 29 30 31 32
[33] 33 34 35 36 37 38 39 40
[41] 41 42 43 44 45 46 47 48
[49] 49 50 51 52 53 54 55 56
[57] 57 58 59 60 61 62 63 64
[65] 65 66 67 68 69 70 71 72
[73] 73 74 75 76 77 78 79 80
[81] 81 82 83 84 85 86 87 88
[89] 89 90 91 92 93 94 95 96
[97] 97 98 99 100
可以使用seq函数 调整等差差值，from为起始值，to为终止值，by设置等差值，等差值默认为1 。
> seq(from=1,to=100,by=3)
[1] 1 4 7 10 13 16 19 22 25
[10] 28 31 34 37 40 43 46 49 52
[19] 55 58 61 64 67 70 73 76 79
[28] 82 85 88 91 94 97 100
length.out用来控制元素输出个数，等差的值相应变大。
> seq(from=1,to=100,length.out=10)
[1] 1 12 23 34 45 56 67 78 89
[10] 100
重复序列使用rep函数，第一个参数为重复的内容，可以是标量或向量，times为重复的次数，可以省略
> ?rep
> rep(23,5)
[1] 23 23 23 23 23
> x <- c(1,2,3,4,5)
> rep(x,5)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3
[19] 4 5 1 2 3 4 5
each参数为每个元素重复的次数
> rep(x,each=5)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4
[19] 4 4 5 5 5 5 5
each和times组合使用，则重复次数为他们的乘积
> rep(x,each=5,times=2)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4
[19] 4 4 5 5 5 5 5 1 1 1 1 1 2 2 2 2 2 3
[37] 3 3 3 3 4 4 4 4 4 5 5 5 5 5
向量只能是同一类型，不能混合使用，同一类型才能进行计算，查看向量类型可以使用mode（）或者typeof（）函数。
> z <- c(T,T,F)
> mode(z)
[1] "logical"
> typeof(z)
[1] "logical"
如果向量中只有一个数，可以不用c函数来创建向量，直接赋值
> a = 2
> b =3
> c ="hello"
> c
[1] "hello"
> b
[1] 3
> a
[1] 2
向量是R与其他编程语言最大的不同，其他编程语言中没有向量，R中最基础的数据结构是一个集合，而不是一个标量，被称为向量化编程。R之所以使用向量化编程是因为R是统计软件，其作用为统计。向量化编程有很多的好处，如：避免使用循环
X集合中的每个元素都扩大一倍 与y集合对应的数值相加
> x <- c(1,2,3,4,5)
> y <- c(6,7,8,9,10)
> x*2+y
[1] 8 11 14 17 20
x中取出x>3的值
> x <- c(1,2,3,4,5)
> x[x>3]
[1] 4 5
在rep函数中使用向量单独控制每个元素的重复次数
> x <- c(1,2,3,4,5)
> rep(x,c(2,7,2,3,5))
[1] 1 1 2 2 2 2 2 2 2 3 3 4 4 4 5 5 5 5
[19] 5
向量索引
- 正（负）整数索引；
- 逻辑向量索引；
- 名称索引；
访问向量中的元素，R中元素是从1开始，而不是从0开始
> x <- c(1:50) #为x赋值等差数列1到50
> x
[1] 1 2 3 4 5 6 7 8 9 10
[11] 11 12 13 14 15 16 17 18 19 20
[21] 21 22 23 24 25 26 27 28 29 30
[31] 31 32 33 34 35 36 37 38 39 40
[41] 41 42 43 44 45 46 47 48 49 50
> length(x) #输出元素个数
[1] 50
> x[1] #输出第一个元素值
[1] 1
> x[-19] #不输出第19个元素
[1] 1 2 3 4 5 6 7 8 9 10
[11] 11 12 13 14 15 16 17 18 20 21
[21] 22 23 24 25 26 27 28 29 30 31
[31] 32 33 34 35 36 37 38 39 40 41
[41] 42 43 44 45 46 47 48 49 50
索引也可以使用向量，可以一次性访问多个元素
> x[c(5:20)]
[1] 5 6 7 8 9 10 11 12 13 14
[11] 15 16 17 18 19 20
> x[c(1,25,30,35)]
[1] 1 25 30 35
> x[c(20,20,5,5,50,50,12,12)]#可以无序，也可以多次访问同一个元素
[1] 20 20 5 5 50 50 12 12
索引中只能全是正数或负数，不能既有正数又有负数
> x[-2,5,6]
Error in x[-2, 5, 6] : incorrect number of dimensions
使用逻辑向量进行向量的索引，逻辑值为true则输出，false则不输出
> y <- c(1:10)
> y
[1] 1 2 3 4 5 6 7 8 9 10
> y[c(T,T,F,T,F,T,F,F,T,T)]
[1] 1 2 4 6 9 10
逻辑值的数目不一定要和元素个数相等，也可以循环使用
> y <- c(1:10)
> y
[1] 1 2 3 4 5 6 7 8 9 10
> y[c(T)] #循环输出
[1] 1 2 3 4 5 6 7 8 9 10
> y[c(F)] #循环不输出
integer(0)
> y[c(T,F)] #循环输出和不输出
[1] 1 3 5 7 9
> y[c(T,F,F)] # 循环输出，不输出，不输出
[1] 1 4 7 10
> y[c(T,T,F,T,F,T,F,F,T,T,T)] #产生缺失值
[1] 1 2 4 6 9 10 NA
不仅可以在索引中给出逻辑值，而且可以直接给出判断表达式
> y <- c(1:10)
> y
[1] 1 2 3 4 5 6 7 8 9 10
> y[y>5]
[1] 6 7 8 9 10
> y[y>5 & y<9]
[1] 6 7 8
在 字符串中，%in%表示元素是否在向量中
> z <- c("one","two","treen","four","five")
> z
[1] "one" "two" "treen"
[4] "four" "five"
> "one" %in% z
[1] TRUE
可以将 %in%添加至索引中
> z[z %in% c("one","two")]
[1] "one" "two"
> z %in% c("one","two")
[1] TRUE TRUE FALSE FALSE FALSE
> k <- z %in% c("one","two")
> z[k]
[1] "one" "two"
可以利用元素名称访问向量，可以使用names元素为向量的每个元素添加名称，输出向量y，有两行，一行是元素名称，称为name属性，一行是向量元素值，我们称为value。
> y
[1] 1 2 3 4 5 6 7 8 9 10
> names(y)
NULL
> names(y) <- c("one","two","treen","four","five","six","seven","eight","nine","ten")
> y
one two treen four five six seven eight nine ten
1 2 3 4 5 6 7 8 9 10
通过名称访问
> names(y)
[1] "one" "two" "treen" "four" "five" "six" "seven" "eight"
[9] "nine" "ten"
> y["two"]
two
2
修改向量
添加元素
> x <- c(1:50)
> x
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
[24] 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
[47] 47 48 49 50
> x[51] <- 51
> x
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
[24] 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
[47] 47 48 49 50 51
> v <- 1:3
> v[c(4,5,6)] <- c(4,5,6)
> v
[1] 1 2 3 4 5 6
插入和删除元素
> append(x=v,values = 99,after = 5)
[1] 1 2 3 4 5 99 6
> rm(v)
> v
Error: object 'v' not found
删除向量中的某个元素，采用负整数索引
> y
one two treen four five six seven eight nine ten
1 2 3 4 5 6 7 8 9 10
> y[-c(1:3)]
four five six seven eight nine ten
4 5 6 7 8 9 10
> y <- y[-c(1:3)]
> y
four five six seven eight nine ten
4 5 6 7 8 9 10
向量运算
向量运算是对每个元素操作
> x <- 1:10
> x
[1] 1 2 3 4 5 6 7 8 9 10
> x+1
[1] 2 3 4 5 6 7 8 9 10 11
> x-3
[1] -2 -1 0 1 2 3 4 5 6 7
> x <- x+1
> x
[1] 2 3 4 5 6 7 8 9 10 11
> x
[1] 2 3 4 5 6 7 8 9 10 11
> y <- seq(1,100,length.out=10)
> y
[1] 1 12 23 34 45 56 67 78 89 100
> x+y
[1] 3 15 27 39 51 63 75 87 99 111
> x**y #乘幂运算
[1] 2.000000e+00 5.314410e+05 7.036874e+13 5.820766e+23
[5] 1.039456e+35 2.115876e+47 3.213876e+60 2.697216e+74
[9] 1.000000e+89 1.378061e+104
> x%%y #求余运算
[1] 0 3 4 5 6 7 8 9 10 11
> y%/%x #整除运算
[1] 0 4 5 6 7 8 8 8 8 9
循环叠加运算（较短的向量会循环使用）
> z <- c(1,2)
> x
[1] 2 3 4 5 6 7 8 9 10 11
> x+z
[1] 3 5 5 7 7 9 9 11 11 13
向量个数不匹配，则会报错。（长的向量必须是短的向量的倍数，才可以循环）
> z <- 1:3
> x+z
[1] 3 5 7 6 8 10 9 11 13 12
Warning message:
In x + z : longer object length is not a multiple of shorter object length
包含运算符作用是测试左边的元素是否存在右边的元素
> c(1,2,3) %in% c(1,2,2,4,5,6)
[1] TRUE TRUE FALSE
> x
[1] 2 3 4 5 6 7 8 9 10 11
> y
[1] 1 12 23 34 45 56 67 78 89 100
> x==y
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
向量计算的函数
> x <- -5:5
> x
[1] -5 -4 -3 -2 -1 0 1 2 3 4 5
> abs(x) #取绝对值
[1] 5 4 3 2 1 0 1 2 3 4 5
> sqrt(25) #计算平方根
[1] 5
> log(16,base =2) #计算以2为底的对数
[1] 4
> log10(100) #计算以10为底的对数
[1] 2
> exp(x) #计算向量中每个元素的指数
[1] 6.737947e-03 1.831564e-02 4.978707e-02 1.353353e-01
[5] 3.678794e-01 1.000000e+00 2.718282e+00 7.389056e+00
[9] 2.008554e+01 5.459815e+01 1.484132e+02
#ceiling函数返回不小于x的最小整数
> ceiling(c(-2.3,3.1415))
[1] -2 4
#floor函数返回不大于x的最小整数
> floor(c(-2.3,3.1415))
[1] -3 3
#trunc函数返回整数部分
> trunc(c(-2.3,3.1415))
[1] -2 3
#round函数用于四舍五入，digits用于保留位数
> round(c(-2.3,3.1415))
[1] -2 3
> round(c(-2.3,3.1415),digits = 2)
[1] -2.30 3.14
#signif函数和round函数类似，只不过保留有些位数
> signif(c(-2.3,3.1415),digits = 2)
[1] -2.3 3.1
#三角函数
> x
[1] -5 -4 -3 -2 -1 0 1 2 3 4 5
> sin(x)
[1] 0.9589243 0.7568025 -0.1411200 -0.9092974 -0.8414710
[6] 0.0000000 0.8414710 0.9092974 0.1411200 -0.7568025
[11] -0.9589243
> cos(x)
[1] 0.2836622 -0.6536436 -0.9899925 -0.4161468 0.5403023
[6] 1.0000000 0.5403023 -0.4161468 -0.9899925 -0.6536436
[11] 0.2836622
统计函数
> vec <- 1:50
> sum(vec) #返回向量求和
[1] 1275
> max(vec) #返回向量最大值
[1] 50
> min(vec) #返回向量最小值
[1] 1
> range(vec) #返回向量范围
[1] 1 50
> mean(vec) #返回向量平均值
[1] 25.5
> var(vec) #返回向量方差
[1] 212.5
> round(var(vec),digits = 2) #round函数设置保留的两位小数
[1] 212.5
> round(sd(vec),digits = 2)#sd函数返回标准差，round函数保留两位小数
[1] 14.58
> prod(vec) #prod函数返回向量连乘积
[1] 3.041409e+64
> median(vec) #midine函数计算中位数
[1] 25.5
#quantile（）是分位数函数，第N个分位数就表示数据集中有N%的数据小于它。
> quantile(vec,c(0.4,0.5,0.8)) #quantile函数计算分位数
40% 50% 80%
20.6 25.5 40.2
#返回位置索引值
> t <- c(1,4,2,5,9,7,6)
> t
[1] 1 4 2 5 9 7 6
> which.max(t)
[1] 5
> which.min(t)
[1] 1
> which(t==7)
[1] 6
> which(t>5)
[1] 5 6 7