《R语言》第2章：函数对象

返回课程主页

版权声明：本套课程材料开源，使用和分享必须遵守「创作共用许可协议 CC BY-NC-SA」（来源引用-非商业用途使用-以相同方式共享）。

---

Chap02：函数对象

往期要点回顾

• Chap01 # R包安装与管理

本章要点目录

• 【知识点】R对象与函数
• 【实践1】数值向量
• 【实践2】字符向量
• 【实践3】逻辑向量
• 【知识点】条件判断运算符与对象类型判断函数
• 【实践4】逻辑向量—数值向量—字符向量的相互转换（重点）
• 【实践5】向量元素命名与提取
• 【实践6】向量代数运算
• 【实践7】列表构建与操作（重点）
• 【知识点】R函数体的结构（重点）
• 【实践8】文件夹里有什么？
• 【实践9】今天晚上吃什么？
• 【实践10】正态分布随机数的平均值和标准差？
• 【实践11】“Hello World”的几种打印方法？

## 本章所需R包
library(bruceR)

bruceR (v2026.1)
Broadly Useful Convenient and Efficient R functions

Packages also loaded:
✔ dplyr         ✔ data.table
✔ tidyr         ✔ emmeans
✔ stringr       ✔ lmerTest
✔ forcats       ✔ effectsize
✔ ggplot2       ✔ performance
✔ cowplot       ✔ interactions

Main functions of `bruceR`:
cc()            Describe()  TTEST()
add()           Freq()      MANOVA()
.mean()         Corr()      EMMEANS()
set.wd()        Alpha()     PROCESS()
import()        EFA()       model_summary()
print_table()   CFA()       lavaan_summary()

For full functionality, please install all dependencies:
install.packages("bruceR", dep=TRUE)

Online documentation:
https://psychbruce.github.io/bruceR

To use this package in publications, please cite:
Bao, H. W. S. (2021). bruceR: Broadly useful convenient and efficient R functions (Version 2026.1) [Computer software]. https://doi.org/10.32614/CRAN.package.bruceR

R对象类型与相互转换

【知识点】R对象与函数

“万物皆对象，万事皆函数。” —— John Chambers（R语言创始人之一）

• “Everything that exists in R is an object.”
  （所用的一切都是对象）
  • 向量（vector）⭐️
    • 数值向量（numeric vector）
    • 字符向量（character vector）
    • 逻辑向量（logical vector）
  • 矩阵（matrix）
  • 数组（array）
  • 列表（list）⭐️
    • 混合存储多种类型的对象和数据
  • 数据框（data frame）⭐️
    • R里90%的分析都是围绕data.frame（包括data.table）展开的
    • 相当于Excel表格在R里的样子（每一列是一个变量，每一行是一个观测值）
• “Everything that happens in R is the result of a function call.”
  （所做的一切都是函数）

向量（vector）

• 单维、单类型数据

（1）数值向量

【实践1】数值向量

函数知识点

• c()：生成任何类型向量（合并一组同类型的数据）⭐️
  • “c”表示“combine”
• seq()：生成数值序列
• rep()：重复向量元素
• as.factor()：将任意类型向量转换为因子型向量⭐️
  • 因子（factor）本质上是带有“类别/分组信息”的向量（将向量中的不重复元素排序后作为类别选项）
  • 因子水平（levels）是所有可能的类别（当涉及类别间的对比时，默认以第一类为参照组）

1

[1] 1

1:5

[1] 1 2 3 4 5

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

[1] 1 2 3 4 5

c(1:5, 10, 15)

[1]  1  2  3  4  5 10 15

seq(1, 5, 0.5)

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

seq(from=1, to=5, by=0.5)

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

rep(1:2, 3)

[1] 1 2 1 2 1 2

rep(1:2, each=3)

[1] 1 1 1 2 2 2

a = c(2, 0, 0, 0, 6, 2)
a

[1] 2 0 0 0 6 2

unique(a)

[1] 2 0 6

a = as.factor(a)
a

[1] 2 0 0 0 6 2
Levels: 0 2 6

levels(a)  # 因子水平：所有可能的类别

[1] "0" "2" "6"

（2）字符向量

【实践2】字符向量

函数知识点

