R语言

Lecture03 : R程序编写与数据处理-01

罗益民

2024-09-03

本节内容一览

  • Part01 R数据输入
    • 使用键盘输入数据
    • 从文本文件导入数据
  • Part02 R数据输出
    • 向控制台输出数据
    • 将数据保存为文件
  • Part03 基本数据管理
    • 缺失值和异常值
    • 日期值
    • 数据转换和排序
    • 合并数据
    • 选取变量
    • 剔除变量

Part01 R数据输入

使用scan()函数输入数据

  1. 使用scan()从控制台输入数据 在控制台中输入scan(), 然后逐个输入数据，可以在一行用空格分开多个数值， 可以用多行输入直到空行结束（EOF）输入。windows下是按下Ctrl+D

注意默认情况下scan() 只能输入浮点类型的数值类型。若要输入其它类型，则需要用what参数指定：

what的取值可以为： logical, integer, numeric, complex, character, raw , list

data <- scan(what="") # character可以用空字符串表示
  1. 使用scan()从文本文件输入数据
#使用cat生成一个序列并保存在x.txt文件中
cat(1:12, "\n", file="x.txt")
x <- scan("x.txt")
  1. 使用scan()输入矩阵数据

假设文件mat.txt包含以下内容：

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

可以先把文件内容读入到一个R向量中， 再利用matrix()函数转换成矩阵

M <- matrix(scan("mat.txt", quiet=TRUE), ncol=3, byrow=TRUE)

scan()函数并不常用，因为它只能读取同种类型的数据。但它有一个重要的优势：在读取大数据集时效率很高。

使用键盘输入数据

使用edit()或fix()函数

edit() 函数通常用于编辑函数、表达式或任何其他R对象。当你在R控制台中使用 edit() 函数时，它会打开一个编辑器，允许你对对象进行修改

mycars <- edit(mtcars)

也可以先创建一个数据，然后在edit()界面中进行修改：

my_data <- data.frame(
  name = character(0),
  age = numeric(0),
  salary = numeric(0)
) 
# 编辑数据框
edit(my_data)
# 编辑数据框的特定列
edit(my_data)

fix()函数和edit()具有同样的功能

从带分隔符的文本文件导入数据

在R语言中，从带分隔符的文本文件导入数据是一项常见的任务，尤其是在处理CSV（逗号分隔值）或TSV（制表符分隔值）等格式的文件时。这些文件通常用于存储表格数据。

R提供了几个函数来读取这些类型的文件，包括read.table()、read.csv()和read.delim()。

1. read.table()函数

read.table()是读取文本数据最常用的函数，可以用来读取任何带分隔符的文本文件。需要指定sep参数来定义字段的分隔符。

read.table(file, header = FALSE, sep = "", quote = "\"'",
           dec = ".", numerals = c("allow.loss", "warn.loss", "no.loss"),
           row.names, col.names, as.is = !stringsAsFactors, tryLogical = TRUE,
           na.strings = "NA", colClasses = NA, nrows = -1,
           skip = 0, check.names = TRUE, fill = !blank.lines.skip,
           strip.white = FALSE, blank.lines.skip = TRUE,
           comment.char = "#",
           allowEscapes = FALSE, flush = FALSE,
           stringsAsFactors = FALSE,
           fileEncoding = "", encoding = "unknown", text, skipNul = FALSE)

不要被这个长长的参数列表吓住，真实情况下大部分参数保持默认就好，其中重要的参数有：

  • file: 文件路径，注意既可以是相对路径，也可以是绝对路径
  • header: 将文件第一行作为列名
  • sep：分隔符，如sep=',' sep='\t'
  • row.names：指定行名
  • col.names: 如果文件第一行没有header，或者指定了header=FALSE, 可以用这个参数指定列名。如果不指定，则自动创建V1,V2...这样的列名。
  • na.strings：指定如何表示NA值
  • stringAsFactors: 是否将字符型向量自动转化为因子。4.0.0以上版本默认FALSE
  • colClasses:指定每一列的数据类型

其余参数解释可用help(read.table)查看

read.table读取示例

以数据集（Affairs）为例，先将他下载到当前的工作目录中:

点击这里下载

my_data <- read.table('Affairs.csv',header=TRUE,sep = ',')
head(my_data)

也可以直接读取远程文件

url <- "http://roypub.biovr.cc/Affairs.csv"
my_data <- read.table(url,header=TRUE,sep = ',')
head(my_data)
  rownames affairs gender age yearsmarried children religiousness education
1        4       0   male  37        10.00       no             3        18
2        5       0 female  27         4.00       no             4        14
3       11       0 female  32        15.00      yes             1        12
4       16       0   male  57        15.00      yes             5        18
5       23       0   male  22         0.75       no             2        17
6       29       0 female  32         1.50       no             2        17
  occupation rating
1          7      4
2          6      4
3          1      4
4          6      5
5          6      3
6          5      5

读取文件空值的处理

值得注意的是，数据文件中的空值往往会以空字符""，或者NA的方式存在。在读取时要对这种情况进行处理，一般使用na.strings = c("","NA")将它们转为NA:

dt_na <- read.table('http://roypub.biovr.cc/employees-salary.csv',sep=",",header =TRUE)
print(dt_na)
   ID              Name Age Department Salary   HireDate
1   1          John Doe  45             70000 1995-12-17
2   2        Jane Smith  38  Marketing  75000 2002-05-24
3   3       Bob Johnson  NA      Sales  80000 1998-08-01
4   4       Emily Davis  29  Marketing  65000 2010-03-15
5   5    Michael Wilson  40    Finance  90000 2005-07-23
6   6        Anna Brown  34      Sales  72000 2015-01-29
7   7        Zoe Wright  30 Technology     NA 2018-09-30
8   8                    22 Technology  78000 2012-06-01
9   9        Luke Evans  NA  Marketing  68000 2007-09-11
10 10 Isabella Martinez  28      Sales  74000 2013-04-20
dt_empty_na <- read.table('http://roypub.biovr.cc/employees-salary.csv',sep=",",header =TRUE,na.strings = c("","NA"))
print(dt_empty_na)
   ID              Name Age Department Salary   HireDate
1   1          John Doe  45       <NA>  70000 1995-12-17
2   2        Jane Smith  38  Marketing  75000 2002-05-24
3   3       Bob Johnson  NA      Sales  80000 1998-08-01
4   4       Emily Davis  29  Marketing  65000 2010-03-15
5   5    Michael Wilson  40    Finance  90000 2005-07-23
6   6        Anna Brown  34      Sales  72000 2015-01-29
7   7        Zoe Wright  30 Technology     NA 2018-09-30
8   8              <NA>  22 Technology  78000 2012-06-01
9   9        Luke Evans  NA  Marketing  68000 2007-09-11
10 10 Isabella Martinez  28      Sales  74000 2013-04-20

2. read.csv 函数

read.csv()1是读取CSV文件的常用函数。它将文件内容读取到一个数据框中，其中每个逗号分隔的值被视为一个字段。

