5 基本数据结构

5.1 向量

向量是用”c()”符号包裹的一组相同类型元素构成的东西。如果每个元素有名字，则叫具名向量。

C1 = c(1,2,3)
C2 = c("a","b","c")
C3 = c(TRUE,FALSE)

class()可以查看向量的类型，可以看到C1是数字型，C2是字符型，C3是逻辑型

class(C1)

[1] "numeric"

class(C2)

[1] "character"

class(C3)

[1] "logical"

如果我非要把不同类型的元素放到一起呢

c4 = c(123,"a",TRUE)
class(c4)

[1] "character"

c4

[1] "123"  "a"    "TRUE"

c5 = c(123,TRUE,FALSE)
class(c5)

[1] "numeric"

c5

[1] 123   1   0

答案是：按照字符型，数字型，逻辑型的顺序保留向量的类型

具名向量

c4 = c("A" = 1,"B"=2,"C" = 3)

c4

A B C 
1 2 3

names(c4)

[1] "A" "B" "C"

c5 = c(1,2,3)
c6 = c("4","5","6")
c7 = c(c5,c6)
c7

[1] "1" "2" "3" "4" "5" "6"

c("1","2","8") %in% c7

[1]  TRUE  TRUE FALSE

c8 = c(11,12,14,15)

c8[1]       # 获取第一个元素

[1] 11

c8[2:3]     # 获取第2到第3个元素

[1] 12 14

c8[-2]      # 获取除了第2个元素之外的元素

[1] 11 14 15

c8[c(TRUE,FALSE,TRUE,FALSE)] # 根据逻辑值，获取元素

[1] 11 14

c8[c8<13]   # 根据条件判断获取元素

[1] 11 12

c4 = c("A" = 1,"B"=2,"C" = 3)
c4["B"]    # 根据名字获取元素

B 
2

c9 = c(-2,2,5,9,9,NA,10)

length(c9)  # 返回长度

[1] 7

unique(c9)  # 返回唯一值

[1] -2  2  5  9 NA 10

sort(c9,decreasing = T)    # 排序

[1] 10  9  9  5  2 -2

min(c9,na.rm = T)   # 最小值

[1] -2

max(c9,na.rm = T)   # 最大值

[1] 10

mean(c9,na.rm = T)  # 平均值

[1] 5.5

sum(c9,na.rm = T)   # 和

[1] 33

sd(c9,na.rm = T)    # 标准差

[1] 4.764452

abs(c9)             # 绝对值

[1]  2  2  5  9  9 NA 10

log(c9,base = 2)    # 对数

Warning: 产生了NaNs

[1]      NaN 1.000000 2.321928 3.169925 3.169925       NA 3.321928

因子是在向量的基础上多了个level。俗称，分类向量。

例如，学生成绩”优”,“良”,“差”

grade = c("差","优","良","良")
grade

[1] "差" "优" "良" "良"

grade2 = factor(grade,levels = c("优","良","差"))
grade2

[1] 差 优 良 良
Levels: 优 良 差

后续画图中尤为常见，可以按照level的水平排序

sort(grade)

[1] "差" "良" "良" "优"

sort(grade2)

[1] 优 良 良 差
Levels: 优 良 差

table(grade2)    # table函数返回各个因子水平的个数

grade2
优 良 差 
 1  2  1

score = c(50,70,95,80)
cut(score,       # cut函数返回因子 
    breaks = c(0,60,90,100),
    labels = c("差","良","优秀"))

[1] 差   良   优秀 良  
Levels: 差 良 优秀

用list()符号包裹住的各种对象，甚至是列表套列表。（熟悉别的编程语言的话，类似与json文件或者python中的字典）

# 定义
list1  =list(
"A" = c(1,2,3),
"B" = factor(c(1,5,6)),
"C" = list(
  "C1" = c(1,3,4)
),
c("q","w","e")
)

list1$A

[1] 1 2 3

list1["A"]

$A
[1] 1 2 3

list1[1]

$A
[1] 1 2 3

list1[[1]]

[1] 1 2 3

unlist()，把列表解开成一个向量

unlist(list1)

   A1    A2    A3    B1    B2    B3 C.C11 C.C12 C.C13                   
  "1"   "2"   "3"   "1"   "2"   "3"   "1"   "3"   "4"   "q"   "w"   "e"

表格结构。

底层是个相同长度的向量构成的列表。

# 定义
# R base 方式

data1 = data.frame(
  "a" = c(1,2,3),
  "b" = c(4,5,6),
  "c" = c(7,8,9)
)
data1

# tibble
data2 = tibble::tibble(
  "a" = c(1,2,3),
  "b" = c(4,5,6),
  "c" = c(7,8,9)
)
data2

# A tibble: 3 x 3
      a     b     c
  <dbl> <dbl> <dbl>
1     1     4     7
2     2     5     8
3     3     6     9

data2[1]   # 访问第一列

# A tibble: 3 x 1
      a
  <dbl>
1     1
2     2
3     3

data2[,1]  # 访问第一列

# A tibble: 3 x 1
      a
  <dbl>
1     1
2     2
3     3

data2[2,1] # 访问第2行第1列

# A tibble: 1 x 1
      a
  <dbl>
1     2

data2["a"] # 访问名字为“a”的列，返回数据框

# A tibble: 3 x 1
      a
  <dbl>
1     1
2     2
3     3

data2$a    # 访问名字为“a”的列，返回向量

[1] 1 2 3

dim(data2)   # 查看数据框，几行几列

[1] 3 3

nrow(data2)  # 数据框，几行

[1] 3

ncol(data2)  # 数据框，几列

[1] 3

str(data2)      # 数据框各列的类型

tibble [3 x 3] (S3: tbl_df/tbl/data.frame)
 $ a: num [1:3] 1 2 3
 $ b: num [1:3] 4 5 6
 $ c: num [1:3] 7 8 9

names(data2)    # 返回列名

[1] "a" "b" "c"

colnames(data2) # 返回列名

[1] "a" "b" "c"

rownames(data2) # 返回行名

[1] "1" "2" "3"

结语：数据框基本上是最常用的数据类型，这个小节，只简单介绍一下数据框，后面的tidyverse系列内容中的dplyr包和tidyr包在重点讲解数据框有关的操作（数据重塑，数据连接，修改列，数据筛选，数据合并，分组汇总等）