Frequently-Used Functions

R base cheatsheet.pdf

Object

函数	描述	说明
lobstr::obj_size(x)	对象所占内存空间的大小 (bytes)	由于列表储存的是指针而非数据，所以所占空间往往很小；字符串向量同理
tracemem() /untracemem()	开启/关闭对对象地址变动的追踪	对象被 copy 时，会自动打印一条说明
length(x)	对象的 size
is.*(x)	判断数据类型
as.*(x)	强制转换数据类型
typeof(x)/mode(x)	查看对象的数据类型	若对象为homogeneous data types，则返回元素的数据类型，如 integer, double, character, logical；若为异质性的列表或数据框，则返回 list
class(x) /unclass(x)	查看、去掉对象的类属性	返回 S3 对象的 class 属性
str(x)	对象的class、结构和概要信息
tibble::glimpse()	tibble 版str()，不显示class，只显示数据
dim(x)[<-]	返回/重置对象的维度
nrow()/ncol()	返回行数/列数，适用于 matrix, array, data.frame
summary(x)	按列汇总对象的基本信息	对于因子，汇总取每一个水平的行数；对于数值向量，返回重要的分位数；对于其他类型的列，则显示列的长度、类型和模式
head(x, n)	列出对象的前n个元素，默认n为6
tail(x, n)	列出对象的后n个元素

df <- data.table(id = 1:10, lower = letters[1:10])

typeof(df)

#> [1] "list"

class(df)

#> [1] "data.table" "data.frame"

str(df)

#> Classes 'data.table' and 'data.frame':   10 obs. of  2 variables:
#>  $ id   : int  1 2 3 4 5 6 7 8 9 10
#>  $ lower: chr  "a" "b" "c" "d" ...
#>  - attr(*, ".internal.selfref")=<externalptr>

glimpse(df)

#> Rows: 10
#> Columns: 2
#> $ id    <int> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
#> $ lower <chr> "a", "b", "c", "d", "e", "f", "g", "h", "i", "j"

df %>% summary()

#>        id           lower          
#>  Min.   : 1.00   Length:10         
#>  1st Qu.: 3.25   Class :character  
#>  Median : 5.50   Mode  :character  
#>  Mean   : 5.50                     
#>  3rd Qu.: 7.75                     
#>  Max.   :10.00

Logical

函数/运算符	描述	说明
& / magrittr::and()	向量化”与”
| / magrittr::or()	向量化”或”
! / magrittr::not()	向量化”非”
xor()	向量化”异或”	二者均为T或F，返回F；一为F一为T，返回T
&&	单值”与”	适合与 if 搭配
||	单值”或”	适合与 if 搭配
any(x, na.rm = FALSE)	是否任一为真	逻辑向量 x 的任何一个（至少一个）元素是 TRUE，返回 TRUE； 没有 TRUE 且包含 NA，返回 NA；只包含 FALSE，返回 FLASE
all(x, na.rm = FALSE)	是否全为真	逻辑向量 x 的任何一个（至少一个）元素是 FLASE，返回 FLASE； 没有 FLASE 且包含 NA，返回 NA；只包含 TRUE，返回 TRUE
>, >=, <, <=	大于、大于等于、小于、小于等于
==	（自动转换数据类型后的）值相等
identical(x, y)	严格相等	除了数值，数据类型也要一样
all.equal(a, b)/dplyr::near(a, b)	比较浮点数 a, b 之间是否相等	电脑运算浮点数有误差，所以比较浮点数是否相等时，不能使用==. all.equal()的可容忍误差是 1.5e-8
x %in% y / magrittr::is_in()	依次检查 x 向量中的元素是否包含于 y	返回一个与 x 长度相同的逻辑向量
is.na()	是否是 NA
is.null()	是否是 NULL

c(T, T) & c(T, F)

#> [1]  TRUE FALSE

c(T, T) | c(T, F)

#> [1] TRUE TRUE

!c(T, F)

#> [1] FALSE  TRUE

xor(c(T, T, F, F), c(T, F, T, F))

#> [1] FALSE  TRUE  TRUE FALSE

#' @title 检测递增递减
#' @description 只有x,y,z的对应元素全部递增，才会返回 1；
#'   全部递减，才会返回 -1；其他情况返回 0
test_all_direction <- function(x, y, z) {
  if (all(x < y & y < z)) {
    1
  } else if (all(x > y & y > z)) {
    -1
  } else {
    0
  }
}