read.csv(file, header = TRUE, sep = ",", quote = "\"",
         dec = ".", fill = TRUE, comment.char = "", ...)

基本用法：

my_data <- read.csv('Affairs.csv')
  1. read.delim() 函数

read.delim() 是 read.table() 的一个特殊版本，它默认使用制表符作为分隔符，通常用于读取TSV文件。

使用readr包读取（推荐）

readr 是 R 语言中的一个非常强大的包，专门用于读取和写入文本数据文件，如 CSV、TSV 和固定宽度文件。它是 tidyverse 生态系统的一部分。 若已经安装过tidyverse则无需再安装。

readr具有以下优点：

  • 速度：readr 的读取速度通常比 R 基础包中的函数快 10 倍左右。
  • 类型推断：readr 自动推断列的数据类型，并且可以处理常见的日期和时间格式。
  • 友好的错误报告：当解析数据时遇到问题，readr 提供了有用的错误报告。
  • 列规格说明：用户可以明确指定每列的类型，或者使用 readr 的猜测功能。
  • 进度条：在读取大型文件时，readr 会显示进度条。

readr主要函数:

  • read_table()：读取使用空格分隔的文件
  • read_csv()：读取逗号分隔的文件（CSV）。
  • read_tsv()：读取制表符分隔的文件（TSV）。
  • read_delim()：读取任意分隔符的文件。
  • read_fwf()：读取固定宽度的文件。
read_csv(
  file,  col_names = TRUE,  col_types = NULL,  col_select = NULL, 
  id = NULL,  locale = default_locale(),  na = c("", "NA"),  
  quoted_na = TRUE,  quote = "\"",  comment = "",  trim_ws = TRUE,  
  skip = 0,  n_max = Inf,  guess_max = min(1000, n_max),  
  name_repair = "unique",  num_threads = readr_threads(),  
  progress = show_progress(),  show_col_types = should_show_types(),
  skip_empty_rows = TRUE,  lazy = should_read_lazy()
)

使用readr读取BenderlyZqick.csv文件内容

点击下载该文件

library(readr)
url <- "http://roypub.biovr.cc/BenderlyZwick.csv"
data <- read_csv(url)
head(data)
# A tibble: 6 × 6
  rownames returns growth inflation growth2 inflation2
     <dbl>   <dbl>  <dbl>     <dbl>   <dbl>      <dbl>
1        1    NA     NA        NA       3.9        2.2
2        2    NA     NA        NA       4          2.1
3        3    53      6.7      -0.4    -1.3        0.6
4        4    31.2    2.1       0.4     5.6        1.3
5        5     3.7    1.8       2.9     2.1        1.9
6        6   -13.8   -0.4       3       1.7        3.2

读取结果以tibble格式返回。readr包的所有函数皆是如此，以便更好地和tidyverse生态配合。

读取excel文件

excel是微软开发的电子表格格式文件，以.xls或.xslx为扩展名。广泛用于办公软件中。

  1. R中读取excel文件最容易的办法是在Excel软件中把数据表转存为CSV格式， 然后用read.csv()读取。

  2. 也可以使用readxl第三方包读取excel文件，file是文件路径，sheet是工作表序号(从1开始)

read_excel(path, sheet = 1, col_names = TRUE, 
    col_types = NULL, na = "",  skip = 0)

读取文件Cigarettes.xslx，点击这里下载

library(readxl)
data <- read_xlsx("Cigarettes.xlsx",1)
data
# A tibble: 46 × 4
   rownames packs price income
   <chr>    <dbl> <dbl>  <dbl>
 1 AL        4.96 0.205   4.64
 2 AZ        4.66 0.166   4.68
 3 AR        5.11 0.234   4.59
 4 CA        4.50 0.364   4.88
 5 CT        4.67 0.321   5.09
 6 DE        5.05 0.219   4.87
 7 DC        4.66 0.289   5.06
 8 FL        4.80 0.287   4.81
 9 GA        4.98 0.128   4.73
10 ID        4.75 0.175   4.64
# ℹ 36 more rows

使用剪贴板

为了把Excel软件中数据表的选中区域读入到R中， 可以借助于剪贴板。在Excel中复制选中的区域，然后在R中用read.delim读入

data <- read.delim("clipboard")

Part02 R数据输出

在R语言中，有多个函数可以用来打印输出数据和结果，常用的有

  • print, sprintf, paste, paste0, str, summary,head, tail(控制台)

  • cat, sink, save, write.csv, readr::write_csv(控制台或文件)

print

使用print()可以将变量打印输出到命令行。在R中，直接写变量名，默认调用的就是print方法

print(iris[1:10,])
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1           5.1         3.5          1.4         0.2  setosa
2           4.9         3.0          1.4         0.2  setosa
3           4.7         3.2          1.3         0.2  setosa
4           4.6         3.1          1.5         0.2  setosa
5           5.0         3.6          1.4         0.2  setosa
6           5.4         3.9          1.7         0.4  setosa
7           4.6         3.4          1.4         0.3  setosa
8           5.0         3.4          1.5         0.2  setosa
9           4.4         2.9          1.4         0.2  setosa
10          4.9         3.1          1.5         0.1  setosa

sprintf

sprintf() 用于生成格式化的字符串 sprintf() 函数使用百分号%来标记格式化指令，后面跟着一个或多个字符来指定类型和格式

%d：整数（decimal）
%f：浮点数（floating point）
%e：科学计数法（exponential）
%g：通用浮点数表示（general）
%s：字符串（string）

一些格式化字符串的例子：

sprintf("%d", 42)
[1] "42"
sprintf("%.2f", 3.14159)
[1] "3.14"
sprintf("Hello, %s!", "World")
[1] "Hello, World!"
sprintf("The value of pi is approximately %f", pi)
[1] "The value of pi is approximately 3.141593"
sprintf("%10.2f", 3.14159)
[1] "      3.14"
sprintf("%e", 123456)
[1] "1.234560e+05"
sprintf("%g", 123.456789)
[1] "123.457"
sprintf("Name: %s, Age: %d, Height: %.2f", "Alice", 30, 175.5)
[1] "Name: Alice, Age: 30, Height: 175.50"

paste/paste0

paste()和paste0()是两个用于字符串连接的函数，它们的主要区别在于是否在连接的字符串之间添加分隔符。

paste (..., sep = " ", collapse = NULL, recycle0 = FALSE)
paste0(...,            collapse = NULL, recycle0 = FALSE)

使用举例：

paste("Hello", "World")
[1] "Hello World"
paste("Hello", "World",sep="^_^")
[1] "Hello^_^World"
paste("Name:", c("Alice", "Bob", "Charlie")) #连接向量
[1] "Name: Alice"   "Name: Bob"     "Name: Charlie"
paste0("Hello", "World")
[1] "HelloWorld"
paste0("Day", 1:5)
[1] "Day1" "Day2" "Day3" "Day4" "Day5"
paste0(1:12, c("st", "nd", "rd", rep("th", 9)))
 [1] "1st"  "2nd"  "3rd"  "4th"  "5th"  "6th"  "7th"  "8th"  "9th"  "10th"
