[关闭]
@evilking 2017-10-15T02:37:46.000000Z 字数 4998 阅读 1037

R基础篇

数据框

数据框同样是R中非常重要也是最常用的数据结构之一，一般可以用来操作数据表

从直观上看，数据框类似于矩阵，有行和列两个维度，与矩阵不同的是，数据框的每列可以具有不同的模式(mode)，例如一列是数值型数据，另一列是字符型数据

从技术层面而言，数据框是每个组件长度都相等的列表，按列排列存储

创建数据框

  1. > id <- c(1:5)
  3. > name <- c("Tom","Jack","Rose","Ketty","Hello")
  5. > salary <- seq(from=2000,to=6000,by=1000)
  7. > (x <- data.frame(id,name,salary,stringsAsFactors = FALSE))
  8.   id  name salary
  9. 1  1   Tom   2000
  10. 2  2  Jack   3000
  11. 3  3  Rose   4000
  12. 4  4 Ketty   5000
  13. 5  5 Hello   6000
  15. > names(x)
  16. [1] "id"     "name"   "salary"
  17. >

实例代码的前三句好理解，就是分别生成了三个长度为5的向量，最后一句就是利用data.frame()来生成数据框

该函数的前面三个参数表示三个向量，作为数据源来填充数据框，按列排列，每个向量在数据框中就成了一个字段，字段名即为向量对象的字符串名

最后一个stringsAsFactors=FALSE参数就表示不将字符串自动转换为“因子”(factor)，保留字符串的属性，该参数默认去TRUE，表示会自动将字符串转换为“因子”

关于因子的概念我们在后面篇幅中专门讲解

一般使用read.table()等函数从文件中读取数据，读取的结果也是一个数据框，例如我们在R的工作空间中创建一个文件my_data_frame.txt，内容为：

  1. "id" "name" "salary"
  2. 1 "Tom" 2000
  3. 2 "Jack" 3000
  4. 3 "Rose" 4000
  5. 4 "Ketty" 5000
  6. 5 "Hello" 6000

则用R代码去读取这个文件：

  1. > y <- read.table("my_data_frame.txt",header = TRUE)
  3. > y
  4.   id  name salary
  5. 1  1   Tom   2000
  6. 2  2  Jack   3000
  7. 3  3  Rose   4000
  8. 4  4 Ketty   5000
  9. 5  5 Hello   6000
  11. > class(y)  #查看读取数据后的结果对象的类型
  12. [1] "data.frame"
  13. >

对象y的第一列显示的是行索引，第一行表示的是列的字段名，查看对象y的数据类型为"data.frame"，可知读取文件数据的结果创建了一个数据框

这里使用的read.table()函数部分，在后面的基础篇之文件数据的存储于读取的文章中会详细讲解，现在可以暂时不用过多理会

数据框的值操作

访问数据框

  1. > x     #使用的数据框
  2.   id  name salary
  3. 1  1   Tom   2000
  4. 2  2  Jack   3000
  5. 3  3  Rose   4000
  6. 4  4 Ketty   5000
  7. 5  5 Hello   6000
  9. > x[[1]]    #按数字索引的方式访问数据框字段
  10. [1] 1 2 3 4 5
  12. > x[["name"]]   #按字段名的方式访问数据框
  13. [1] "Tom"   "Jack"  "Rose"  "Ketty" "Hello"
  15. > x$salary  #用$符合访问字段
  16. [1] 2000 3000 4000 5000 6000
  18. > x[,1] #使用类似于访问矩阵的方式访问数据框
  19. [1] 1 2 3 4 5
  20. > class(x[,1])
  21. [1] "integer"
  23. > x[2:4,2]  #用类似于矩阵的方式提取子数据框
  24. [1] "Jack"  "Rose"  "Ketty"
  25. > mode(x[2:4,2])    #自动降维成向量
  26. [1] "character"
  28. > x[2:4,2,drop = FALSE] #使用drop =FALSE参数保持数据框属性
  29.    name
  30. 2  Jack
  31. 3  Rose
  32. 4 Ketty
  33. > class(x[2:4,2,drop = FALSE])
  34. [1] "data.frame"
  35. >
  37. > x[2:4,2:3]    #子数据框自动变成了列表
  38.    name salary
  39. 2  Jack   3000
  40. 3  Rose   4000
  41. 4 Ketty   5000
  43. > mode(x[2:4,2:3])
  44. [1] "list"
  46. > x[1:2]    #类似于列表，以单括号的方式访问数据框，结果为子数据框
  47.   id  name
  48. 1  1   Tom
  49. 2  2  Jack
  50. 3  3  Rose
  51. 4  4 Ketty
  52. 5  5 Hello
  54. > class(x[["name"]])    #查看字段的类型
  55. [1] "character"
  57. > class(x[1])   #单括号索引访问结果为子数据框
  58. [1] "data.frame"
  60. > str(x)    #使用str()函数查看对象的内部结构
  61. 'data.frame':   5 obs. of  3 variables:
  62.  $ id    : int  1 2 3 4 5
  63.  $ name  : chr  "Tom" "Jack" "Rose" "Ketty" ...
  64.  $ salary: num  2000 3000 4000 5000 6000
  65. >