any(c(TRUE, FALSE, NA))

#> [1] TRUE

any(c(FALSE, FALSE, NA))

#> [1] NA

any(c(FALSE, FALSE, NA), na.rm = TRUE)

#> [1] FALSE

any(c(FALSE, FALSE))

#> [1] FALSE

all(c(TRUE, FALSE, NA))

#> [1] FALSE

all(c(TRUE, TRUE, NA))

#> [1] NA

all(c(TRUE, TRUE, NA), na.rm = TRUE)

#> [1] TRUE

all(c(TRUE, TRUE))

#> [1] TRUE

1 == 1L

#> [1] TRUE

identical(1, 1L)

#> [1] FALSE

sin(pi) == 0

#> [1] FALSE

all.equal(sin(pi), 0)

#> [1] TRUE

c(1, 2, 5) %in% c(1, 2, 3, 4)

#> [1]  TRUE  TRUE FALSE

Index

函数	描述	说明
which(x)	返回 x 中值为 TRUE 的 index（忽略 NA）	x 是一个 logical vector，返回值可能也是一个向量。
which.min(x)/which.max(x)	返回 x 中最小/最大值的 index
match(x, vector)	返回 x 在 vector 中第一次匹配的位置	以上几个函数，若 x 为矩阵，则会将其视为按列展开的向量，返回的是复合条件的元素在向量中的 index
rank(x)	返回各元素在 x 所有元素中（从小到大）的次序
order(x)	按照递增/递减的次序重排列x后，新序列各元素在原序列x中的位置	从而保证 x[order(x)] 为x中元素递增、递减的重排列，使 x[order(x)] 等价于 sort(x) order()也可用于对一个对象的行或列进行排序

x <- c(-2, -1, 2, 1)
abs(x) >= 1.5

#> [1]  TRUE FALSE  TRUE FALSE

which(abs(x) >= 1.5)

#> [1] 1 3

x <- c(-2, -3, NA, 2, 3, 1, NA, 0, 1, NA, 2)
x >= 0

#>  [1] FALSE FALSE    NA  TRUE  TRUE  TRUE    NA  TRUE  TRUE    NA  TRUE

x[x >= 0] # 选择器使用 condition，会保留 NA 项

#> [1] NA  2  3  1 NA  0  1 NA  2

which(x >= 0)

#> [1]  4  5  6  8  9 11

x[which(x >= 0)] # 选择器使用 index，不保留 NA 项

#> [1] 2 3 1 0 1 2

match('e', letters)

#> [1] 5

rank(c(1, 3, 2, 4))

#> [1] 1 3 2 4

Set

单个向量

• unique(x), 提取不重复元素
• duplicated(x), 返回逻辑向量，非重复元素（首次出现）返回 FALSE，重复元素（之前出现过）返回 TRUE

两个向量的集合运算

• intersect()，交集
• setdiff()，集合的差，只保留第一个向量含有、第二个向量不含的元素
• union()，并集，保留所有元素，但重复的只保留一次
• setequal()，检测两个向量所含的元素是否完全相同（不考虑顺序，像集合一样）

Math

