• R语言表与因子（详细知识点，深入知识点后续会补充！）

    (1) level表示额外的信息,包含向量中不同值的记录 
    1. > x<-c(5,12,13,12)
    2. > xf<-factor(x)
    3. > xf
    4. [1] 5  12 13 12
    5. Levels: 5 12 13
    6. #xf中不同数值(5,12,13)就是水平
    7.  
    8. >length(xf)
    9. [1] 4
    10. #因子的长度定义为数据的长度,而不是水平的长度
    11.  
    12.  
    13. #可以提前插入新的水平
    14. > x<-c(5,12,13,12)
    15. > xff<-factor(x,levels = c(5,12,13,88))
    16. > xff
    17. [1] 5  12 13 12
    18. Levels: 5 12 13 88
    19. > xff[2]<-88
    20. > xff
    21. [1] 5  88 13 12
    22. Levels: 5 12 13 88
    23.  
    24. 但是不能添加非法的水平
    25. > xff[2]<-28
    26. Warning message:
    27. In `[<-.factor`(`*tmp*`, 2, value = 28) : 因子层次有错，产生了NA

    (2)tapply函数
    1. > ages<-c(25,26,55,37,21,42)
    2. > affils<-c("R","D","D","R","U","D")
    3. > tapply(ages,affils,mean)
    4.  D  R  U 
    5. 41 31 21 
    6. 这里返回的是mean(u[x]),mean(u[y]),mean(u[z])
    7.  
    8.  
    9. #也可以使用自定义函数
    10. x <- c(1, 2, 3, 4, 5, 6)
    11.  
    12. # 创建一个因子
    13. f <- factor(c("A", "B", "A", "B", "A", "B"))
    14.  
    15. # 自定义函数，计算每个子集的标准差
    16. my_function <- function(x) {
    17.   return(sd(x))
    18. }
    19.  
    20. # 使用tapply应用自定义函数
    21. result <- tapply(x, f, my_function)
    22. print(result)
    23.  
    24. #输出
    25.      A      B 
    26. 1.632993 1.632993 
    27.  
    28. #多因子拆分
    29.  
    30. x <- c(1, 2, 3, 4, 5, 6)
    31.  
    32. # 创建两个因子
    33. f1 <- factor(c("A", "A", "B", "B", "A", "B"))
    34. f2 <- factor(c("X", "Y", "X", "Y", "Y", "X"))
    35.  
    36. # 使用tapply计算平均值
    37. result <- tapply(x, list(f1, f2), mean)
    38. print(result)
    39.  
    40. #输出
    41.   X   Y
    42. A 3.0 5.0
    43. B 4.5 4.0

    （3）split函数
    1. #根据因子拆分向量
    2.  
    3. x <- c(1, 2, 3, 4, 5, 6)
    4.  
    5. # 创建一个因子
    6. f <- factor(c("A", "B", "A", "B", "A", "B"))
    7.  
    8. # 使用 split() 函数拆分向量
    9. result <- split(x, f)
    10. print(result)
    11.  
    12. #输出
    13. $A
    14. [1] 1 3 5
    15.  
    16. $B
    17. [1] 2 4 6
    18.  
    19. #根据向量拆分数据框
    20. # 创建一个数据框
    21. df <- data.frame(
    22.   x = c(1, 2, 3, 4, 5, 6),
    23.   y = c("A", "B", "A", "B", "A", "B")
    24. )
    25.  
    26. # 使用 split() 函数根据向量拆分数据框
    27. result <- split(df, df$y)
    28. print(result)
    29.  
    30. #输出
    31. $A
    32.   x y
    33. 1 1 A
    34. 3 3 A
    35. 5 5 A
    36.  
    37. $B
    38.   x y
    39. 2 2 B
    40. 4 4 B
    41. 6 6 B
    42.  
    43. #根据自定义函数拆分向量
    44.  
    45. x <- c(1, 2, 3, 4, 5, 6)
    46.  
    47. # 自定义函数，根据奇偶性拆分向量
    48. my_function <- function(x) {
    49.   ifelse(x %% 2 == 0, "Even", "Odd")
    50. }
    51.  
    52. # 使用 split() 函数根据自定义函数拆分向量
    53. result <- split(x, my_function(x))
    54. print(result)
    55.  
    56. #输出
    57. $Odd
    58. [1] 1 3 5
    59.  
    60. $Even
    61. [1] 2 4 6

    （4）by()函数

    by(data, INDICES, FUN, ...)

    • data：要拆分的数据框、列表或向量。
    • INDICES：用于拆分数据的因子、列表或向量。
    • FUN：要应用于每个子集的函数。
    • ...：传递给函数 FUN 的其他参数。
    1. #对数据框的列进行拆分和求和
    2. # 创建一个数据框
    3. df <- data.frame(
    4.   group = rep(c("A", "B", "C"), each = 3),
    5.   value = 1:9
    6. )
    7.  
    8. # 使用 by() 函数对数据框的 value 列按照 group 列进行拆分和求和
    9. result <- by(df$value, df$group, sum)
    10. print(result)
    11.  
    12. #输出
    13. df$group: A
    14. [1] 6
    15. ------------------------------------------------------------ 
    16. df$group: B
    17. [1] 15
    18. ------------------------------------------------------------ 
    19. df$group: C
    20. [1] 24
    21.  
    22. #对列表中的元素进行拆分和求平均值
    23.  
    24. list_data <- list(
    25.   A = c(1, 2, 3),
    26.   B = c(4, 5, 6),
    27.   C = c(7, 8, 9)
    28. )
    29.  
    30. # 使用 by() 函数对列表中的元素进行拆分和求平均值
    31. result <- by(list_data, names(list_data), mean)
    32. print(result)
    33. #输出
    34. names(list_data): A
    35. [1] 2
    36. ------------------------------------------------------------ 
    37. names(list_data): B
    38. [1] 5
    39. ------------------------------------------------------------ 
    40. names(list_data): C
    41. [1] 8
    42.  
    43. #对向量进行拆分和自定义操作
    44. # 创建一个向量
    45. x <- c(1, 2, 3, 4, 5, 6)
    46.  
    47. # 创建一个因子
    48. f <- factor(c("A", "B", "A", "B", "A", "B"))
    49.  
    50. # 自定义函数，计算每个子集的中位数
    51. my_function <- function(x) {
    52.   return(median(x))
    53. }
    54.  
    55. # 使用 by() 函数对向量按照因子进行拆分和计算中位数
    56. result <- by(x, f, my_function)
    57. print(result)
    58.  
    59. #输出
    60. f: A
    61. [1] 2
    62.  
    63. ------------------------------------------------------------ 
    64. f: B
    65. [1] 4

    （5）表的操作
    1. > u<-c(22,8,33,6,8,29,-2)
    2. > f1<-list(c(5,12,13,12,13,5,13),c("a","bc","a","a","bc","a","a"))
    3. > tapply(u,f1,length)
    4.    a bc
    5. 5  2 NA
    6. 12 1  1
    7. #根据以上学习的tapply,得到的分组如下,但是事实上NA应该为0,因为没有第一因子是5,第二银子为"bc"的例子
    8. 所以应该用table()建表
    9. > table(f1)
    10.     f1.2
    11. f1.1 a bc
    12.   5  2  0
    13.   12 1  1
    14.   13 2  1
    15. #这里计算的是频数
    16.  
    17. #这里用一维的频数理解一下
    18. > table(c(5,12,13,12,8,5))
    19.  
    20.  5  8 12 13 
    21.  2  1  2  1 
    22.  
    23. #也可以建立三维表
    24. > gender<-c("M","M","F","M","F","F")
    25. > race<-c("W","W","A","O","B","B")
    26. > pol<-c("L","L","C","L","L","C")
    27. > v<-data.frame(gender,race,pol)
    28. > v
    29.   gender race pol
    30. 1      M    W   L
    31. 2      M    W   L
    32. 3      F    A   C
    33. 4      M    O   L
    34. 5      F    B   L
    35. 6      F    B   C
    36. > vt<-table(v)
    37. > vt
    38. , , pol = C
    39.  
    40.       race
    41. gender A B O W
    42.      F 1 1 0 0
    43.      M 0 0 0 0
    44.  
    45. , , pol = L
    46.  
    47.       race
    48. gender A B O W
    49.      F 0 1 0 0
    50.      M 0 0 1 2

    （6）对表的矩阵操作 
    1. > ct<-read.table("D://ct.dat",header=T)
    2. > ct
    3.   Vote.for.X Voted.For.X.Last.Time
    4. 1        YES                   YES
    5. 2        YES                    NO
    6. 3         NO                    NO
    7. 4   Not Sure                   YES
    8. 5         NO                    NO
    9. > cttab<-table(ct)
    10. > cttab
    11.           Voted.For.X.Last.Time
    12. Vote.for.X NO YES
    13.   NO        2   0
    14.   Not Sure  0   1
    15.   YES       1   1
    16.  
    17. #在R中，我们还是把表当作矩阵进行处理
    18. > class(cttab)
    19. [1] "table"
    20. > cttab[1,1]
    21. [1] 2
    22.  NO YES 
    23.   2   0 
    24.  
    25. #与标量进行运算
    26. > cttab/5
    27.           Voted.For.X.Last.Time
    28. Vote.for.X  NO YES
    29.   NO       0.4 0.0
    30.   Not Sure 0.0 0.2
    31.   YES      0.2 0.2
    32.  
    33. #以下为Vote.for.X变量的边际值：2+0=2，0+1=1，1+1=2
    34. > apply(cttab,1,sum)
    35.       NO Not Sure      YES 
    36.        2        1        2 
    37.  
    38. #实际上可以用addmargins()解决边际值问题
    39. > addmargins(cttab)
    40.           Voted.For.X.Last.Time
    41. Vote.for.X NO YES Sum
    42.   NO        2   0   2
    43.   Not Sure  0   1   1
    44.   YES       1   1   2
    45.   Sum       3   2   5
    46. > 
    47. #这样可以得到一个二维的边际数据
    48.  
    49. #dimnames可以得到边际值的名称和水平值
    50. > dimnames(cttab)
    51. $Vote.for.X
    52. [1] "NO"       "Not Sure" "YES"     
    53.  
    54. $Voted.For.X.Last.Time
    55. [1] "NO"  "YES"

    （7）aggregate()函数

    用于按照指定的因子变量对数据进行分组，并对每个组应用一个函数进行聚合操作

    aggregate(formula, data, FUN, ...)

    • formula 是一个公式对象，用于定义要聚合的变量和分组的因子变量。
    • data 是一个数据框或数据集，包含要聚合的数据。
    • FUN 是一个函数，用于指定要应用于每个分组的聚合操作。常见的函数有sum、mean、median、max、min等。
    1. df <- data.frame(
    2.   group = c("A", "A", "B", "B", "C", "C"),
    3.   value = c(10, 15, 5, 8, 20, 25)
    4. )
    5.  
    6. # 使用aggregate函数计算平均值
    7. result <- aggregate(value ~ group, data = df, FUN = mean)
    8. #计算每一组因子的平均值
    9. > result
    10.   group value
    11. 1     A  12.5
    12. 2     B   6.5
    13. 3     C  22.5

    （8）cut()函数

    cut()函数用于将连续型的数值变量划分为离散的区间

    cut(x, breaks, labels = NULL, include.lowest = FALSE, right = TRUE, dig.lab = 3, ...)\

    • x 是要进行切分的数值变量。
    • breaks 是用于指定区间的断点。可以有多种不同的方式来指定断点，例如一个整数（表示分割成等宽的区间）、一个向量（表示自定义的断点）、一个数值表示分割的区间个数等。
    • labels 是可选参数，用于指定每个区间的标签。如果未指定，则默认使用区间的范围作为标签。

      • 当labels = FALSE时，切分后的区间将使用数字表示。例如，如果将数值变量划分为3个区间，那么第一个区间将表示为1，第二个区间表示为2，以此类推。

      • 当labels = TRUE时，切分后的区间将使用字符型的标签表示。默认情况下，将使用区间的范围作为标签。例如，如果将数值变量划分为三个区间，范围分别为(0, 30]、(30, 60]和(60, 100]，则标签分别为(0, 30]、(30, 60]和(60, 100]。

    • include.lowest 是一个逻辑值（TRUE或FALSE），表示是否包括最小值在内的左端点。
    • right 是一个逻辑值，用于指定区间是否是右开的。
    • dig.lab 是一个整数，表示标签的小数位数。
    1. values <- c(10, 20, 30, 40, 50, 60, 70)
    2.  
    3. # 使用cut函数进行切分
    4. cut_values <- cut(values, breaks = c(0, 30, 60, 100))
    5.  
    6. print(cut_values)
    7. [1] (0,30]   (0,30]   (0,30]   (30,60]  (30,60]  (30,60]  (60,100]
    8. Levels: (0,30] (30,60] (60,100]
    9.  
    10.  
    11. > z<-c(0.88,0.28,0.58,0.42,0.46,0.24,0.0528,0.88)
    12. > z<-c(0.88,0.28,0.58,0.42,0.46,0.24,0.0528,0.88035)
    13. > seq(from=0.0,to=1.0,by=0.1)
    14.  [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
    15. > binmarks<-seq(from=0.0,to=1.0,by=0.1)
    16. > cut(z,binmarks,labels = F)
    17. [1] 9 3 6 5 5 3 1 9
    18. #例如z[1],0.88落在第九个区间,即(0.0,0.1]
  • 相关阅读:
    【视频】报告分享|展望人工智能银行：当银行遇到AI
    关于Unity Inspector上的一些常用技巧，一般用于编辑器扩展或者其他
    【达摩院OpenVI】视频目标渐进式Transformer跟踪器ProContEXT
    您的连接不是s连接 上不去g 的解决办法
    Scrapy第十篇：selenium4模拟器中间件
    Linux-centos
    谈一谈在两个商业项目中使用MVI架构后的感悟
    框架依赖-网站总结
    支持代理直连Oracle数据库，JumpServer堡垒机v2.24.0发布
    RGB彩色模型理解与编程实例
  • 原文地址：https://blog.csdn.net/weixin_69884785/article/details/132713200