[11] "11th" "12th"
#两个函数都可以通过 collapse 参数将多个字符串连接成一个单一的字符串
paste0(c("a", "b", "c"), collapse = "_")
[1] "a_b_c"

str

str() 是 R 语言中的一个非常有用的函数，它以紧凑的形式显示任何 R对象的内部结构。可以显示对象的类型、维度、元素等信息，对于理解对象及其组成部分非常有帮助

查看向量的结构

vec <- c(1, 2, 3, 4, 5, NA, 7, 8, 9, 10)
str(vec)
 num [1:10] 1 2 3 4 5 NA 7 8 9 10

查看数据框的结构

df <- data.frame(
  team = c("A", "B", "C", "D"),
  points = c(99, 90, 86, 88),
  assists = c(33, 28, 31, 39),
  rebounds = c(30, 28, 24, 24)
)
str(df)
'data.frame':   4 obs. of  4 variables:
 $ team    : chr  "A" "B" "C" "D"
 $ points  : num  99 90 86 88
 $ assists : num  33 28 31 39
 $ rebounds: num  30 28 24 24

查看列表的结构

lst <- list(
  name = "Alice",
  age = 25,
  scores = c(98.5, 72, 88)
)
str(lst)
List of 3
 $ name  : chr "Alice"
 $ age   : num 25
 $ scores: num [1:3] 98.5 72 88

查看矩阵的结构

mat <- matrix(1:15, nrow = 5, ncol = 3)
str(mat)
 int [1:5, 1:3] 1 2 3 4 5 6 7 8 9 10 ...

summary

summary() 函数在 R 语言中用于生成各种模型拟合函数的结果摘要。这个函数会根据第一个参数的类别调用特定的方法。

  • 它的行为取决于它作用的对象的类别
  • 可以显示数据的最小值、第25百分位数、中位数、平均值、第75百分位数和最大值

向量的摘要统计

x <- c(1, 2, 3, 4, 5, 6)
summary(x)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
   1.00    2.25    3.50    3.50    4.75    6.00

数据框的摘要统计

df <- data.frame(
  a = c(1, 2, 3, 4, 5),
  b = c("A", "B", "C", "D", "E")
)
summary(df)
       a          b            
 Min.   :1   Length:5          
 1st Qu.:2   Class :character  
 Median :3   Mode  :character  
 Mean   :3                     
 3rd Qu.:4                     
 Max.   :5

因子的摘要统计

f <- factor(c("low", "medium", "high", "medium", "low"))
summary(f)#显示因子 f 的每个水平的频率
  high    low medium 
     1      2      2

head/tail

head() 和 tail() 用于查看数据集的开始和结束部分。对于快速检查数据结构和内容非常有用

它们默认都显示6行

head(ChickWeight)
  weight Time Chick Diet
1     42    0     1    1
2     51    2     1    1
3     59    4     1    1
4     64    6     1    1
5     76    8     1    1
6     93   10     1    1
tail(ChickWeight,n=3)
    weight Time Chick Diet
576    234   18    50    4
577    264   20    50    4
578    264   21    50    4

cat

cat()函数把字符串、变量、表达式连接起来显示，其中变量和表达式的类型一般是标量或向量，不能是矩阵、列表等复杂数据。

x <- 1:10
cat("x=",x,"\n")
x= 1 2 3 4 5 6 7 8 9 10 
cat("Hello", "world!", sep = " ", end = "\n")
Hello world!

cat()也可以将内容写入指定文件中：

cat("写入文件的内容\n", file="res.txt")

cat()默认情况下会覆盖原文件，调用append=TRUE选项，可以追加文本

cat("写入文件的内容2\n", file="res.txt", append=TRUE)

sink

sink() 函数在 R 语言中用于将输出重定向到文件或其他外部设备，而不是默认的控制台。

sink(file = NULL, append = FALSE, type = c("output", "message"),
     split = FALSE)

将输出重定向到文本文件

sink("output.txt")
# 在这里执行的任何打印操作都会被写入到 output.txt 文件中
print("Hello, World!")
sink()  # 关闭重定向，之后的输出会回到控制台

将输出追加到文件

sink("output.txt", append = TRUE)
# 执行的打印操作会追加到 output.txt 文件的末尾
print("Appending this line")
sink()  # 关闭重定向

同时在控制台和文件中显示输出

sink("output.txt", split = TRUE)
# 执行的打印操作会同时显示在控制台和写入到 output.txt 文件中
print("This appears in both")
sink()  # 关闭重定向

save / load

save() 和 load() 函数用于将R对象保存到文件中以及从文件中加载这些对象。这两个函数是处理R数据持久化的基本工具，使得用户可以在不同的R会话之间共享数据。

# 创建一个数据框
df <- data.frame(name = c("Alice", "Bob", "Charlie"), age = c(25, 30, 35))

# 保存数据框到文件
save(df, file = "my_data.RData")

# 从文件加载数据框
load(file = "my_data.RData")

也可以将多个变量保存在一个文件中：

save(x, zeta, file="myvars.RData")
#或采用列表方式
save(list = c("x", "zeta"), file="myvars.RData")

R的数据文件

使用RStudio编程时，Environment窗口显示了程序中定义的所有变量，点击保存按钮即可保存。在退出RStudio时，也会询问是否保存这些数据

这些数据默认情况下保存在项目目录下的.RData文件中

save.image()方法是一个简化版的save()，作用和我们点击上述保存按钮的效果一致，就是把当前工作区内的所有数据保存为一个.RData文件。

save.image(file = ".RData", version = NULL, ascii = FALSE,
           compress = !ascii, safe = TRUE)

write.csv / readr::write_csv

write系列和前面讲过的read系列对应，分别是写入文件和读取文件

基础包 tidyverse包
读取 read.table,read.csv,read.csv2,read.delim read_table,read_csv,read_csv2,read_delim
写入 write.table,write.csv,write.csv2,write.delim write_table,write_csv,write_csv2,write_delim

其中最常用的还是CSV包