函数/运算符	描述	说明
基础数学
+, -, *, /, %/%（除法取整）, %%（除法取余）	四则运算	数学函数皆支持向量化运算
^	幂	\(10^k\) 可以用表达式 10^k，也可以直接写为 1ek 或 1Ek，计算机可以识别
log()/log10()/log2()	对数	参数为负数时，返回 NaN
exp()	以自然对数 \(e\) 为底的指数函数	常用 exp(1) 引入自然对数 \(e\)
sqrt()	平方根	参数为负数时，返回 NaN
abs()	绝对值
factorial()	阶乘
sign()	符号	正数返回1，0返回0，负数返回-1
is.finite()/is.infinite()	是否有限/无穷大
sin()/cos()/tan()/asin()/acos()/atan()/atan2()	三角函数
sinpi(x)/cospi(x)/tanpi(x)	精确计算浮点数的三角函数	相应三角函数的真实参数是 \(\pi\) 倍的x
sinh()/cosh()/tanh()/asinh()/acosh()/atanh()	双曲函数
pi	圆周率
取整
ceiling(x)	不小于x的最小整数
floor(x)	不大于x的最大整数
trunc(x)	向0的方向截取的x中的整数部分
round(x,n)	保留n位小数，四舍五入
signif(x,n)	保留n位有效数字
sprintf(fmt, ...)	C-style String Formatting
最值
range()	极值两端	用最小值和最大值返回一个长度为2的向量
max()/min()	最大/小值	na.rm=TRUE这个参数可以去掉所有的缺失值 如果参数为多个向量，返回其中所有元素的最值
pmax()/pmin()	平行最大/小值	如果参数为多个向量，返回相应位置的最大/小值（也是一个向量）
（累计）和/积
sum(x)/prod(x)	向量和/积	返回一个标量
cumsum(x)/cumprod(x)	返回累计和/积序列	返回一个向量 由新增求累计，非常好用的函数
dplyr::cummean(vector)	返回累计和的均值序列
排列组合
combn(x, k)	一个向量x中k个元素的所有组合	返回 matrix
expand.grid(var1 = x1, var2 = x2) /tidyr::crossing()	两个向量对应元素的所有排列，返回 data.frame	两个函数的用法几乎完全相同
进制转换
as.octmode(), as.hexmode()	将十进制数值转换为八进制、十六进制	接受整数，返回字符串
strtoi(x, base = kL)	将k进制的字符串转换为十进制整数	接受字符串，返回整数

5 %% c(1, 2, 3, 4, 5)

#> [1] 0 1 2 1 0

sign(-2:3)

#> [1] -1 -1  0  1  1  1

1 / 0

#> [1] Inf

is.finite(1 / 0)

#> [1] FALSE

log(0)

#> [1] -Inf

is.infinite(log(0))

#> [1] TRUE

#' @title 判断是否正无穷
#' @param x 可以为向量
is_pos_infinite <- function(x) {
  is.infinite(x) & x > 0
}

#' @title 判断是否负无穷
#' @param x 可以为向量
is_neg_infinite <- function(x) {
  is.infinite(x) & x < 0
}

is_pos_infinite(1 / 0)

#> [1] TRUE

is_neg_infinite(log(0))

#> [1] TRUE

sinpi(1)

#> [1] 0

cospi(0)

#> [1] 1

tanpi(1)

#> [1] 0

round(pi, 3)

#> [1] 3.142

signif(pi, 3)

#> [1] 3.14

sprintf("%f", pi)

#> [1] "3.141593"

sprintf("%.3f", pi)

#> [1] "3.142"

sprintf("%1.0f", pi)

#> [1] "3"

sprintf("%5.1f", pi)

#> [1] "  3.1"

sprintf("%05.1f", pi)

#> [1] "003.1"

sprintf("%+f", pi)

#> [1] "+3.141593"

sprintf("% f", pi)

#> [1] " 3.141593"

sprintf("%-10f", pi) # left justified

#> [1] "3.141593  "

sprintf("%e", pi)

#> [1] "3.141593e+00"

sprintf("%E", pi)

#> [1] "3.141593E+00"

sprintf("%g", pi)

#> [1] "3.14159"

sprintf("%g", 1e6 * pi) # -> exponential

#> [1] "3.14159e+06"

sprintf("%.9g", 1e6 * pi) # -> "fixed"

#> [1] "3141592.65"

sprintf("%G", 1e-6 * pi)

#> [1] "3.14159E-06"

max(
  c(1, 2, 3),
  c(2, 1, 2),
  c(1, 3, 4)
)

#> [1] 4

pmax(
  c(1, 2, 3),
  c(2, 1, 2),
  c(1, 3, 4)
)

#> [1] 2 3 4

#' @title 向量化分段函数
#' @description 若输入值小于−5，则取值为−5；
#'   若输入值介于−5～5 之间，则取值就是输入值；
#'   若输入值大于 5，则取值为 5
spread <- function(x) {
  pmin(5, pmax(-5, x))
}
spread(seq(-8, 8))

#>  [1] -5 -5 -5 -5 -4 -3 -2 -1  0  1  2  3  4  5  5  5  5

# 用 ifelse() 的等价写法
spread2 <- function(x) {
  ifelse(x < -5, -5, ifelse(x > 5, 5, x))
}
spread2(seq(-8, 8))

#>  [1] -5 -5 -5 -5 -4 -3 -2 -1  0  1  2  3  4  5  5  5  5

