• R语言 数据的整理与清洗（第一篇）

    《Cookbook for R》 Manipulating Data ~ General

    Sorting 排序

    1、vectors 向量

    # 先随机生成一组向量
v <- sample(101:110)

# 排序sort()
sort(v)
#>  [1] 101 102 103 104 105 106 107 108 109 110

# 反向排序
sort(v, decreasing=TRUE)
#>  [1] 110 109 108 107 106 105 104 103 102 101

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    2、data frames 数据框
    要对一个或多个列上的数据帧进行排序，可以使用 plyr 包中的 arrange()

    # 生成一个数据框
df <- data.frame (id=1:4,
            weight=c(20,27,24,22),
            size=c("small", "large", "medium", "large"))
df

library(plyr)

# 按weight这一列排序
arrange(df, weight)       # 使用arrange函数
df[ order(df$weight), ]   # 使用R自带函数
#>   id weight   size
#> 1  1     20  small
#> 2  4     22  large
#> 3  3     24 medium
#> 4  2     27  large

# 按size排序，再按weight排序
arrange(df, size, weight)         
df[ order(df$size, df$weight), ] 
#>   id weight   size
#> 4  4     22  large
#> 2  2     27  large
#> 3  3     24 medium
#> 1  1     20  small


# 按所有列进行排序，列的顺序从左到右
df[ do.call(order, as.list(df)), ] 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    Note：size这一列是因子，按因子水平的顺序排序；在这种情况下，级别是自动分配的（在创建数据框时），因此large是第一个，small是最后一个。

    3、reverse sort 反向排序

    排序的整体顺序可以用参数 decreasing=TRUE 颠倒

    若要反转特定列的方向，该方法取决于数据类型：

    1. Numbers：在变量名前面加上 - ，例如 df[ order(-df$weight), ] ;
    2. Factors：转换为整数，并在变量名前面加上 - ，例如 df[ order(-xtfrm(df$size)), ] ;
    3. Characters: 没有一个简单的方法可以做到这一点。一种方法是先转换为因子，然后如上所述进行排序
    # 按weight这一列反向排序 
arrange(df, -weight)                      # 使用arrange函数
df[ order(df$weight, decreasing=TRUE), ]  # 使用R自带函数
df[ order(-df$weight), ]                  # 使用R自带函数
#>   id weight   size
#> 2  2     27  large
#> 3  3     24 medium
#> 4  4     22  large
#> 1  1     20  small


# 按 size (increasing), 然后按 weight (decreasing)
arrange(df, size, -weight)        
df[ order(df$size, -df$weight), ]  
#>   id weight   size
#> 2  2     27  large
#> 4  4     22  large
#> 3  3     24 medium
#> 1  1     20  small


# 按 size (decreasing), 然后按 weight (increasing)
# R自带函数 xtfrm() ，用于生成一个数字向量
arrange(df, -xtfrm(size), weight)         # Use arrange from plyr package
df[ order(-xtfrm(df$size), df$weight), ]  # Use built-in R functions
#>   id weight   size
#> 1  1     20  small
#> 3  3     24 medium
#> 4  4     22  large
#> 2  2     27  large

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    Randomizing order 随机化排序

    当你想随机化排序时

    # 先创造一个向量
v <- 11:20

# 使向量随机化
v <- sample(v)

# 再创建一个数据框
data <- data.frame(label=letters[1:5], number=11:15)
data
#>   label number
#> 1     a     11
#> 2     b     12
#> 3     c     13
#> 4     d     14
#> 5     e     15

# 使数据框随机化
data <- data[sample(1:nrow(data)), ]
data
#>   label number
#> 5     e     15
#> 2     b     12
#> 4     d     14
#> 3     c     13
#> 1     a     11

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    要使随机化可重复，应该为随机数生成器设置种子

    Converting between vector types 向量类型转换

    在数字向量、字符向量和因子之间进行转换

    从这个数字向量 n 开始：

    n <- 10:14
n
#> [1] 10 11 12 13 14

    • 1
    • 2
    • 3

    要将数字向量转换为其他两种类型：

    # Numeric 数字型 to Character 字符型