上述实例代码展示了四种访问数据框的方法，可以使用[[1]]数字索引访问第几列元素，使用[["name"]]字段名索引访问指定列元素，使用$salary$符合的方式访问指定列元素，以及使用类似于[2:4,2]矩阵取值操作的方式访问数据框元素，这也是提取子数据框的方法

其中x[1:2]的用法类似于列表，可以提取序列索引对应的列，结果的数据类型为数据框

str()函数很重要，它可以方便的查看R中所以对象的内部结构，包括多少行数据、多少个字段、字段名、每个字段的值是什么，都可以从中清楚的获知。当我们在用别人的库时，函数调用返回的对象不知道有哪些变量，就可以使用该函数查看

向数据框中添加列或行

  1. > x
  2.   id  name salary
  3. 1  1   Tom   2000
  4. 2  2  Jack   3000
  5. 3  3  Rose   4000
  6. 4  4 Ketty   5000
  7. 5  5 Hello   6000
  9. > (x <- rbind(x,list(6,"World",7000)))  #行绑定，向数据框中添加新行
  10.   id  name salary
  11. 1  1   Tom   2000
  12. 2  2  Jack   3000
  13. 3  3  Rose   4000
  14. 4  4 Ketty   5000
  15. 5  5 Hello   6000
  16. 6  6 World   7000
  18.  > (x <- cbind(x,flag = TRUE,new = x$id))  #列绑定，向数据框中添加新列，这里还用到了循环补齐
  19.   id  name salary flag new
  20. 1  1   Tom   2000 TRUE   1
  21. 2  2  Jack   3000 TRUE   2
  22. 3  3  Rose   4000 TRUE   3
  23. 4  4 Ketty   5000 TRUE   4
  24. 5  5 Hello   6000 TRUE   5
  25. 6  6 World   7000 TRUE   6
  27. > x[4:5] <- NULL    #删除序列索引指定的列
  28. > x
  29.   id  name salary
  30. 1  1   Tom   2000
  31. 2  2  Jack   3000
  32. 3  3  Rose   4000
  33. 4  4 Ketty   5000
  34. 5  5 Hello   6000
  35. 6  6 World   7000
  36. >

类似于矩阵的添加行或列，数据框也是使用的rbind()函数添加新行，使用cbind()函数添加新列；当要删除列时，可将对应的列设为NULL即可
————————————————————————————————————
修改列名

  1. > x
  2.   id  name salary
  3. 1  1   Tom   2000
  4. 2  2  Jack   3000
  5. 3  3  Rose   4000
  6. 4  4 Ketty   5000
  7. 5  5 Hello   6000
  8. 6  6 World   7000
  10. > names(x) <- c(names(x)[1:2],"old_salary")   #修改第三列字段的字段名
  11. > x
  12.   id  name old_salary
  13. 1  1   Tom       2000
  14. 2  2  Jack       3000
  15. 3  3  Rose       4000
  16. 4  4 Ketty       5000
  17. 5  5 Hello       6000
  18. 6  6 World       7000
  20. > names(x) <- NULL  #删除字段名
  21. > x
  22. 1 1   Tom 2000
  23. 2 2  Jack 3000
  24. 3 3  Rose 4000
  25. 4 4 Ketty 5000
  26. 5 5 Hello 6000
  27. 6 6 World 7000
  28. >

数据框也可以用names()函数来查看和修改字段名，若要删除字段名，只需要将names(x)设为NULL即可

数据框上应用函数

  1. > x
  3. 1 1   Tom 2000
  4. 2 2  Jack 3000
  5. 3 3  Rose 4000
  6. 4 4 Ketty 5000
  7. 5 5 Hello 6000
  8. 6 6 World 7000
  10. > apply(x,2,max)    #对每一列使用max()函数
  11. [1] "6"     "World" "7000" 
  13. > (y <- lapply(x,sort)) #对每列使用sort()函数
  14. [[1]]
  15. [1] 1 2 3 4 5 6
  17. [[2]]
  18. [1] "Hello" "Jack"  "Ketty" "Rose"  "Tom"   "World"
  20. [[3]]
  21. [1] 2000 3000 4000 5000 6000 7000
  23. > (z <- sapply(x,sort))
  24.      [,1] [,2]    [,3]  
  25. [1,] "1"  "Hello" "2000"
  26. [2,] "2"  "Jack"  "3000"
  27. [3,] "3"  "Ketty" "4000"
  28. [4,] "4"  "Rose"  "5000"
  29. [5,] "5"  "Tom"   "6000"
  30. [6,] "6"  "World" "7000"
  31. >