cumsum(1:10)

#>  [1]  1  3  6 10 15 21 28 36 45 55

cumprod(1:10)

#>  [1]       1       2       6      24     120     720    5040   40320  362880
#> [10] 3628800

dplyr::cummean(1:10)

#>  [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5

combn(letters[1:4], 2)

#>      [,1] [,2] [,3] [,4] [,5] [,6]
#> [1,] "a"  "a"  "a"  "b"  "b"  "c" 
#> [2,] "b"  "c"  "d"  "c"  "d"  "d"

expand.grid(n = c(1, 2, 3), x = c("a", "b"))

#>   n x
#> 1 1 a
#> 2 2 a
#> 3 3 a
#> 4 1 b
#> 5 2 b
#> 6 3 b

# 进制转换
as.octmode(255)

#> [1] "377"

as.hexmode(255)

#> [1] "ff"

strtoi(c("0xff", "077", "123")) # 通过前缀自动识别进制

#> [1] 255  63 123

strtoi(c("ffff", "FFFF"), 16L)

#> [1] 65535 65535

strtoi(c("177", "377"), 8L)

#> [1] 127 255

Numeric

函数	描述	说明
polyroot()	解多项式方程	参数为从常数项到最高阶项的系数向量
Re()	提取复数的实数部分
uniroot(f, interval)	任意一元方程求根	求方程 \(f(x)=0\) 的近似解，返回的列表包含了近似解、近似解处的函数值、迭代次数、根的估计精度等信息 要限定 interval，使区间内只有一个解，因为该函数不会智能地列出所有解
D(quote(原函数), "自变量")	求原函数的(偏)导函数	返回一个未被执行的表达式
eval(导函数表达式, list(自变量的值))	导函数在某点的值
integrate(f, lower，upper)	定积分的数值计算
optimise(f, interval, ..., maximum = FALSE)	极值点横坐标	计算 f(x) 在区间 interval 上最低（或最高）点的位置 与uniroot()一样，要限定 interval，使区间内只有一个极值，因为该函数不会智能地列出所有极值

polyroot(c(-2, 1, 1)) # 求 -2 + x + x^2 = 0 的解

#> [1]  1-0i -2+0i

Re(polyroot(c(-2, 1, 1))) # 提取实数部分

#> [1]  1 -2

polyroot(c(1, 0, 1)) # 求 1 + x^2 = 0 的根

#> [1] 0+1i 0-1i

## 求 e^x - 3 * e^(-x^2 + x) + 1 = 0 在 [-2, 2] 上的解
calY <- function(x) {
  exp(x) - 3 * exp(-x^2 + x) + 1
}
x <- seq(-2, 2, by = 0.001)
y <- calY(x)
plot(x, y) # 观察图形发现两个解的大概位置

uniroot(calY, c(-1, 0)) # 在单调区间内分别求解

#> $root
#> [1] -0.4180457
#> 
#> $f.root
#> [1] 1.335516e-05
#> 
#> $iter
#> [1] 5
#> 
#> $init.it
#> [1] NA
#> 
#> $estim.prec
#> [1] 6.103516e-05

uniroot(calY, c(0, 2))

#> $root
#> [1] 0.8643009
#> 
#> $f.root
#> [1] 2.703399e-05
#> 
#> $iter
#> [1] 7
#> 
#> $init.it
#> [1] NA
#> 
#> $estim.prec
#> [1] 6.103516e-05

uniroot(calY, c(-2, 2)) %>% try() # 如果区间包含了两个以上的解，会报错

#> Error in uniroot(calY, c(-2, 2)) : 
#>   f() values at end points not of opposite sign

## 求导
z <- D(quote(sin(x) * cos(x * y)), "x") # 对 x 的偏导函数
z # 导函数

#> cos(x) * cos(x * y) - sin(x) * (sin(x * y) * y)

eval(z, list(x = 1, y = 2))

#> [1] -1.75514

## 定积分
result <- integrate(dnorm, -1.96, 1.96)
result

#> 0.9500042 with absolute error < 1e-11

str(result)

#> List of 5
#>  $ value       : num 0.95
#>  $ abs.error   : num 1.05e-11
#>  $ subdivisions: int 1
#>  $ message     : chr "OK"
#>  $ call        : language integrate(f = dnorm, lower = -1.96, upper = 1.96)
#>  - attr(*, "class")= chr "integrate"