• length()：计算对象内的元素个数
• nchar()：计算字符串的字符个数
• str()：显示R对象的内部结构（常用于探索数据结构）⭐️
• factor()：比as.factor()更完整的因子型向量设定⭐️
  • levels：定义因子水平顺序
  • labels：定义因子取值标签
• cc()：比c()更方便的字符向量设定
  • 自动根据分隔符号（英文逗号、换行符等）拆解字符串

c(1:5, 10.5, "next")  # 如果混着放，统统变成字符型！

[1] "1"    "2"    "3"    "4"    "5"    "10.5" "next"

"Psychology"  # 一个字符串，本质上是一个长度为1的字符向量

[1] "Psychology"

"Psychology"[1]  # 向量的第1个元素

[1] "Psychology"

"Psychology"[0]  # 向量的第0个元素（没有）

character(0)

"Psychology"[2]  # 向量的第2个元素（缺失）

[1] NA

nchar("Psychology")  # 字符个数为10

[1] 10

a = c("Psychology", "ECNU", "Shanghai", "China")
a

[1] "Psychology" "ECNU"       "Shanghai"   "China"     

length(a)

[1] 4

nchar(a)  # 向量化计算

[1] 10  4  8  5

class(a)

[1] "character"

str(a)  # structure：显示R对象的结构

 chr [1:4] "Psychology" "ECNU" "Shanghai" "China"

as.factor(a)

[1] Psychology ECNU       Shanghai   China     
Levels: China ECNU Psychology Shanghai

factor(a, levels=c("China", "Shanghai", "ECNU", "Psychology"))

[1] Psychology ECNU       Shanghai   China     
Levels: China Shanghai ECNU Psychology

factor(
  a,
  levels = c("China", "Shanghai", "ECNU", "Psychology"),
  labels = c("CN", "SH", "ECNU", "Psy")
)

[1] Psy  ECNU SH   CN  
Levels: CN SH ECNU Psy

## cc() 用法：必须是英文逗号或换行符
cc("心理学, 社会学, 教育学, 管理学, 计算机, 人工智能")

[1] "心理学"   "社会学"   "教育学"   "管理学"   "计算机"   "人工智能"

