1.向量

向量.png

1.1向量赋值

> x <-c(1,2,3,4,5) #num[1:5] 1 2 3 4 5
> x #此时直接输入x，print(x)的省略
[1] 1 2 3 4 5 #直接显示向量

> y <-c("one","two","three") #chr[1:3]"one" "two" "three"；注意一定要加引号。
> y
[1]"one" "two" "three"
> z <-c(TRUE,T,F) #logi[1:3] TRUE TRUE FALSE；不能大小写混写
> z
[1] TRUE TURE FALSE

> c(1:100) #构建等差数列
> seq (from=1,to=100) #从1到100的序列
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16
 [17]  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32
 [33]  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48
 [49]  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64
 [65]  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80
 [81]  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96
 [97]  97  98  99 100

> seq (from=1,to=100,by=2) #从1到100相差2的等差序列
> seq(1,100,2) #seq(from,to,by)为有规律数列
 [1]  1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43
[23] 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87
[45] 89 91 93 95 97 99

> x <- seq(1,10,0.5) #1-10之间相差为0.5的等差序列
> x
 [1]  1.0  1.5  2.0  2.5  3.0  3.5  4.0  4.5  5.0  5.5  6.0  6.5  7.0
[14]  7.5  8.0  8.5  9.0  9.5 10.0

> seq (from=1,to=100,length.out=10) #输出从1到100的10个值，须为等差序列
[1]   1  12  23  34  45  56  67  78  89 100

> rep(1:3,times=2) #将123重复2次
[1] 1 2 3 1 2 3

> rep (2,5) #将2重复5次
[1] 2 2 2 2 2

> rep (x,5)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 #x在上面被赋值为1 2 3 4 5

> rep (x,each=5) #每个元素重复5次
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5

> rep(x,c(2,4,6,1,3)) #x第一个数重复2次，第二个数重复4次……
 [1] 1 1 2 2 2 2 3 3 3 3 3 3 4 5 5 5

> a <-c(1,2,"one") #输入不同类型的向量
[1] "1" "2" "one" #所有向量都变成了字符串

> mode(a) #查看a的向量类型
[1] "numeric"

> 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中大于3的元素
[1] 4 5

1.2向量索引

1.2.1正（负）整数索引