c <- as.character(n)

# Numeric 数字型 to Factor 因子型
f <- factor(n)
# 10 11 12 13 14

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    要将字符向量转换为其他两个：

    # Character 字符型 to Numeric 数字型
as.numeric(c)
#> [1] 10 11 12 13 14

# Character 字符型 to Factor 因子型
factor(c)
#> [1] 10 11 12 13 14
#> Levels: 10 11 12 13 14

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    将因子转换为字符向量很简单：

    # Factor to Character
as.character(f)
#> [1] "10" "11" "12" "13" "14"

    • 1
    • 2
    • 3

    但把因子转为数值型则有点棘手
    如果你只是用 as.numeric 转换它，它会给你给予因子的数字编码，这可能不是你想要的结果

    as.numeric(f)
#> [1] 1 2 3 4 5

# 另一种得到数字编码的方式
unclass(f)
#> [1] 1 2 3 4 5
#> attr(,"levels")
#> [1] "10" "11" "12" "13" "14"

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    将文本内容转换为数字的方法是：
    首先将其转换为字符，然后转换为数字向量

    # Factor to Numeric
as.numeric(as.character(f))
#> [1] 10 11 12 13 14

    • 1
    • 2
    • 3

    Finding and removing duplicate records 查找和删除重复记录

    从向量或数据框中查找和/或删除重复条目

    1、对向量

    # 设置随机种子
# 生成一个向量，取整数部分
set.seed(158)
x <- round(rnorm(20, 10, 5))
x
#>  [1] 14 11  8  4 12  5 10 10  3  3 11  6  0 16  8 10  8  5  6  6

# duplicate()判断是否有重复
# 某元素第一次出现的位置返回FALSE，第二次出现的位置返回TRUE
duplicated(x)
#>  [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE FALSE  TRUE  TRUE FALSE FALSE FALSE
#> [15]  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE

# 利用返回的逻辑值取子集
x[duplicated(x)]
#> [1] 10  3 11  8 10  8  5  6  6
# 因为6、10、8出现了3次，后两次都是TRUE
# 所以会被选出来2个

# 用unique()去重复
# unique()默认保留第一次出现的元素
unique(x[duplicated(x)])
#> [1] 10  3 11  8  5  6

# 用unique()给原始x去重复
unique(x)
#>  [1] 14 11  8  4 12  5 10  3  6  0 16
# ！逆转逻辑值
x[!duplicated(x)]
#>  [1] 14 11  8  4 12  5 10  3  6  0 16

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    2、对数据框

    # 示例