cc("
心理学
社会学
教育学
管理学
计算机
人工智能
")

[1] "心理学"   "社会学"   "教育学"   "管理学"   "计算机"   "人工智能"

（3）逻辑向量

【实践3】逻辑向量

函数知识点

• %in%：向量化判断前一个对象的每个元素是否在后一个对象中
• ifelse()：根据条件语句，向量化逻辑判断

c(TRUE, TRUE, FALSE, TRUE, FALSE, FALSE)

[1]  TRUE  TRUE FALSE  TRUE FALSE FALSE

1:5 > 2

[1] FALSE FALSE  TRUE  TRUE  TRUE

c(0, 5, 10, 15) %in% 1:10

[1] FALSE  TRUE  TRUE FALSE

ifelse(1:10 >= 5, "Yes", "No")  # ifelse(test, yes, no)

 [1] "No"  "No"  "No"  "No"  "Yes" "Yes" "Yes" "Yes" "Yes" "Yes"

【知识点】条件判断运算符与对象类型判断函数

## 条件判断运算符
a == b
a != b
a > b
a < b
a >= b
a <= b
a %in% b

## 对象类型判断函数
is.na(x)
is.null(x)
is.numeric(x)
is.character(x)
is.factor(x)
# 还有非常多其他 is.xxx() 系列函数！

向量相互转换

【实践4】逻辑向量—数值向量—字符向量的相互转换

函数知识点

• as.logical()：0转换为FALSE，非0转换为TRUE
• as.character()：转换为字符向量
• as.numeric()：转换为数值向量（无法转换的记为NA缺失值）
• %>%：管道操作符⭐️（tidyverse系列包的通用函数）
  • 将前一个运行结果传递给后一个函数的第一个参数位置
  • 如果需要传递给后一个函数的其他参数位置，需要用点.占位
  • 快捷键：Ctrl + Shift + M（注意检查其他软件的快捷键冲突）
  • 如果提示没有"%>%"这个函数，请library(bruceR)或library(tidyverse)

as.logical(0:5)

[1] FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

as.character(0:5)

[1] "0" "1" "2" "3" "4" "5"

as.numeric(c("-1.5", "0", "1.5"))

[1] -1.5  0.0  1.5

as.numeric(c("1.2", "-.12", "1.2.3"))  # NA表示缺失值

Warning: 强制改变过程中产生了NA

[1]  1.20 -0.12    NA

a = c("Psychology", "ECNU", "Shanghai", "China")
as.factor(a)

[1] Psychology ECNU       Shanghai   China     
Levels: China ECNU Psychology Shanghai

a %>% as.factor()

[1] Psychology ECNU       Shanghai   China     
Levels: China ECNU Psychology Shanghai

a %>% as.factor() %>% as.numeric()

[1] 3 2 4 1

a %>% as.factor() %>% as.numeric() %>% c(200062)

[1]      3      2      4      1 200062

a %>% as.factor() %>% as.numeric() %>% c(., 200062)

[1]      3      2      4      1 200062

a %>% as.factor() %>% as.numeric() %>% c(200062, .)

[1] 200062      3      2      4      1

向量元素操作

【实践5】向量元素命名与提取

函数知识点

• names()：对象元素名称或命名
  • 直接使用：返回对象元素名称
  • 赋值使用：赋予对象元素名称（将会改变当前对象）
• x[...]：[]操作符取对象元素内容
  • x[逻辑/数值向量]：取对应位置元素（若为负数，则删除对应元素）
  • x[字符向量]：取对应名称元素
• rev()：向量反向排列
• sort()：按照数值大小或字母序重新排列
• unique()：取向量中的所有独特元素（去重复值）
• table()：向量元素频次统计

LETTERS  # 26个英文字母

 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
[20] "T" "U" "V" "W" "X" "Y" "Z"

a = 1:5
names(a)  # 直接用法（刚刚出生，还没名字）

NULL

names(a) = LETTERS[1:5]  # 赋值用法，a已改变
a

A B C D E 
1 2 3 4 5 

names(a)  # 现在上好户口，有名字了！

[1] "A" "B" "C" "D" "E"

a["E"]

E 
5 

a[c("A", "C", "E")]

A C E 
1 3 5 

a[-1]  # 删除元素，但不改变a

B C D E 
2 3 4 5 

a[-(2:4)]  # 删除元素，但不改变a

A E 
1 5 

x = c(2, 0, 0, 0, 6, 2)
rev(x)

[1] 2 6 0 0 0 2

sort(x)

[1] 0 0 0 2 2 6

unique(x)

[1] 2 0 6

x %>% unique() %>% sort() %>% rev()

[1] 6 2 0

table(x)

x
0 2 6 
3 2 1 

x %in% 1:5

[1]  TRUE FALSE FALSE FALSE FALSE  TRUE

x[x %in% 1:5]

[1] 2 2

x[x %in% 1:5] = NA
x

[1] NA  0  0  0  6 NA

【实践6】向量代数运算

函数知识点

• sum()、mean()：对一个向量对象求和、求平均值
• paste()：把向量元素拼接在一起
  • sep参数：多个输入之间的黏合字符
  • collaspe参数：向量不同元素之间的黏合字符

a = 1:5
a + 1    # 1:5 + 1 【思考：a + 1:2 的结果？】

[1] 2 3 4 5 6

a * 2    # 1:5 * 2

[1]  2  4  6  8 10

a^2      # (1:5)^2

[1]  1  4  9 16 25

a * 5:1  # 对应位置相乘，长度必须相等

[1] 5 8 9 8 5

a %% 2   # 取余数

[1] 1 0 1 0 1

sum(1:100)  # 高斯求和

[1] 5050

mean(1:100)  # 求平均值

[1] 50.5

paste(1, 2, 3, 4, 5, sep=" ")  # 多个输入之间

[1] "1 2 3 4 5"

paste(1:5, collapse=" ")  # 向量不同元素之间

[1] "1 2 3 4 5"

paste(1:10, collapse="+")  # 打印计算公式

[1] "1+2+3+4+5+6+7+8+9+10"

cat(paste(1:10, collapse="+"), "=", sum(1:10))

1+2+3+4+5+6+7+8+9+10 = 55

abs(log(sqrt(pi)))

[1] 0.5724

pi |> sqrt() |> log() |> abs()     # 新版R内置管道操作符

[1] 0.5724

pi %>% sqrt() %>% log() %>% abs()  # tidy系列管道操作符（建议使用）

[1] 0.5724

列表（list）

• 单维、多类型数据

【实践7】列表构建与操作

函数知识点

• list()：建立一个列表对象，可存储任意类型、任意结构的对象
  • $：根据元素名称，取列表中的元素内容（Tab键弹出所有元素名称）
  • [[...]]：取列表中对应位置的元素内容（不同于[...]）
• unlist()：解除列表结构，还原为向量
• lapply()：批量应用函数，返回为列表

输入后按Tab键弹出所有元素名称

l = list(Year=2000:2015, Month=1:12, Day=1:31, Letter=LETTERS)
l

$Year
 [1] 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
[16] 2015

$Month
 [1]  1  2  3  4  5  6  7  8  9 10 11 12

$Day
 [1]  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] 26 27 28 29 30 31