数据框是列表的特例，数据框的列构成了列表的组件，所以也可以在数据框的每列上应用apply()函数和lapply()函数，包括sapply()函数

  1. > x
  2.   id  name salary
  3. 1  1   Tom   2000
  4. 2  2  Jack   3000
  5. 3  3  Rose   4000
  6. 4  4 Ketty   5000
  7. 5  5 Hello   6000
  8. 6  6 World   7000
  9. > y
  10.   id
  11. 1  3
  12. 2  4
  13. 3  5
  14. 4  6
  15. 5  7
  16. 6  8
  18. > merge(x,y)    #按照x和y中共有的字段的值相等来做合并
  19.   id  name salary
  20. 1  3  Rose   4000
  21. 2  4 Ketty   5000
  22. 3  5 Hello   6000
  23. 4  6 World   7000

在关系型数据库中经常会需要合并，即将两张表根据某个共同变量的值相等来组合到一起，join操作；在R中可以用 merge()来实现。比如上例，将x和y按照id字段的相等值合并

  1. > names(y) <- "old_id"
  2. > y
  3.   old_id
  4. 1      3
  5. 2      4
  6. 3      5
  7. 4      6
  8. 5      7
  9. 6      8
  11. > merge(x,y)
  12.    id  name salary old_id
  13. 1   1   Tom   2000      3
  14. 2   2  Jack   3000      3
  15. 3   3  Rose   4000      3
  16. 4   4 Ketty   5000      3
  17. 5   5 Hello   6000      3
  18. 6   6 World   7000      3
  19. 7   1   Tom   2000      4
  20. 8   2  Jack   3000      4
  21. 9   3  Rose   4000      4
  22. 10  4 Ketty   5000      4
  23. 11  5 Hello   6000      4
  24. 12  6 World   7000      4
  25. 13  1   Tom   2000      5
  26. 14  2  Jack   3000      5
  27. 15  3  Rose   4000      5
  28. 16  4 Ketty   5000      5
  29. 17  5 Hello   6000      5
  30. 18  6 World   7000      5
  31. 19  1   Tom   2000      6
  32. 20  2  Jack   3000      6
  33. 21  3  Rose   4000      6
  34. 22  4 Ketty   5000      6
  35. 23  5 Hello   6000      6
  36. 24  6 World   7000      6
  37. 25  1   Tom   2000      7
  38. 26  2  Jack   3000      7
  39. 27  3  Rose   4000      7
  40. 28  4 Ketty   5000      7
  41. 29  5 Hello   6000      7
  42. 30  6 World   7000      7
  43. 31  1   Tom   2000      8
  44. 32  2  Jack   3000      8
  45. 33  3  Rose   4000      8
  46. 34  4 Ketty   5000      8
  47. 35  5 Hello   6000      8
  48. 36  6 World   7000      8
  50. > merge(x,y, by.x = "id", by.y = "old_id")
  51.   id  name salary
  52. 1  3  Rose   4000
  53. 2  4 Ketty   5000
  54. 3  5 Hello   6000
  55. 4  6 World   7000
  56. >

当merge()函数中没有共同的字段时，结果就是全连接操作，也就是两个表做笛卡尔积；如果想按指定的列的值相等做合并操作，可以设置by.x和by.y参数

  1. > x
  2.   id  name salary
  3. 1  1   Tom   2000
  4. 2  2  Jack   3000
  5. 3  3  Rose   4000
  6. 4  4 Ketty   5000
  7. 5  5 Hello   6000
  8. 6  6 World   7000
  10. > x[3:4,3] <- NA
  11. > x         #假设数据框中有缺失值存在
  12.   id  name salary
  13. 1  1   Tom   2000
  14. 2  2  Jack   3000
  15. 3  3  Rose     NA
  16. 4  4 Ketty     NA
  17. 5  5 Hello   6000
  18. 6  6 World   7000
  20. > complete.cases(x) #可以用该函数查看某行是否不存在缺失值
  21. [1]  TRUE  TRUE FALSE FALSE  TRUE  TRUE
  23. > (w <- x[complete.cases(x),])  #提取没有缺失值的行
  24.   id  name salary
  25. 1  1   Tom   2000
  26. 2  2  Jack   3000
  27. 5  5 Hello   6000
  28. 6  6 World   7000
  29. >

若假设数据框中存在缺失值，则可以用complete.cases()函数检查某行是否不存在缺失值，结果是一个boolean型向量，每个元素指示对应的行是否不存在缺失值；若存在，则对应行的值为FALSE，不存在则为TRUE；得到这个指示的索引向量后，便可以提取数据框中不存在缺失值的行

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注