R语言学习：提取R对象的子集

Posted 刘老师医学统计

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了R语言学习：提取R对象的子集相关的知识，希望对你有一定的参考价值。

Subsetting R Objects

取子集的三种基本方法

  • [ ：“单方括号”返回的对象和原来相同，如向量的子集还是向量；也可用于在对象中选择多个元素

  • [ [：“双方括号”仅可用于提取单一元素，并且用来提取列表或者数据框中的元素，但是，由于列表或者数据框中的元素类别不唯一，因此它返回对象的类型不一定是列表或者数据框

  • $ ：“美元符号”是提取有名字的列表或数据框中的一个元素

（一）向量取子集

举例

  1. 单括号+数字索引：

 
   
   
 
    
  
    
    
  
  1. > x <- c("a", "b", "c", "c", "d", "a")  
    2. 
  
    
    
  
  2. > x[2]            ## 提取第二个元素
    3. 
  
    
    
  
  3. [1] "b"
    4. 
  
    
    
  
  4. > x[1:4]          ## 提取连续多个元素
    5. 
  
    
    
  
  5. [1] "a" "b" "c" "c"
    6. 
  
    
    
  
  6. > x[c(1, 3, 4)]   ## 提取不连续的多个元素
    7. 
  
    
    
  
  7. [1] "a" "c" "c"
    8.

2.单括号+逻辑索引（按字母排序）：

 
   
   
 
    
  
    
    
  
  1. > x <- c("a", "b", "c", "c", "d", "a")  
    2. 
  
    
    
  
  2. > x[x > "a"]      ## 提取首字母排序大于a的元素
    3. 
  
    
    
  
  3. [1] "b" "c" "c" "d"
    4.

3.创建逻辑向量

 
   
   
 
    
  
    
    
  
  1. > u <- x > "a"
    2. 
  
    
    
  
  2. > u
    3. 
  
    
    
  
  3. [1] FALSE  TRUE  TRUE  TRUE  TRUE FALSE
    4. 
  
    
    
  
  4. > x[u]
    5. 
  
    
    
  
  5. [1] "b" "c" "c" "d"
    6.

（二）矩阵取子集

矩阵取子集可通过行索引和列索引来完成。

例如以下2*3的矩阵

 
   
   
 
    
  
    
    
  
  1. > x <- matrix(1:6, 2, 3)
    2. 
  
    
    
  
  2. > x
    3. 
  
    
    
  
  3.      [,1] [,2] [,3]
    4. 
  
    
    
  
  4. [1,]    1    3    5
    5. 
  
    
    
  
  5. [2,]    2    4    6
    6. 
  
    
    
  
  6. > x[1, 2]            
    7. 
  
    
    
  
  7. [1] 3
    8. 
  
    
    
  
  8. > x[, 1]
    9. 
  
    
    
  
  9. [1] 1 2
    10. 
  
    
    
  
  10. > x[1, 2, drop = FALSE]   ## 修改drop参数，返回矩阵形式
    11. 
  
    
    
  
  11.      [,1]
    12. 
  
    
    
  
  12. [1,]    3
    13. 
  
    
    
  
  13. > x[, 1, drop = FALSE]
    14. 
  
    
    
  
  14.      [,1]
    15. 
  
    
    
  
  15. [1,]    1
    16. 
  
    
    
  
  16. [2,]    2
    17.

（三）列表取子集

列表取子集既可以使用“[”，"[["，也可以使用“$”

 
   
   
 
    
  
    
    
  
  1. > ## 创建一个含有两个元素的列表
    2. 
  
    
    
  
  2. > x <- list(foo = 1:4, bar = 0.6)
    3. 
  
    
    
  
  3. > x
    4. 
  
    
    
  
  4. $foo
    5. 
  
    
    
  
  5. [1] 1 2 3 4
    6. 
  
    
    
  
    7. 
  
    
    
  
  7. $bar
    8. 
  
    
    
  
  8. [1] 0.6
    9. 
  
    
    
  
  9. > ## 三种方法提取第一个元素
    10. 
  
    
    
  
  10. > x[1]            ## 单方括号返回的也是一个列表
    11. 
  
    
    
  
  11. $foo
    12. 
  
    
    
  
  12. [1] 1 2 3 4
    13. 
  
    
    
  
  13. > x[[1]]
    14. 
  
    
    
  
  14. [1] 1 2 3 4
    15. 
  
    
    
  
  15. > x$foo
    16. 
  
    
    
  
  16. [1] 1 2 3 4
    17.

列表取子集方法的好处是不需要记住顺序，只要有名字就可以。

但是如果要从列表中提取多个元素，只能使用单方括号（双方括号和美元符号只能提取单个元素），并且知道顺序。

 
   
   
 
    
  
    
    
  
  1. > x <- list(foo = 1:4, bar = 0.6, baz = "hello")
    2. 
  
    
    
  
  2. > x[c(1, 3)]
    3. 
  
    
    
  
  3. $foo
    4. 
  
    
    
  
  4. [1] 1 2 3 4
    5. 
  
    
    
  
    6. 
  
    
    
  
  6. $baz
    7. 
  
    
    
  
  7. [1] "hello"
    8.

双方括号和美元符号的区别：

美元符号必须是列表中存在的元素名；

双方括号可以是后续再次赋值变量之后的

 
   
   
 
    
  
    
    
  
  1. > x <- list(foo = 1:4, bar = 0.6, baz = "hello")
    2. 
  
    
    
  
  2. > name <- "foo"
    3. 
  
    
    
  
  3. >
    4. 
  
    
    
  
  4. > ## computed index for "foo"
    5. 
  
    
    
  
  5. > x[[name]]  
    6. 
  
    
    
  
  6. [1] 1 2 3 4
    7. 
  
    
    
  
  7. >
    8. 
  
    
    
  
  8. > ## element "name" doesn’t exist! (but no error here)
    9. 
  
    
    
  
  9. > x$name    
    10. 
  
    
    
  
  10. NULL
    11. 
  
    
    
  
  11. >
    12. 
  
    
    
  
  12. > ## element "foo" does exist
    13. 
  
    
    
  
  13. > x$foo      
    14. 
  
    
    
  
  14. [1] 1 2 3 4
    15.

另外双方括号可以取一个整数数列，不仅仅是一个数字

 
   
   
 
    
  
    
    
  
  1. > x <- list(a = list(10, 12, 14), b = c(3.14, 2.81))
    2. 
  
    
    
  
  2. > 
    3. 
  
    
    
  
  3. > ## Get the 3rd element of the 1st element
    4. 
  
    
    
  
  4. > x[[c(1, 3)]]  
    5. 
  
    
    
  
  5. [1] 14
    6. 
  
    
    
  
  6. > 
    7. 
  
    
    
  
  7. > ## Same as above
    8. 
  
    
    
  
  8. > x[[1]][[3]]  
    9. 
  
    
    
  
  9. [1] 14
    10. 
  
    
    
  
  10. > 
    11. 
  
    
    
  
  11. > ## 1st element of the 2nd element
    12. 
  
    
    
  
  12. > x[[c(2, 1)]]  
    13. 
  
    
    
  
  13. [1] 3.14
    14.

（四）模糊匹配

美元符号$和双方括号[[有模糊匹配的功能。可以通过这种方法在命令行快速查找元素。

例：

 
   
   
 
    
  
    
    
  
  1. > x <- list(aardvark = 1:5)
    2. 
  
    
    
  
  2. > x$a
    3. 
  
    
    
  
  3. [1] 1 2 3 4 5
    4. 
  
    
    
  
  4. > x[["a"]]                 ## 参数默认为精确匹配
    5. 
  
    
    
  
  5. NULL
    6. 
  
    
    
  
  6. > x[["a", exact = FALSE]]  ## 参数设置为不精确匹配
    7. 
  
    
    
  
  7. [1] 1 2 3 4 5
    8.

（五）删除缺失数据和缺失值（NA）

大部分真实数据中包含大量缺失数据，不管是向量、矩阵还是数据框，通过创建一个能够告诉你哪里有缺失值的逻辑向量，从而创建子集来删除它们

is.na() 函数可以找到某个向量中的缺失值，例：

 
   
   
 
    
  
    
    
  
  1. > x <- c(1, 2, NA, 4, NA, 5)
    2. 
  
    
    
  
  2. > bad <- is.na(x)
    3. 
  
    
    
  
  3. > print(bad)
    4. 
  
    
    
  
  4. [1] FALSE FALSE  TRUE FALSE  TRUE FALSE
    5. 
  
    
    
  
  5. > x[!bad]         ## !bad表示非缺失值
    6. 
  
    
    
  
  6. [1] 1 2 4 5
    7.

如果有多个向量、多个对象，NA分布在各个不同地方，目的是去除所有缺失值建立新的子集，可以使用 complete.cases() 函数，如下例：

 
   
   
 
    
  
    
    
  
  1. > x <- c(1, 2, NA, 4, NA, 5)
    2. 
  
    
    
  
  2. > y <- c("a", "b", NA, "d", NA, "f")
    3. 
  
    
    
  
  3. > good <- complete.cases(x, y)
    4. 
  
    
    
  
  4. > good
    5. 
  
    
    
  
  5. [1]  TRUE  TRUE FALSE  TRUE FALSE  TRUE
    6. 
  
    
    
  
  6. > x[good]
    7. 
  
    
    
  
  7. [1] 1 2 4 5
    8. 
  
    
    
  
  8. > y[good]
    9. 
  
    
    
  
  9. [1] "a" "b" "d" "f"
    10.

类似地，如果x，y两个向量的缺失值位置不同， complete.cases() 函数则取并集判断缺失位置：

 
   
   
 
    
  
    
    
  
  1. > x <- c(1, 2, NA, 4, NA, 5)
    2. 
  
    
    
  
  2. > y <- c("a", "b", NA, NA, "d", "f")
    3. 
  
    
    
  
  3. > good <- complete.cases(x, y)
    4. 
  
    
    
  
  4. > good
    5. 
  
    
    
  
  5. [1]  TRUE  TRUE FALSE FALSE FALSE  TRUE
    6. 
  
    
    
  
  6. > 
    7. 
  
    
    
  
  7. > x[good]
    8. 
  
    
    
  
  8. [1] 1 2 5
    9. 
  
    
    
  
  9. > y[good]
    10. 
  
    
    
  
  10. [1] "a" "b" "f"
    11.

complete.cases() 函数也可以用于从数据框中移除缺失值

 
   
   
 
    
  
    
    
  
  1. > ## 创建数据框airquality
    2. 
  
    
    
  
  2. > Ozone <- c(41, 36, 12, 18, NA, 28, 13, 15)
    3. 
  
    
    
  
  3. > Solar.R <- c(190, 118, 149, 313, NA, NA, 244, 222)
    4. 
  
    
    
  
  4. > Wind <- c (7.4, 8.0, 12.1, 11.2, 14.3, 13.9, 14.1, 15.2)
    5. 
  
    
    
  
  5. > Temp <- c(67, 72, 74, 62, 56, 66, 22, 33)
    6. 
  
    
    
  
  6. > Month <- c(5, 5, 5, 5, 5, 5, 5, 5)
    7. 
  
    
    
  
  7. > Day <- c(1, 2, 3, 4, 5, 6, 7, 8)
    8. 
  
    
    
  
  8. > airquality <- data.frame(Ozone, Solar.R, Wind, Temp, Month, Day)
    9. 
  
    
    
  
  9. > airquality
    10. 
  
    
    
  
  10.   Ozone Solar.R Wind Temp Month Day
    11. 
  
    
    
  
  11. 1    41     190  7.4   67     5   1
    12. 
  
    
    
  
  12. 2    36     118  8.0   72     5   2
    13. 
  
    
    
  
  13. 3    12     149 12.1   74     5   3
    14. 
  
    
    
  
  14. 4    18     313 11.2   62     5   4
    15. 
  
    
    
  
  15. 5    NA      NA 14.3   56     5   5
    16. 
  
    
    
  
  16. 6    28      NA 13.9   66     5   6
    17. 
  
    
    
  
  17. 7    13     244 14.1   22     5   7
    18. 
  
    
    
  
  18. 8    15     222 15.2   33     5   8
    19. 
  
    
    
  
  19. >
    20. 
  
    
    
  
  20. > ## 取数据框中的前六行数据
    21. 
  
    
    
  
  21. > head(airquality)
    22. 
  
    
    
  
  22.   Ozone Solar.R Wind Temp Month Day
    23. 
  
    
    
  
  23. 1    41     190  7.4   67     5   1
    24. 
  
    
    
  
  24. 2    36     118  8.0   72     5   2
    25. 
  
    
    
  
  25. 3    12     149 12.6   74     5   3
    26. 
  
    
    
  
  26. 4    18     313 11.5   62     5   4
    27. 
  
    
    
  
  27. 5    NA      NA 14.3   56     5   5
    28. 
  
    
    
  
  28. 6    28      NA 14.9   66     5   6
    29. 
  
    
    
  
  29. >
    30. 
  
    
    
  
  30. > ## 通过创建逻辑向量找到没有缺失数据的行
    31. 
  
    
    
  
  31. > good <- complete.cases(airquality)
    32. 
  
    
    
  
  32. > head(airquality[good, ])
    33. 
  
    
    
  
  33.   Ozone Solar.R Wind Temp Month Day
    34. 
  
    
    
  
  34. 1    41     190  7.4   67     5   1
    35. 
  
    
    
  
  35. 2    36     118  8.0   72     5   2
    36. 
  
    
    
  
  36. 3    12     149 12.6   74     5   3
    37. 
  
    
    
  
  37. 4    18     313 11.5   62     5   4
    38. 
  
    
    
  
  38. 7    23     299  8.6   65     5   7
    39. 
  
    
    
  
  39. 8    19      99 13.8   59     5   8
    40.

（六）提取某种条件下数据框的子集

如上例：

挑取Ozone列中数值大于18，且Temp数值大于60的数据子集，从该子集中计算Wind数据的平均值

 
   
   
 
    
  
    
    
  
  1. > Ozone <- c(41, 36, 12, 18, NA, 28, 13, 15)
    2. 
  
    
    
  
  2. > Solar.R <- c(190, 118, 149, 313, NA, NA, 244, 222)
    3. 
  
    
    
  
  3. > Wind <- c (7.4, 8.0, 12.1, 11.2, 14.3, 13.9, 14.1, 15.2)
    4. 
  
    
    
  
  4. > Temp <- c(67, 72, 74, 62, 56, 66, 22, 33)
    5. 
  
    
    
  
  5. > Month <- c(5, 5, 5, 5, 5, 5, 5, 5)
    6. 
  
    
    
  
  6. > Day <- c(1, 2, 3, 4, 5, 6, 7, 8)
    7. 
  
    
    
  
  7. > data <- data.frame(Ozone, Solar.R, Wind, Temp, Month, Day)
    8. 
  
    
    
  
  8. > data
    9. 
  
    
    
  
  9.   Ozone Solar.R Wind Temp Month Day
    10. 
  
    
    
  
  10. 1    41     190  7.4   67     5   1
    11. 
  
    
    
  
  11. 2    36     118  8.0   72     5   2
    12. 
  
    
    
  
  12. 3    12     149 12.1   74     5   3
    13. 
  
    
    
  
  13. 4    18     313 11.2   62     5   4
    14. 
  
    
    
  
  14. 5    NA      NA 14.3   56     5   5
    15. 
  
    
    
  
  15. 6    28      NA 13.9   66     5   6
    16. 
  
    
    
  
  16. 7    13     244 14.1   22     5   7
    17. 
  
    
    
  
  17. 8    15     222 15.2   33     5   8
    18. 
  
    
    
  
  18. > 
    19. 
  
    
    
  
  19. > ## 设置条件
    20. 
  
    
    
  
  20. > d2 <- data[data$Ozone>18 & data$Temp>60, ]
    21. 
  
    
    
  
  21. > d2
    22. 
  
    
    
  
  22.   Ozone Solar.R Wind Temp Month Day
    23. 
  
    
    
  
  23. 1    41     190  7.4   67     5   1
    24. 
  
    
    
  
  24. 2    36     118  8.0   72     5   2
    25. 
  
    
    
  
  25. 6    28      NA 13.9   66     5   6
    26. 
  
    
    
  
  26. > m <- d2$Wind
    27. 
  
    
    
  
  27. > m
    28. 
  
    
    
  
  28. [1]  7.4  8.0 13.9
    29. 
  
    
    
  
  29. > mean(m)
    30. 
  
    
    
  
  30. [1] 9.766667
    31.



参考资料：

  1. https://bookdown.org/rdpeng/rprogdatascience/R Programming for Data Science

  2. 《R语言实战》 Robert I. Kabacoff

本文来源生信小白学习记


以上是关于R语言学习：提取R对象的子集的主要内容，如果未能解决你的问题，请参考以下文章

R语言中怎么提取时间序列数据框中符合行名称的子集

r语言提取部分数据剩下的数据怎么表示

根据R中的元素名称从列表中提取对象

循环遍历 R 中列名的特定子集

如何根据不同 R 生态系统中的另一个向量重写代码，将函数应用于行子集？

编写一个 R 函数，它只在声明时子集