$Letter
 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
[20] "T" "U" "V" "W" "X" "Y" "Z"

names(l)

[1] "Year"   "Month"  "Day"    "Letter"

length(l)

[1] 4

l$Year

 [1] 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
[16] 2015

l[2]    # 取第2个子集，返回list子集

$Month
 [1]  1  2  3  4  5  6  7  8  9 10 11 12

l[[2]]  # 取第2个元素，返回元素本身，相当于 l$Month

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

unlist(l)  # 解除列表结构，强行统一对象类型（数值 -> 字符）

   Year1    Year2    Year3    Year4    Year5    Year6    Year7    Year8 
  "2000"   "2001"   "2002"   "2003"   "2004"   "2005"   "2006"   "2007" 
   Year9   Year10   Year11   Year12   Year13   Year14   Year15   Year16 
  "2008"   "2009"   "2010"   "2011"   "2012"   "2013"   "2014"   "2015" 
  Month1   Month2   Month3   Month4   Month5   Month6   Month7   Month8 
     "1"      "2"      "3"      "4"      "5"      "6"      "7"      "8" 
  Month9  Month10  Month11  Month12     Day1     Day2     Day3     Day4 
     "9"     "10"     "11"     "12"      "1"      "2"      "3"      "4" 
    Day5     Day6     Day7     Day8     Day9    Day10    Day11    Day12 
     "5"      "6"      "7"      "8"      "9"     "10"     "11"     "12" 
   Day13    Day14    Day15    Day16    Day17    Day18    Day19    Day20 
    "13"     "14"     "15"     "16"     "17"     "18"     "19"     "20" 
   Day21    Day22    Day23    Day24    Day25    Day26    Day27    Day28 
    "21"     "22"     "23"     "24"     "25"     "26"     "27"     "28" 
   Day29    Day30    Day31  Letter1  Letter2  Letter3  Letter4  Letter5 
    "29"     "30"     "31"      "A"      "B"      "C"      "D"      "E" 
 Letter6  Letter7  Letter8  Letter9 Letter10 Letter11 Letter12 Letter13 
     "F"      "G"      "H"      "I"      "J"      "K"      "L"      "M" 
Letter14 Letter15 Letter16 Letter17 Letter18 Letter19 Letter20 Letter21 
     "N"      "O"      "P"      "Q"      "R"      "S"      "T"      "U" 
Letter22 Letter23 Letter24 Letter25 Letter26 
     "V"      "W"      "X"      "Y"      "Z" 

## lapply(向量或列表, 函数)
lapply(l, length)  # 每个元素批量应用length()函数

$Year
[1] 16

$Month
[1] 12

$Day
[1] 31

$Letter
[1] 26

lapply(l, mean)    # 每个元素批量应用mean()函数

Warning in mean.default(X[[i]], ...): 参数不是数值也不是逻辑值：返回NA

$Year
[1] 2008

$Month
[1] 6.5

$Day
[1] 16

$Letter
[1] NA

a = 1:5
a^2

[1]  1  4  9 16 25

lapply(a, function(x) x^2)  # x是形参（形式参数）

[[1]]
[1] 1

[[2]]
[1] 4

[[3]]
[1] 9

[[4]]
[1] 16

[[5]]
[1] 25

lapply(a, function(x) x^2) %>% unlist()

[1]  1  4  9 16 25

R函数使用与参数设置

【知识点】R函数体的结构

• function(...)：函数接收输入参数，内部操作后，返回输出结果
  • { }：大括号内定义所有形式参数（形参）的操作过程
  • 返回结果可用两种方式
    • return(...)：显式返回
    • invisible(...)：隐式返回