> x=c(1:100) #int[1:100]
[1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16
[17]  17  18  20  21  22  23  24  25  26  27  28  29  30  31  32  33
[33]  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49
[49]  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65
[65]  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81
[81]  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97
[97]  98  99 100
> length(x) #统计x有多少个元素
[1] 100
> x[1] #x中第一个数
[1] 1
> x[0]
integer(0) #提示整数0，搜索不出x中的数字
> x[-19] #输出除了第19个以外的剩余元素
[1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16
[17]  17  18  20  21  22  23  24  25  26  27  28  29  30  31  32  33
[33]  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49
[49]  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65
[65]  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81
[81]  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97
[97]  98  99 100
> x[2:4] #输出第2-4位元素
[1] 2 3 4
> x[c(4:18)] #输出x中第4到第18个元素
[1]  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18
> x[c(2,4,6,8)] #输出x第2，第4，第6，第8个元素
[1] 2 4 6 8
> x[-(2:4)] #输出除了第2-4以外的剩余元素
 [1]   1   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19
[17]  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35
[33]  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51
[49]  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67
[65]  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83
[81]  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99
[97] 100
> x[c(-2,3,4)] #逻辑矛盾，报错
Error in x[c(-2, 3, 4)] : only 0's may be mixed with negative subscripts
> x[x==10] #输出等于10的元素
[1] 10
> x[x<0] #输出小于0的元素
integer(0) #提示没有改元素
> x[x %in% c(1,2,5)] #输出x在向量c（1,2,5）中的元素
[1] 1 2 5

1.2.2逻辑向量索引

> y <- c(1:10)
> y[c(T,F,T,T,F,F,T,T,T,F)]
[1] 1 3 4 7 8 9 #只输出逻辑值为TRUE的元素
> y <- c(1:10)
> y[c(T)] #只有一个逻辑值时，将所有元素一起判断
[1]   1   2   3   4   5   6   7   8   9  10
> y[c(F)]
integer(0) #全部为假，全不输出
> y[c(T,F)] #循环判断，T F T F T F T F T F 
[1] 1 3 5 7 9
> y[c(T,F,F)] #循环判断，T F F T F F T F F T
[1]  1  4  7 10
> y[c(T,F,T,T,F,F,T,T,T,F,T)] #逻辑值比数值多了一位
[1]  1  3  4  7  8  9 NA #NA缺失值
> y[y>5 & y<9]
[1] 6 7 8
> z <- c("one","two","three","four","five")
> "one" %in% z #"one"是否在z中
#%in%相当于math()函数的一个缩写。用来判断一个数组或者矩阵是否包含另一个数组或矩阵
[1] TRUE
> z["one" %in% z] #“one” %in% z 是判断字符串是否是z的元素，返回逻辑值；相当于z[T]
> z[z %in% c("one","two")]  #相当于z[T,T,F,F,F]
[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" #在索引中只输出TRUE的元素（前两个）

1.2.3名称索引

> names(y) <- c("one","two","three","four","five","six","seven","eight","nine","ten") #添加名称
> y
  one   two three  four  five   six seven eight  nine   ten  #元素名称，name的属性。类似perl中的哈希结构
    1     2     3     4     5     6     7     8     9    10 #元素值，name的value 。可通过元素的name访问元素值
> names(y)
 [1] "one"   "two"   "three" "four"  "five"  "six"   "seven" "eight"
 [9] "nine"  "ten"  

1.2.4修改向量

添加元素：

> x
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16
 [17]  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32
 [33]  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48
 [49]  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64
 [65]  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80
 [81]  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96
 [97]  97  98  99 100
> x[101] <- 101 #添加单个元素
> x
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16
 [17]  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32
 [33]  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48
 [49]  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64
 [65]  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80
 [81]  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96
 [97]  97  98  99 100 101

> v <- 1:3
> v
[1] 1 2 3
> v[c(4,5,6)] <- c(4,5,6) #批量赋值，添加多个元素
> v
[1] 1 2 3 4 5 6

> v[20] <- 4
> v
 [1]  1  2  3  4  5  6 NA NA NA NA NA NA NA NA NA NA NA NA NA  4 #向量被扩展成20个元素，没有被赋值的元素为NA

> append(x=v,values=99,after=5) #在第5个元素后插入数值99
 [1]  1  2  3  4  5 99  6 NA NA NA NA NA NA NA NA NA NA NA NA NA  4

> append(x=v,values=99,after=0) #在向量的头部插入数据99
 [1] 99  1  2  3  4  5  6 NA NA NA NA NA NA NA NA NA NA NA NA NA  4

删除向量

> rm(v) #删除向量v
> v
Error: object 'v' not found

> y[-c(1:3)] #索引y函数中1-3以外的值
 four  five   six seven eight  nine   ten 
    4     5     6     7     8     9    10 
> y <- y[-c(1:3)] #将索引结果赋值y
> y
 four  five   six seven eight  nine   ten 
    4     5     6     7     8     9    10

改变向量中某个元素的值

> y["four"] <- 100 #直接将值赋值到索引
> y
 four  five   six seven eight  nine   ten 
  100     5     6     7     8     9    10 

> v[2]
[1] 2
> v[2] <- 15 #将15赋值到v索引到的第二个数
> v[2]
[1] 15
> v[2] <- "one" #如果在num的向量里赋值了chr
> v
[1] "1"   "one" "3"   "4"   "5"   "6"  #所有的num都变成了chr

2.数据框

2.1概念

• 实质上是一个列表
• 列表中的元素是向量
• 向量构成数据框的列
• 每一列必须具有相同长度
• 数据框是矩形结构
• 数据框的列必须命名

数据框与数据集对比

数据框与矩阵

• 数据框形状上很像矩阵
• 数据框是比较规则的列表
• 矩阵必须为同一数据类型
• 数据框每一列必须为同一类型，每一行则不必

2.2数据框

提取元素

> state <- data.frame(state.name,state.abb,state.region,state.x77) #将state.name,state.abb,state.region,state.x77这四个数据框合并成一个名为“state”的数据框
> state[1] #输出数据框的第1列
> state[c(2,4)] #输出第2和第4列
> state[-c(2,4)] #输出除第2和第4列以外，剩下的数据
> state[,"state.abb"] #输出state.abb列
> state["Alabama",] #输出Albama行
> state$Murder #输出Murder列
> state$state.name #输出state.name列

做图

> women #输出15名女性的身高体重
   height weight
1      58    115
2      59    117
3      60    120
4      61    123
5      62    126
6      63    129
7      64    132
8      65    135
9      66    139
10     67    142
11     68    146
12     69    150
13     70    154
14     71    159
15     72    164
> plot(women$height,women$weight) #绘制身高和体重的散点图

> lm (weight ~height,data = women) #lm线性回归的时候给出列名即可

Call:
lm(formula = weight ~ height, data = women)

Coefficients:
(Intercept)       height  
     -87.52         3.45

> attach(mtcars) #加载名为mtcars的数据框到R搜索目录中，之后直接敲击列名即可使用数据
> detach(mtcars) #取消加载
> with(mtcars,{hp}) #输出名为mtcars的数据框中，列名为hp的数据

TIPS：

• 在Console中输入命令
• 表格在R语言中改名叫数据框

• 要理解代码的含义
  -单双中括号的区别

  
  
  单双中括号的经典解释

今天观看的视频编号为
P16 P17 P18 P22