write.csv(x, file, row.names = TRUE, col.names = TRUE, quote = TRUE, sep = ",", eol = "\n", ...)
write_csv(x, file, na = "NA", append = FALSE, col_names = !is.null(names(x)...)

Part03 基本数据管理

缺失值和异常值

真实的数据中往往遍布缺失值和异常值

在R语言中，缺失值通常用NA表示，而NaN表示不可能的值，Inf和-Inf分别表示正无穷和负无穷。

识别缺失值

vec <- c(1,2,3,NA,5)
is.na(vec)
[1] FALSE FALSE FALSE  TRUE FALSE

识别异常值(注意：在R中，缺失值和异常值是不同的概念)

is.nan(0/0)
[1] TRUE
is.infinite(1/0) 
[1] TRUE
is.infinite(-Inf + (-1)) 
[1] TRUE

处理缺失值和异常值

使用na.omit()，将删除含有缺失值的数据行

df <- data.frame(
  Name = c("Alice", "Bob", "Charlie", NA),
  Age = c(25, NA, 35, 40),
  Score = c(88, 92, NA, 85)
)
na.omit(df)
   Name Age Score
1 Alice  25    88

很多数值处理函数都有na.rm=TRUE选项，可以移除缺失值

# 直接调用时，因为数据中含有缺失值，结果为NA
sum(df$Age)
[1] NA
# 移除缺失值后显示正确结果
sum(df$Age,na.rm = TRUE)
[1] 100
mean(df$Age,na.rm = TRUE)
[1] 33.33333
# 列出数据中含有缺失值的行数
sum(is.na(df$Age))
[1] 1

处理缺失值和异常值

# 用Age列的均值替换缺失值
df$Age[is.na(df$Age)] <- mean(df$Age, na.rm = TRUE)
# 绘制Score列的箱线图
boxplot(df$Score, main = "Score Distribution")
# 假设我们认为Score超过90或低于86是异常值
df <- df[df$Score <= 90 & df$Score >= 86, ]

日期值

在R中处理日期和时间是一个常见的任务，尤其是在数据分析和统计建模中。日期值通常以字符串的形式输入到R中，然后转换为以数值形式存储的日期变量。

as.Date(x,format): 字符格式 → 日期格式, x是字符型数据，format是和x匹配的读入日期的适当格式，若不匹配会产生NA

as.Date("2021-01-25", format = "%Y-%m-%d")
[1] "2021-01-25"
dates <- c("02/27/92", "02/27/92", "01/14/92", "02/28/92", "02/01/92")
as.Date(dates,format="%m/%d/%y")
[1] "1992-02-27" "1992-02-27" "1992-01-14" "1992-02-28" "1992-02-01"
as.Date(32768, origin = "1900-01-01")#1900-01-01是windows系统默认起始日期
[1] "1989-09-19"

format(x,format)：日期格式→字符格式

format(as.Date("2024-01-25"), "%b %d, %Y") 
[1] "1月 25, 2024"

字符串转为日期变量后就可以进行日期相关的运算

d1 <-  as.Date("2023-01-25")
d2 <-  as.Date("2024-06-03")

日期计算1

d2-d1 # 计算日期差异，以天为单位
Time difference of 495 days
difftime(d2, d1, units = "weeks")# 计算日期差异，以周为单位
Time difference of 70.71429 weeks
d1+10
[1] "2023-02-04"
d1-10
[1] "2023-01-15"
format(d2, "%j")#计算日期是一年中的第几天
[1] "155"
format(d2, "%U")#计算日期是一年中的第几周
[1] "22"
format(d2, "%A")#计算日期是一周中的第几天
[1] "星期一"
format(d2, "%d")#计算日期是月份中的第几天
[1] "03"

系统时间相关

Sys.Date()#获取系统日期
[1] "2024-10-09"
date()#获取当前系统时间(字符串格式)
[1] "Wed Oct  9 08:28:43 2024"
Sys.time()#获取当前系统时间(标准日期格式)
[1] "2024-10-09 08:28:43 CST"
format(Sys.time(), "%a %b %e %H:%M:%S %Y")
[1] "周三 10月  9 08:28:43 2024"
Sys.getlocale("LC_ALL")#获取当前系统的区域设置（locale）
[1] "LC_COLLATE=Chinese (Simplified)_China.utf8;LC_CTYPE=Chinese (Simplified)_China.utf8;LC_MONETARY=Chinese (Simplified)_China.utf8;LC_NUMERIC=C;LC_TIME=Chinese (Simplified)_China.utf8"
Sys.setlocale("LC_TIME", "China.utf8")#设置当前系统的区域设置（locale）
[1] ""

时区相关

Sys.timezone()#返回当前R会话的默认时区
[1] "Asia/Shanghai"
Sys.setenv(TZ = 'Asia/Shanghai')#设置环境变量TZ，从而影响R会话的默认时区

使用lubridate包管理日期和时间

lubridate 是一个强大的 R包，专门用于处理日期和时间数据。推荐在R中使用。

lubridate 属于tidyverse家族，若已经安装过 tidyverse则无需再安装。

library(lubridate)

ymd("2024-01-25")# 解析年月日
[1] "2024-01-25"
dmy("25/01/24")# 解析年月日
[1] "2024-01-25"
mdy("01-25-24")# 解析年月日
[1] "2024-01-25"
datetime <- ymd_hms("2024-01-25 14:30:00")# 解析年月日时分秒
print(datetime)
[1] "2024-01-25 14:30:00 UTC"
with_tz(datetime, tz = "America/Chicago")#将时间对象转换为指定的时区
[1] "2024-01-25 08:30:00 CST"
force_tz(datetime, tz = "Asia/Shanghai")#强制将时间对象的时区设置为指定的时区，而不考虑原始时区
[1] "2024-01-25 14:30:00 CST"
month(3)+days(12)#计算时间间隔
[1] "12d 0H 0M 3S"
dyears(1) #计算时间长度（以秒）
[1] "31557600s (~1 years)"
leap_year(2024)#计算是否闰年
[1] TRUE

数据转换

在R中，使用is.xx判断数据类型，as.xx转换数据类型

判 断 转 换
is.numeric() as.numeric()
is.character() as.character()
is.vector() as.vector()
is.matrix() as.matrix()
is.data.frame() as.data.frame()
is.factor() as.factor()
is.logical() as.logical()

数据排序

  1. 对向量或因子使用sort()排序
numbers <- c(5, 2, 9, 3, 7)
sort(numbers)
[1] 2 3 5 7 9
sort(numbers,decreasing = TRUE)
[1] 9 7 5 3 2

2.order() 函数可以对向量、因子或数据框的行或列进行排序，并返回排序后的索引。

order(numbers) #注意返回的是索引
[1] 2 4 1 5 3

可以使用下标获得元素

numbers[order(numbers)]
[1] 2 3 5 7 9
mtcars[order(mtcars$mpg),]
                     mpg cyl  disp  hp drat    wt  qsec vs am gear carb
Cadillac Fleetwood  10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4
Lincoln Continental 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4
Camaro Z28          13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4
Duster 360          14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
Chrysler Imperial   14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4
Maserati Bora       15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8
Merc 450SLC         15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3
AMC Javelin         15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2
Dodge Challenger    15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2
Ford Pantera L      15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4
Merc 450SE          16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
Merc 450SL          17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3
Merc 280C           17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
Merc 280            19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
Pontiac Firebird    19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2
Ferrari Dino        19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
Volvo 142E          21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2
Toyota Corona       21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
Merc 230            22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
Merc 240D           24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
Porsche 914-2       26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2
Fiat X1-9           27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1
Honda Civic         30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2
Lotus Europa        30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2
Fiat 128            32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1
Toyota Corolla      33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1

对数据框的多列进行排序，首先按照第一列排序，如果第一列相同，则按照第二列、第n列…排序

carsOrderedIndex <- order(mtcars$mpg, mtcars$cyl,mtcars$disp)
mtcars[carsOrderedIndex,]
                     mpg cyl  disp  hp drat    wt  qsec vs am gear carb
Lincoln Continental 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4
Cadillac Fleetwood  10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4
Camaro Z28          13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4
Duster 360          14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
Chrysler Imperial   14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4
Maserati Bora       15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8
Merc 450SLC         15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3
AMC Javelin         15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2
Dodge Challenger    15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2
Ford Pantera L      15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4
Merc 450SE          16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
Merc 450SL          17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3
Merc 280C           17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
Merc 280            19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
Pontiac Firebird    19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2
Ferrari Dino        19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
Volvo 142E          21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
Toyota Corona       21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
Merc 230            22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
Merc 240D           24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
Porsche 914-2       26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2
Fiat X1-9           27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1
Honda Civic         30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2
Lotus Europa        30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2
Fiat 128            32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1
Toyota Corolla      33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1

合并数据集（按列）

1. merge() 函数

merge() 函数基于一个或多个共同的列（即键）合并两个数据框，可以指定合并的类型（如内连接、外连接等）。特点：

  • 基于共同的键合并数据框。
  • 可以指定合并的方式。
  • 会自动对结果数据框中的列名进行处理，以避免列名冲突。
# 创建两个数据框
df1 <- data.frame(key = c("A", "B", "C"), x = c(1, 2, 3))
df2 <- data.frame(key = c("A", "B", "D"), y = c("one", "two", "four"))
# 使用merge()进行内连接
merged_df <- merge(df1, df2, by = "key")
print(merged_df)
  key x   y
1   A 1 one
2   B 2 two

可以看到，merge的默认行为是保留待合并项的公共部分，不相同的将被丢弃。如果要保留所有数据，需要加上all=TRUE

merge(df1, df2, by = "key",all=TRUE)
  key  x    y
1   A  1  one
2   B  2  two
3   C  3 <NA>
4   D NA four

merge会自动解决合并过程中的列名冲突

df3 <- data.frame(key = c("A", "B", "C"), x = c(1, 2, 3))
merge(df1, df3, by = "key",all=TRUE)
  key x.x x.y
1   A   1   1
2   B   2   2
3   C   3   3

2. cbind() 函数

cbind() 函数用于将两个或多个向量、矩阵或数据框按列绑定在一起。特点：

  • 按列合并数据，不考虑键值匹配。
  • 如果合并的对象长度不同，会进行填充。
  • 通常用于合并具有相同行数的数据框。
# 使用cbind()合并数据框
cbind_df <- cbind(df1, df2)
print(cbind_df)
  key x key    y
1   A 1   A  one
2   B 2   B  two
3   C 3   D four

总结

  1. merge() 是专门用于数据框的，基于共同的键进行合并，类似于数据库的连接操作。
  2. cbind() 可以用于向量、矩阵和数据框，按列合并，不基于键值匹配。
  3. merge() 可以处理不同数据框中的列名冲突，而 cbind() 要求除了要合并的列之外，其他列名必须唯一。
  4. merge() 可以指定合并的方式（如内连接、外连接等），而 cbind() 总是将所有数据合并在一起，不考虑缺失值或键值匹配。

合并数据集（按行）

rbind()函数用于按行合并两个或多个向量、矩阵或数据框。它将数据按行叠加在一起，常用于追加观测值。

合并向量

vec1 <- c(1, 2, 3)
vec2 <- c(4, 5, 6)
rbind(vec1, vec2)
     [,1] [,2] [,3]
vec1    1    2    3
vec2    4    5    6

合并矩阵

mat1 <- matrix(1:4, nrow = 2)
mat2 <- matrix(5:8, nrow = 2)
rbind(mat1, mat2)
     [,1] [,2]
[1,]    1    3
[2,]    2    4
[3,]    5    7
[4,]    6    8

合并数据框

df1 <- data.frame(Name = c("Alice", "Bob"), Age = c(25, 30))
df2 <- data.frame(Name = c("Charlie", "David"), Age = c(35, 40))
rbind(df1, df2)
     Name Age
1   Alice  25
2     Bob  30
3 Charlie  35
4   David  40

rbind()注意事项:

  • 当使用 rbind() 合并数据框时，两个数据框必须具有相同数量的列，并且对应列的数据类型必须相同。
  • 如果数据框包含行名，rbind()会尝试保留这些行名。如果不想保留行名，可以在合并后使用 row.names() 函数重新设置。
  • rbind() 在合并时不会检查数据的一致性，所以确保合并的数据在逻辑上是有意义的。

选取变量

  1. 可以通过dataframe[行序号或名称,列序号或名称]的方式来选取数据框中的行和列
selected <- iris[c(1:4),c(1:2)]
print(selected)
  Sepal.Length Sepal.Width
1          5.1         3.5
2          4.9         3.0
3          4.7         3.2
4          4.6         3.1
selected <-iris[1:3,c("Petal.Length","Petal.Width")]
print(selected)
  Petal.Length Petal.Width
1          1.4         0.2
2          1.4         0.2
3          1.3         0.2
mat <- matrix(1:100,nrow = 10) 
colnames(mat) <- paste("V", 1:10, sep = "")
selected <-mat[,paste("V",1:5,sep = "")] 
print(selected)
      V1 V2 V3 V4 V5
 [1,]  1 11 21 31 41
 [2,]  2 12 22 32 42
 [3,]  3 13 23 33 43
 [4,]  4 14 24 34 44
 [5,]  5 15 25 35 45
 [6,]  6 16 26 36 46
 [7,]  7 17 27 37 47
 [8,]  8 18 28 38 48
 [9,]  9 19 29 39 49
[10,] 10 20 30 40 50
  1. 可以通过dataframe[行布尔值向量,]的方式来选取数据框中的行(观测值)
mtcars[mtcars$cyl>4 & mtcars$mpg>20,]
                mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4      21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag  21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
Hornet 4 Drive 21.4   6  258 110 3.08 3.215 19.44  1  0    3    1

行列筛选可组合进行：

mtcars[mtcars$cyl>4 & mtcars$mpg>20,c(1:3)]
                mpg cyl disp
Mazda RX4      21.0   6  160
Mazda RX4 Wag  21.0   6  160
Hornet 4 Drive 21.4   6  258

使用subset()函数

subset 函数是一个非常有用的函数，它提供了一种方便的方式从数据框或矩阵中选择满足特定条件的子集。

subset(x, subset, select, drop = FALSE, ...)，其中，x是要操作的数据框或矩阵,subset是一个逻辑表达式，用于指定要选择的行,select是要筛选的列名或列索引,drop如果为TRUE，则如果筛选结果只有一列，结果将是一个向量。默认FALSE

以airquality数据集为例，这个数据集包含了某地区的空气质量数据。有六个变量：Ozone（臭氧浓度）、Solar.R（太阳辐射）、Wind（风速）、Temp（温度）、Month（月份）、Day（日）。：

airquality数据集
Ozone Solar.R Wind Temp Month Day
41 190 7.4 67 5 1
36 118 8.0 72 5 2
12 149 12.6 74 5 3
18 313 11.5 62 5 4
NA NA 14.3 56 5 5
28 NA 14.9 66 5 6 
subset(airquality, Temp > 80)
    Ozone Solar.R Wind Temp Month Day
29     45     252 14.9   81     5  29
35     NA     186  9.2   84     6   4
36     NA     220  8.6   85     6   5
38     29     127  9.7   82     6   7
39     NA     273  6.9   87     6   8
40     71     291 13.8   90     6   9
41     39     323 11.5   87     6  10
42     NA     259 10.9   93     6  11
43     NA     250  9.2   92     6  12
44     23     148  8.0   82     6  13
61     NA     138  8.0   83     6  30
62    135     269  4.1   84     7   1
63     49     248  9.2   85     7   2
64     32     236  9.2   81     7   3
65     NA     101 10.9   84     7   4
66     64     175  4.6   83     7   5
67     40     314 10.9   83     7   6
68     77     276  5.1   88     7   7
69     97     267  6.3   92     7   8
70     97     272  5.7   92     7   9
71     85     175  7.4   89     7  10
72     NA     139  8.6   82     7  11
74     27     175 14.9   81     7  13
75     NA     291 14.9   91     7  14
77     48     260  6.9   81     7  16
78     35     274 10.3   82     7  17
79     61     285  6.3   84     7  18
80     79     187  5.1   87     7  19
81     63     220 11.5   85     7  20
83     NA     258  9.7   81     7  22
84     NA     295 11.5   82     7  23
85     80     294  8.6   86     7  24
86    108     223  8.0   85     7  25
87     20      81  8.6   82     7  26
88     52      82 12.0   86     7  27
89     82     213  7.4   88     7  28
90     50     275  7.4   86     7  29
91     64     253  7.4   83     7  30
92     59     254  9.2   81     7  31
93     39      83  6.9   81     8   1
94      9      24 13.8   81     8   2
95     16      77  7.4   82     8   3
96     78      NA  6.9   86     8   4
97     35      NA  7.4   85     8   5
98     66      NA  4.6   87     8   6
99    122     255  4.0   89     8   7
100    89     229 10.3   90     8   8
101   110     207  8.0   90     8   9
102    NA     222  8.6   92     8  10
103    NA     137 11.5   86     8  11
104    44     192 11.5   86     8  12
105    28     273 11.5   82     8  13
117   168     238  3.4   81     8  25
118    73     215  8.0   86     8  26
119    NA     153  5.7   88     8  27
120    76     203  9.7   97     8  28
121   118     225  2.3   94     8  29
122    84     237  6.3   96     8  30
123    85     188  6.3   94     8  31
124    96     167  6.9   91     9   1
125    78     197  5.1   92     9   2
126    73     183  2.8   93     9   3
127    91     189  4.6   93     9   4
128    47      95  7.4   87     9   5
129    32      92 15.5   84     9   6
134    44     236 14.9   81     9  11
143    16     201  8.0   82     9  20
146    36     139 10.3   81     9  23
subset(airquality, Temp > 80, select = c(Ozone, Temp))
    Ozone Temp
29     45   81
35     NA   84
36     NA   85
38     29   82
39     NA   87
40     71   90
41     39   87
42     NA   93
43     NA   92
44     23   82
61     NA   83
62    135   84
63     49   85
64     32   81
65     NA   84
66     64   83
67     40   83
68     77   88
69     97   92
70     97   92
71     85   89
72     NA   82
74     27   81
75     NA   91
77     48   81
78     35   82
79     61   84
80     79   87
81     63   85
83     NA   81
84     NA   82
85     80   86
86    108   85
87     20   82
88     52   86
89     82   88
90     50   86
91     64   83
92     59   81
93     39   81
94      9   81
95     16   82
96     78   86
97     35   85
98     66   87
99    122   89
100    89   90
101   110   90
102    NA   92
103    NA   86
104    44   86
105    28   82
117   168   81
118    73   86
119    NA   88
120    76   97
121   118   94
122    84   96
123    85   94
124    96   91
125    78   92
126    73   93
127    91   93
128    47   87
129    32   84
134    44   81
143    16   82
146    36   81
subset(airquality, Day == 1, select = -Temp)
    Ozone Solar.R Wind Month Day
1      41     190  7.4     5   1
32     NA     286  8.6     6   1
62    135     269  4.1     7   1
93     39      83  6.9     8   1
124    96     167  6.9     9   1
subset(airquality, select = Ozone:Wind)
    Ozone Solar.R Wind
1      41     190  7.4
2      36     118  8.0
3      12     149 12.6
4      18     313 11.5
5      NA      NA 14.3
6      28      NA 14.9
7      23     299  8.6
8      19      99 13.8
9       8      19 20.1
10     NA     194  8.6
11      7      NA  6.9
12     16     256  9.7
13     11     290  9.2
14     14     274 10.9
15     18      65 13.2
16     14     334 11.5
17     34     307 12.0
18      6      78 18.4
19     30     322 11.5
20     11      44  9.7
21      1       8  9.7
22     11     320 16.6
23      4      25  9.7
24     32      92 12.0
25     NA      66 16.6
26     NA     266 14.9
27     NA      NA  8.0
28     23      13 12.0
29     45     252 14.9
30    115     223  5.7
31     37     279  7.4
32     NA     286  8.6
33     NA     287  9.7
34     NA     242 16.1
35     NA     186  9.2
36     NA     220  8.6
37     NA     264 14.3
38     29     127  9.7
39     NA     273  6.9
40     71     291 13.8
41     39     323 11.5
42     NA     259 10.9
43     NA     250  9.2
44     23     148  8.0
45     NA     332 13.8
46     NA     322 11.5
47     21     191 14.9
48     37     284 20.7
49     20      37  9.2
50     12     120 11.5
51     13     137 10.3
52     NA     150  6.3
53     NA      59  1.7
54     NA      91  4.6
55     NA     250  6.3
56     NA     135  8.0
57     NA     127  8.0
58     NA      47 10.3
59     NA      98 11.5
60     NA      31 14.9
61     NA     138  8.0
62    135     269  4.1
63     49     248  9.2
64     32     236  9.2
65     NA     101 10.9
66     64     175  4.6
67     40     314 10.9
68     77     276  5.1
69     97     267  6.3
70     97     272  5.7
71     85     175  7.4
72     NA     139  8.6
73     10     264 14.3
74     27     175 14.9
75     NA     291 14.9
76      7      48 14.3
77     48     260  6.9
78     35     274 10.3
79     61     285  6.3
80     79     187  5.1
81     63     220 11.5
82     16       7  6.9
83     NA     258  9.7
84     NA     295 11.5
85     80     294  8.6
86    108     223  8.0
87     20      81  8.6
88     52      82 12.0
89     82     213  7.4
90     50     275  7.4
91     64     253  7.4
92     59     254  9.2
93     39      83  6.9
94      9      24 13.8
95     16      77  7.4
96     78      NA  6.9
97     35      NA  7.4
98     66      NA  4.6
99    122     255  4.0
100    89     229 10.3
101   110     207  8.0
102    NA     222  8.6
103    NA     137 11.5
104    44     192 11.5
105    28     273 11.5
106    65     157  9.7
107    NA      64 11.5
108    22      71 10.3
109    59      51  6.3
110    23     115  7.4
111    31     244 10.9
112    44     190 10.3
113    21     259 15.5
114     9      36 14.3
115    NA     255 12.6
116    45     212  9.7
117   168     238  3.4
118    73     215  8.0
119    NA     153  5.7
120    76     203  9.7
121   118     225  2.3
122    84     237  6.3
123    85     188  6.3
124    96     167  6.9
125    78     197  5.1
126    73     183  2.8
127    91     189  4.6
128    47      95  7.4
129    32      92 15.5
130    20     252 10.9
131    23     220 10.3
132    21     230 10.9
133    24     259  9.7
134    44     236 14.9
135    21     259 15.5
136    28     238  6.3
137     9      24 10.9
138    13     112 11.5
139    46     237  6.9
140    18     224 13.8
141    13      27 10.3
142    24     238 10.3
143    16     201  8.0
144    13     238 12.6
145    23      14  9.2
146    36     139 10.3
147     7      49 10.3
148    14      20 16.6
149    30     193  6.9
150    NA     145 13.2
151    14     191 14.3
152    18     131  8.0
153    20     223 11.5

当筛选结果只剩下一列，且drop=TRUE时，结果会退化成一个向量

subset(airquality, select = Ozone)
    Ozone
1      41
2      36
3      12
4      18
5      NA
6      28
7      23
8      19
9       8
10     NA
11      7
12     16
13     11
14     14
15     18
16     14
17     34
18      6
19     30
20     11
21      1
22     11
23      4
24     32
25     NA
26     NA
27     NA
28     23
29     45
30    115
31     37
32     NA
33     NA
34     NA
35     NA
36     NA
37     NA
38     29
39     NA
40     71
41     39
42     NA
43     NA
44     23
45     NA
46     NA
47     21
48     37
49     20
50     12
51     13
52     NA
53     NA
54     NA
55     NA
56     NA
57     NA
58     NA
59     NA
60     NA
61     NA
62    135
63     49
64     32
65     NA
66     64
67     40
68     77
69     97
70     97
71     85
72     NA
73     10
74     27
75     NA
76      7
77     48
78     35
79     61
80     79
81     63
82     16
83     NA
84     NA
85     80
86    108
87     20
88     52
89     82
90     50
91     64
92     59
93     39
94      9
95     16
96     78
97     35
98     66
99    122
100    89
101   110
102    NA
103    NA
104    44
105    28
106    65
107    NA
108    22
109    59
110    23
111    31
112    44
113    21
114     9
115    NA
116    45
117   168
118    73
119    NA
120    76
121   118
122    84
123    85
124    96
125    78
126    73
127    91
128    47
129    32
130    20
131    23
132    21
133    24
134    44
135    21
136    28
137     9
138    13
139    46
140    18
141    13
142    24
143    16
144    13
145    23
146    36
147     7
148    14
149    30
150    NA
151    14
152    18
153    20
subset(airquality, select = Ozone,drop = TRUE)
  [1]  41  36  12  18  NA  28  23  19   8  NA   7  16  11  14  18  14  34   6
 [19]  30  11   1  11   4  32  NA  NA  NA  23  45 115  37  NA  NA  NA  NA  NA
 [37]  NA  29  NA  71  39  NA  NA  23  NA  NA  21  37  20  12  13  NA  NA  NA
 [55]  NA  NA  NA  NA  NA  NA  NA 135  49  32  NA  64  40  77  97  97  85  NA
 [73]  10  27  NA   7  48  35  61  79  63  16  NA  NA  80 108  20  52  82  50
 [91]  64  59  39   9  16  78  35  66 122  89 110  NA  NA  44  28  65  NA  22
[109]  59  23  31  44  21   9  NA  45 168  73  NA  76 118  84  85  96  78  73
[127]  91  47  32  20  23  21  24  44  21  28   9  13  46  18  13  24  16  13
[145]  23  36   7  14  30  NA  14  18  20

subset的另一个用法是和with联用:

with(airquality, subset(airquality, Temp > 80))
    Ozone Solar.R Wind Temp Month Day
29     45     252 14.9   81     5  29
35     NA     186  9.2   84     6   4
36     NA     220  8.6   85     6   5
38     29     127  9.7   82     6   7
39     NA     273  6.9   87     6   8
40     71     291 13.8   90     6   9
41     39     323 11.5   87     6  10
42     NA     259 10.9   93     6  11
43     NA     250  9.2   92     6  12
44     23     148  8.0   82     6  13
61     NA     138  8.0   83     6  30
62    135     269  4.1   84     7   1
63     49     248  9.2   85     7   2
64     32     236  9.2   81     7   3
65     NA     101 10.9   84     7   4
66     64     175  4.6   83     7   5
67     40     314 10.9   83     7   6
68     77     276  5.1   88     7   7
69     97     267  6.3   92     7   8
70     97     272  5.7   92     7   9
71     85     175  7.4   89     7  10
72     NA     139  8.6   82     7  11
74     27     175 14.9   81     7  13
75     NA     291 14.9   91     7  14
77     48     260  6.9   81     7  16
78     35     274 10.3   82     7  17
79     61     285  6.3   84     7  18
80     79     187  5.1   87     7  19
81     63     220 11.5   85     7  20
83     NA     258  9.7   81     7  22
84     NA     295 11.5   82     7  23
85     80     294  8.6   86     7  24
86    108     223  8.0   85     7  25
87     20      81  8.6   82     7  26
88     52      82 12.0   86     7  27
89     82     213  7.4   88     7  28
90     50     275  7.4   86     7  29
91     64     253  7.4   83     7  30
92     59     254  9.2   81     7  31
93     39      83  6.9   81     8   1
94      9      24 13.8   81     8   2
95     16      77  7.4   82     8   3
96     78      NA  6.9   86     8   4
97     35      NA  7.4   85     8   5
98     66      NA  4.6   87     8   6
99    122     255  4.0   89     8   7
100    89     229 10.3   90     8   8
101   110     207  8.0   90     8   9
102    NA     222  8.6   92     8  10
103    NA     137 11.5   86     8  11
104    44     192 11.5   86     8  12
105    28     273 11.5   82     8  13
117   168     238  3.4   81     8  25
118    73     215  8.0   86     8  26
119    NA     153  5.7   88     8  27
120    76     203  9.7   97     8  28
121   118     225  2.3   94     8  29
122    84     237  6.3   96     8  30
123    85     188  6.3   94     8  31
124    96     167  6.9   91     9   1
125    78     197  5.1   92     9   2
126    73     183  2.8   93     9   3
127    91     189  4.6   93     9   4
128    47      95  7.4   87     9   5
129    32      92 15.5   84     9   6
134    44     236 14.9   81     9  11
143    16     201  8.0   82     9  20
146    36     139 10.3   81     9  23

使用sample()函数随机抽样

sample(x, size, replace = FALSE, prob = NULL)

  • x：表示要从中抽取样本的集合。可以是一个数字、字符或逻辑向量
  • size：指定要抽取的样本数量。可以是一个整数，也可以是一个与 x 长度相同的向量。
  • replace：一个逻辑值，指定抽样是否允许替换。如果 replace = FALSE，则进行无放回抽样；否则进行有放回抽样。1
  • prob：一个与 x 长度相同的向量，表示每个元素被抽取的概率。如果提供，这些概率必须是非负的，并且总和必须为1。如果不提供，所有元素被认为具有相同的抽取概率。
x <- 1:12
#随机抽取所有元素
sample(x)
 [1]  1  2  4 12  9 11  6 10  7  8  3  5
#随机抽取5个元素
sample(x,5)
[1]  5  2  7  3 12
#有放回抽样
sample(x, replace = TRUE)
 [1]  3  5  7  9  7 11 11  3  9  4  3  6
#无放回抽样
sample(x, replace = FALSE)
 [1]  9  4  5  1 10  2  6  7  3 11 12  8
#根据概率抽样
probs <- c(0.1, 0.1, 0.1, 0.1, 0.1, 0.3, 0.2, 0.1, 0.1, 0.1)
sample(1:10, 5, prob = probs)
[1]  7  3  2 10  4
# 从字符向量中随机抽取元素
sample(c("a", "b", "c", "d"), 3)
[1] "c" "b" "d"

sample函数用于数据框数据选取：

airquality[sample(3),]
  Ozone Solar.R Wind Temp Month Day
3    12     149 12.6   74     5   3
1    41     190  7.4   67     5   1
2    36     118  8.0   72     5   2

剔除变量

我们创建一个数据框来说明在R中如何去除我们不想要的数据

df <- data.frame(A = 1:3, B = letters[1:3], C = rnorm(3),D=c(TRUE,FALSE,FALSE))
df
  A B          C     D
1 1 a  0.4268635  TRUE
2 2 b  0.8134248 FALSE
3 3 c -0.7995522 FALSE

1. 使用NULL

注意，NULL和NA是完全不同的概念

#删除df的整列（注意：不可恢复）
df$B <- NULL
df
  A          C     D
1 1  0.4268635  TRUE
2 2  0.8134248 FALSE
3 3 -0.7995522 FALSE

2. 使用负号索引

df2 <- df[,c(-1,-3)]
df2
[1]  0.4268635  0.8134248 -0.7995522

3. 使用列名

df2 <- df[,colnames(df) != "B"]
df2
  A          C     D
1 1  0.4268635  TRUE
2 2  0.8134248 FALSE
3 3 -0.7995522 FALSE

4. 使用%in%

df <- data.frame(A = 1:3, B = letters[1:3], C = rnorm(3),D=c(TRUE,FALSE,FALSE))
selected <- colnames(df) %in% c("A","C")
df2 <- df[,selected] 
print(df2)
  A          C
1 1 -0.3990312
2 2 -0.1093854
3 3 -1.6723097
df3 <- df[,!selected]
print(df3)
  B     D
1 a  TRUE
2 b FALSE
3 c FALSE

附录(appendix)

format()完整参数列表

代码 描述 示例
%a 缩写的星期几名称 “Mon”, “Tue”, …
%A 完整的星期几名称 “Monday”, “Tuesday”, …
%b 缩写的月份名称 “Jan”, “Feb”, …
%B 完整的月份名称 “January”, “February”, …
%d 月份中的第几天（01到31） “01”, “02”, …, “31”
%e 月份中的第几天（1到31），不补0 “1”, “2”, …, “31”
%H 24小时制的小时（00到23） “00”, “01”, …, “23”
%I 12小时制的小时（01到12） “01”, “02”, …, “12”
%j 一年中的第几天 “001”, “002”, …, “366”
%m 月份（01到12） “01”, “02”, …, “12”
%M 分钟（00到59） “00”, “01”, …, “59”
%p AM 或 PM “AM”, “PM”
%S 秒（00到59） “00”, “01”, …, “59”
%U 一年中的第几个星期（星期日为一周的第一天） “00”, “01”, …, “52”
%w 星期几（0到6，0表示星期日） “0”, “1”, …, “6”
%W 一年中的第几个星期（星期一为一周的第一天） “00”, “01”, …, “52”
%x 适用于本地的日期格式 “01/02/03”, “04/05/06”, …
%X 适用于本地的时间格式 “12:34:56”
%y 年份的最后两位数字 “00”, “01”, …, “99”
%Y 四位数的年份 “2000”, “2001”, …
%Z 时区的名称 “PST”, “MDT”, …
%z 时区的偏移量（例如 “-0800”） “+0900”, “-0100”, …

Rdatasets

Rdatasets是一个提供大量示例数据集的资源库，它包含了数百个常见的数据集，涵盖了生物学、经济学、医学等多个领域。你可以通过Rdatasets包来访问这些数据集，或者直接从网上下载CSV格式的数据集。 Rdatasets链接

课后练习(exercises)

练习03-1：综合性编程题目

背景

假设你是一名数据分析师，需要处理一个包含员工信息的数据集。

任务

1. 读取数据

  • 从文本文件employees.csv中读取员工信息。该文件以逗号分隔，包含以下列：ID, Name, Age, Department, Salary, HireDate。请确保正确处理日期和缺失值。
  • 点这里下载employees.csv文件，或直接从网址http://roypub.biovr.cc/employees-salary.csv读取文件。

2. 清洗数据

  • 将Salary列中的缺失值替换为该列的中位数。
  • 将HireDate列转换为日期格式，并计算每位员工的工作年限（以年为单位，四舍五入到最接近的整数）。
  • 剔除Name或Department列中包含缺失值的行。

3. 分析数据

  • 计算所有员工的平均工资和中位数工资
  • 将数据按照工资从高到底排列。

4. 数据输出

  • 将清洗后的数据框输出到一个新的CSV文件cleaned_employees.csv。

提示：

  • 使用read.csv()函数读取文本文件。
  • 使用as.Date()转换日期格式，可能需要自定义日期格式。
  • 使用na.omit()剔除缺失值。
  • 使用order()函数进行数据排序。
  • 使用write.csv()函数将数据框输出到CSV文件。

R程序编写与数据处理-01