func = function(param1, param2, ...) {
  ## 函数内部操作
  results = param1 + param2
  cat(param1, "+", param2, "=", results, "\n")
  
  ## 函数返回结果
  return(results)
  # 也可以隐式返回：
  # invisible(results)
}
func(16, 9)

16 + 9 = 25 

[1] 25

常用R函数使用

【实践8】文件夹里有什么？

## 请自己运行
library(bruceR)
set.wd()  # 设置工作路径为当前打开文件的路径

list.files()          # 列出当前路径的所有文件/文件夹
list.files("../")     # 列出上一级路径的所有文件/文件夹
list.files("../../")  # 列出上两级路径的所有文件/文件夹

【实践9】今天晚上吃什么？

## 请自己运行
choice = c("河西食堂", "河东食堂", "环球港", "点外卖")
sample(choice, size=1)  # 随机抽样

# 设置随机种子，使结果可重复
set.seed(123)  # 随机种子可以是任意整数，没有特定含义
sample(choice, size=1)

【实践10】正态分布随机数的平均值和标准差？

set.seed(123)  # 设置随机种子，使结果可重复
x = rnorm(30)  # 生成30个随机数（正态分布）

mean(x)  # 求平均值

[1] -0.0471

sd(x)    # 求标准差

[1] 0.981

hist(x)  # 画直方图

x > mean(x) + sd(x)         # 返回TRUE/FALSE向量

 [1] FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE
[13] FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[25] FALSE FALSE FALSE FALSE FALSE  TRUE

x[x > mean(x) + sd(x)]      # 返回(取出)符合条件的数值

[1] 1.559 1.715 1.224 1.787 1.254

which(x > mean(x) + sd(x))  # 返回符合条件数值所在位置

[1]  3  6 11 16 30

set.seed(123)  # 设置随机种子，使结果可重复
x = rnorm(1000)  # 生成1000个随机数（正态分布）

mean(x)  # 求平均值

[1] 0.01613

sd(x)    # 求标准差

[1] 0.9917

hist(x)  # 画直方图

【实践11】“Hello World”的几种打印方法？

函数知识点

• cli是命令行交互的专业R包，系统性提供了各种输出文本设定函数
  • 详见：https://cli.r-lib.org/

print("Hello World!")

[1] "Hello World!"

cat("Hello World!")

Hello World!

cat("Hello", "World!")

Hello World!

cli::cli_text("Hello World!")

Hello World!

cli::cli_h1("Hello World!")

── Hello World! ────────────────────────────────────────────────────────────────

cli::cli_h2("Hello World!")

── Hello World! ──

cli::cli_h3("Hello World!")

── Hello World! 

cli::cli_alert("Hello World!")

→ Hello World!

cli::cli_alert_success("Hello World!")

✔ Hello World!

cli::cli_alert_info("Hello World!")

ℹ Hello World!

cli::cli_alert_warning("Hello World!")

! Hello World!

cli::cli_alert_danger("Hello World!")

✖ Hello World!

R逻辑控制语句

if判断语句

if (condition) {
  # Do something
} else if {
  # Do something
} else {
  # Do sth. else
}

x = 3
if (x %in% 1:5) {
  cat("Yes")
} else {
  cat("No")
}

Yes

while循环语句

while (condition) {
  # Do something
}

x = 1
while (x < 5) {
  cat(x, "is smaller than 5\n")
  x = x + 1
}

1 is smaller than 5
2 is smaller than 5
3 is smaller than 5
4 is smaller than 5

for循环语句

for (var in seq) {
  # Do something
}

for (x in 1:5) {
  y = x * 2
  print(y)
}

[1] 2
[1] 4
[1] 6
[1] 8
[1] 10

【作业3】编程解决抛硬币问题

问题情境：一枚硬币，连续抛了N次都是正面朝上，再抛一次反面朝上的概率是多少？

• 比如，一枚硬币，连续抛了3次都是正面朝上，再抛一次反面朝上的概率是多少？
• 连续10次呢？连续1000次呢？连续1亿次呢？……
• 思路提示：用假设检验的思想，判断这枚硬币是不是普通硬币（H0：硬币是普通的）

作业要求：

• 编写一段R程序，计算并判断至少连续多少次正面朝上，可以认定硬币不再是普通硬币（拒绝零假设）
• 尽可能用R Markdown完成

平台提交：

• R代码和运行结果截图