df <- read.table(header=TRUE, text='
 label value
     A     4
     B     3
     C     6
     B     3
     B     1
     A     2
     A     4
     A     4
')


# 判断是否有重复的行?
duplicated(df)
#> [1] FALSE FALSE FALSE  TRUE FALSE FALSE  TRUE  TRUE

# 找出重复的行
df[duplicated(df),]
#>   label value
#> 4     B     3
#> 7     A     4
#> 8     A     4

# 重复条目去重
unique(df[duplicated(df),])
#>   label value
#> 4     B     3
#> 7     A     4

# 原始数据去重复，返回去掉重复的数据框
unique(df)
#>   label value
#> 1     A     4
#> 2     B     3
#> 3     C     6
#> 5     B     1
#> 6     A     2
df[!duplicated(df),]
#>   label value
#> 1     A     4
#> 2     B     3
#> 3     C     6
#> 5     B     1
#> 6     A     2

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    Comparing vectors or factors with NA 将向量或因子与NA进行比较

    想要比较两个向量或因子
    但希望与 NA 比较的结果报告为 TRUE 或 FALSE （而不是 NA ）

    假如你有这样的数据框
    由两列布尔向量（逻辑）组成，且内含 NA

    df <- data.frame( a=c(TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,NA,NA,NA),
                  b=c(TRUE,FALSE,NA,TRUE,FALSE,NA,TRUE,FALSE,NA))
df
#>       a     b
#> 1  TRUE  TRUE
#> 2  TRUE FALSE
#> 3  TRUE    NA
#> 4 FALSE  TRUE
#> 5 FALSE FALSE
#> 6 FALSE    NA
#> 7    NA  TRUE
#> 8    NA FALSE
#> 9    NA    NA

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    默认情况，当比较两个包含 NA 值的向量或因子时,
    只要原始项中的任一项为 NA，结果向量将具有 NA 。

    # 两列相比，相同返回TRUE
df$a == df$b
#> [1]  TRUE FALSE    NA FALSE  TRUE    NA    NA    NA    NA

# 将结果新增一列到数据框中
data.frame(df, isSame = (df$a==df$b))
#>       a     b isSame
#> 1  TRUE  TRUE   TRUE
#> 2  TRUE FALSE  FALSE
#> 3  TRUE    NA     NA
#> 4 FALSE  TRUE  FALSE
#> 5 FALSE FALSE   TRUE
#> 6 FALSE    NA     NA
#> 7    NA  TRUE     NA
#> 8    NA FALSE     NA
#> 9    NA    NA     NA

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    与 NA 比较的函数：
    这个函数本质上将 NA 视为另一个值。
    如果两个向量中的一个项都是 NA ，则它报告该项的 TRUE ;
    如果该项在一个向量中是 NA ，则它报告 FALSE ;
    所有其他比较（非 NA 项之间）的行为相同。

    # 只要内容相同就返回TRUE
compareNA <- function(v1,v2) {
    same <- (v1 == v2) | (is.na(v1) & is.na(v2))
    same[is.na(same)] <- FALSE
    return(same)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    应用该函数比较布尔向量

    compareNA(df$a, df$b)
#> [1]  TRUE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

data.frame(df, isSame = compareNA(df$a,df$b))
#>       a     b isSame
#> 1  TRUE  TRUE   TRUE
#> 2  TRUE FALSE  FALSE
#> 3  TRUE    NA  FALSE
#> 4 FALSE  TRUE  FALSE
#> 5 FALSE FALSE   TRUE
#> 6 FALSE    NA  FALSE
#> 7    NA  TRUE  FALSE
#> 8    NA FALSE  FALSE
#> 9    NA    NA   TRUE

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    应用该函数比较因子
    即使因子的水平顺序不同

    # 先创建两列因子
df1 <- data.frame(a = factor(c('x','x','x','y','y','y', NA, NA, NA)),
                  b = factor(c('x','y', NA,'x','y', NA,'x','y', NA)))

# 比较因子
data.frame(df1, isSame = compareNA(df1$a, df1$b))
#>      a    b isSame
#> 1    x    x   TRUE
#> 2    x    y  FALSE
#> 3    x   FALSE
#> 4    y    x  FALSE
#> 5    y    y   TRUE
#> 6    y   FALSE
#> 7     x  FALSE
#> 8     y  FALSE
#> 9     TRUE


# 即便因子顺序被改变，也不影响比较结果
df1$b <- factor(df1$b, levels=c('y','x'))
data.frame(df1, isSame = compareNA(df1$a, df1$b))
#>      a    b isSame
#> 1    x    x   TRUE
#> 2    x    y  FALSE
#> 3    x   FALSE
#> 4    y    x  FALSE
#> 5    y    y   TRUE
#> 6    y   FALSE
#> 7     x  FALSE
#> 8     y  FALSE
#> 9     TRUE

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
  • 相关阅读:
    CAP 7.0 版本发布通告 - 支持延迟消息，性能炸了？
    找暑期实习还是学习准备秋招
    Redis缓存击穿、雪崩、穿透
    SEO优化排名的技巧与注意点（百度SEO排名的五大注意点）
    DP232在兼容FT232RL的注意事项
    springMvc59-图片上传
    如何从宏观层面构建优秀的大语言模型
    【DesignMode】建造者模式（Builder model）
    SpringMVC13-注解配置SpringMVC
    Python进阶教学——多线程高级应用
  • 原文地址：https://blog.csdn.net/yangyulu1998/article/details/138088058