integrate(dnorm, -Inf, Inf)

#> 1 with absolute error < 9.4e-05

## 最优化
optimise(sin, c(0, 2 * pi)) # 极小值在 1.5*pi 处

#> $minimum
#> [1] 4.712391
#> 
#> $objective
#> [1] -1

optimise(sin, c(0, 2 * pi), maximum = TRUE) # 极大值在 pi/2 处

#> $maximum
#> [1] 1.570794
#> 
#> $objective
#> [1] 1

Statistical

函数	描述	说明
Data Transformation
cut(x, breaks, labels = NULL, right = TRUE, …)	将连续数据按数值分段	x 为待分段数据，breaks 为几个区间的边界，labels 为各段的标签. 默认各区间左开右闭，令 right=FALSE 则左闭右开。
scale(x, center = TRUE, scale = TRUE)	标准化	默认状态下，进行均值为0、标准差为1的标准化。 x可以是一个列向量，也可以是整个矩阵/数据框。此时 x 按列分别操作。
描述统计
summary(x)	显示对象的统计概要	显示连续型变量的最小值、最大值、均值和四分位数 显示类别型变量的频数值。
table(x)	统计每个元素的出现频数	若 x 为多个向量，则返回列联表； table(x)[x] 可返回等长向量，表示向量中每个元素对应的频数
mean()/median()/var()/sd()	平均值/中位数/方差/标准差	参数 trim 的取值在 0(0%) 到 0.5(50%) 之间，表示去掉最大的最小的 trim 比例的数据（认为是异常值），剩下的求平均 如果参数的 size 为偶数，mean() 会返回最中间两个数的平均值
cov(x, y)/cor(x, y)	协方差/相关系数（correlation）	接收一个数据框或矩阵时，返回每两列之间的协方差/相关系数矩阵
mad(x)	绝对中位差(median absolute deviation)
quantile(x, probs)	分位数	x 为待求分位数的数值型向量，probs 为一个由[0,1]之间的概率值组成的数值向量
fivenum()	返回最小值、25百分位数、 中位数、75百分位数、最大值
抽样与模拟
sample(vector, size, replace = F, prob)	抽样	replace 默认为 FALSE，不放回抽样 prob为抽样概率权重向量
replicate(n, expr)	重复运行	对第二个参数的表达式重复运行 n 次，返回向量。常用于产生一个样本
随机数
rnorm(n, mean = 0, sd = 1) runif(n, min = 0, max = 1)	分布相关函数	函数名为”前缀+具体分布”的形式，如runif()可以生成均匀分布随机数，dnorm()为正态密度函数。 前缀包括：d = 密度函数（density）；p = 累计分布函数（cumulative distribution function）；q = 分位数函数（quantile function）；r = 随机数生成器 具体分布：unif = 均匀分布；norm = 正态分布；pois = 泊松分布；binom = 二项分布。可以通过?Distributions 查询
set.seed()	设定随机数种子
MASS::mvrnorm(n, mean, sigma)	生成多元正态数据	n 为样本大小，mean 为均值向量，sigma 是方差-协方差矩阵 该函数返回一个矩阵
推断统计
lm(y~x, data = df)	线性回归模型
glm(y~x, data = df)	广义线性模型
stats4::mle()	极大似然估计模型	Maximum Likelihood Estimation, MLE
summary(model)	输出模型的更多细节
t.test(x, y)	两个向量均值的t检验
pairwise.t.test	成对数据的t检验
prop.test	test for a difference between proportions
aov	方差分析

age <- c(55, 12, 30, 9, 22, 24, 78, 109, 45, 66, 49)
cut(age, breaks = c(-Inf, 12, 30, 60, Inf), labels = c("小孩", "青年", "中年", "老年"))

#>  [1] 中年 小孩 青年 小孩 青年 青年 老年 老年 中年 老年 中年
#> Levels: 小孩 青年 中年 老年

x <- rnorm(50)
y <- 2 * x + 0.5 * rnorm(length(x))
z <- runif(length(x))
m1 <- cbind(x, y, z)
cor(m1)

#>            x          y          z
#> x  1.0000000  0.9700979 -0.1382418
#> y  0.9700979  1.0000000 -0.1253764
#> z -0.1382418 -0.1253764  1.0000000