生信自学路线｜R语言的数据变量类型与对应运算

R 是一种动态类型语言，使用灵活，变量无需预先声明类型。掌握 R 的数据类型和变量机制，是后续进行数据处理和建模分析的基础。本章节主要介绍 R 语言中的常量、变量、基本数据类型及常用数据结构，并结合示例进行说明。

一、常量（Constants）

常量是指程序中直接写出的固定值，例如数字、字符串、逻辑值、复数等。在 R 中，常量具有不同的表现形式。

1. 数值型常量

数值型常量包括整数、浮点数和科学计数法表示形式。例如：

x1 <- 123
x2 <- -0.012
x3 <- 1.23e2   # 等价于123
x4 <- 123L     # 表示整数类型（L 结尾）

2. 字符型常量

字符常量是由双引号或单引号括起来的文本。在 R 中，字符类型用于表示字符串：

name1 <- "Li Ming"
name2 <- '李明'

注意：R 没有单独的“字符（character）”类型和“字符串（string）”类型，二者统一称为 character。

3. 逻辑型常量

逻辑型常量仅包括 TRUE 和 FALSE，表示布尔值：

flag1 <- TRUE
flag2 <- FALSE
flag3 <- flag1 & flag2   # 与操作

4. 缺失值常量

R 使用 NA 表示缺失值，广泛出现在统计分析中。

v <- c(1, 2, NA, 4)
mean(v)                  # 返回 NA
mean(v, na.rm = TRUE)    # 去除缺失值后计算均值

字符型空白不会自动识别为 NA，需要手动转换。

5. 复数常量

R 支持复数类型。复数常量的形式如下：

z <- 2 + 3i
Mod(z)    # 计算复数的模长

二、变量（Variables）

程序语言中的变量用来保存输入的值或者计算得到的值。在 R 中，变量可以保存所有类型的数据，包括标量、向量、矩阵、数据框、函数等。

1. 变量名命名规则

变量名是变量的标识符。R 语言的变量命名需要遵循以下规则：

• 由字母、数字、下划线 _ 和句点 . 组成；
• 第一个字符不能为数字；
• R 中变量名区分大小写，如 x 和 X 是两个不同的变量；
• 在中文操作系统中，也可以使用中文作为变量名（不推荐）。

x <- 10
y <- 20
Data_1 <- "变量"
变量名 <- "合法但不推荐"

2. 变量赋值方式

R 中常用 <- 进行赋值，也可使用 =。建议优先使用 <-，更符合 R 编程规范。

a <- 5
b = 10
sum <- a + b
print(sum)

3. 动态类型语言特征

R 是动态类型语言，变量的类型在赋值时自动确定，可以随时被修改为其他类型：

x <- 1.5        # 数值型
x <- "abc"      # 重新赋值为字符型
x <- TRUE       # 再次赋值为逻辑型

尽管 R 支持类型切换，实际编程中应避免频繁更改同一变量的类型。

三、基本数据类型（Atomic Types）

R 语言的基本数据类型包括以下几类：

可使用 typeof() 或 class() 查看变量类型：

x <- 3.14
typeof(x)   # 返回 "double"
class(x)    # 返回 "numeric"

四、常用数据结构（Data Structures）

R 支持多种数据结构，用于组织和管理不同类型和维度的数据。

1. 向量（vector）

向量是 R 最基本的数据结构，包含相同类型的一组元素。

v <- c(1, 2, 3, 4)
length(v)       # 返回元素个数
mean(v)         # 求均值

2. 矩阵（matrix）

矩阵是二维向量，所有元素类型必须一致。

m <- matrix(1:6, nrow = 2, byrow = TRUE)
print(m)

3. 数据框（data.frame）

数据框是类似于表格的二维数据结构，每列可以是不同类型。

df <- data.frame(
  name = c("Tom", "Amy"),
  score = c(90, 85),
  passed = c(TRUE, FALSE)
)
print(df)

4. 列表（list）

列表是一种可容纳任意类型对象的数据结构，常用于模型输出、函数返回值等场景。

lst <- list(
  id = 1,
  name = "Tom",
  scores = c(85, 90)
)
lst$name

5. 因子（factor）

因子用于存储分类变量，有固定的水平（levels）。

gender <- factor(c("Male", "Female", "Male"))
levels(gender)
summary(gender)

五、数据访问与子集提取

R 提供多种方式访问数据结构中的元素。

1. 向量访问

v <- c(100, 200, 300)
v[2]         # 返回第二个元素

2. 数据框访问

df <- data.frame(id = 1:3, score = c(80, 85, 90))

df[1, 2]          # 第1行第2列
df$score          # 按列名访问
df[df$score > 80, ]  # 筛选得分大于80的行

3. 列表访问

lst <- list(name = "Amy", age = 25)
lst$name
lst[["age"]]

六、数值型向量及其运算（Numeric Vectors and Their Operations）

1. 数值型向量的创建

R 语言中，数值型向量是由一组数值组成的线性结构，是最基本的数据单位。可以使用 c() 函数将多个数值组合成一个向量，也可以通过冒号 : 或 seq() 函数生成等差数列。

x <- c(10, 6, 4, 7, 8)
y <- c(1:3, 10:13)
z1 <- c(1, 2)
z2 <- c(3, 4)
z <- c(z1, z2)

numeric(5)    # 创建一个元素全部为 0、长度为 5 的向量
length(z)     # 返回向量的长度

长度为 0 的向量用 numeric(0) 表示。

2. 标量与标量运算

R 中的标量（单个数值）本质上是长度为 1 的向量，支持加减乘除乘方等常见运算：

1.5 + 2.3 - 0.6 + 2.1 * 1.2 - 1.5 / 0.5 + 2^3
## [1] 10.72

# 使用括号控制优先级
1.5 + 2.3 - (0.6 + 2.1) * 1.2 - 1.5 / 0.5 + 2^3
## [1] 5.56

R 还支持整除（%/%）和取余（%%）：

5 %/% 3    # 商为 1
5 %% 3     # 余数为 2

3. 向量与标量运算

向量与标量进行运算时，会将标量扩展为与向量等长，逐元素进行运算：

x <- c(1, 10)

x + 2      # 每个元素加 2
x * 2      # 每个元素乘 2
2 ^ x      # 以 2 为底，对 x 中每个元素进行乘方

缺失值参与运算会返回缺失：

c(1, NA, 3) + 10
## [1] 11 NA 13

4. 向量与向量运算

两个等长向量进行运算时，按对应元素逐一计算：

x1 <- c(1, 10)
x2 <- c(4, 2)

x1 + x2    # [1]  5 12
x1 * x2    # [1]  4 20

如果向量长度不一致，但较长者是较短者长度的整数倍，R 会自动重复短向量的元素：

x1 <- c(10, 20)
x2 <- c(1, 3, 5, 7)

x1 + x2
## [1] 11 23 15 27

若长度不是整数倍，将返回计算结果但伴随警告信息：

c(1, 2) + c(1, 2, 3)
## Warning: longer object length is not a multiple of shorter object length

5. 向量函数与向量化计算

R 中的许多数学函数都是向量化的，接受向量输入并返回对应的向量输出：

sqrt(c(1, 4, 6.25))
## [1] 1.0 2.0 2.5

log10(c(1, 10, 100))
exp(c(0, 1, 2))

常用函数包括：

• 平方根：sqrt()
• 对数与指数：log(), log10(), exp()
• 绝对值与符号：abs(), sign()
• 三角函数：sin(), cos(), tan()
• 舍入：round(), floor(), ceiling(), trunc()

6. 排序函数与顺序函数

排序函数可以用于向量排序及下标操作：

x <- c(33, 55, 11)

sort(x)         # 升序排列
rev(sort(x))    # 降序排列
order(x)        # 获取排序下标
x[order(x)]     # 排序后的向量

7. 常用统计函数

R 中统计函数直接作用于数值向量，计算基本统计量：

x <- c(88, 92, 76, 81, 95, 67, 90, 85, 73, 89)

mean(x)     # 平均值
sd(x)       # 标准差
min(x)      # 最小值
max(x)      # 最大值
median(x)   # 中位数
sum(x)      # 总和
range(x)    # 范围

还有累计函数：

cumsum(1:5)     # 累计和
cumprod(1:5)    # 累计积

8. 序列与重复生成函数

使用 seq() 生成规则数列，rep() 生成重复模式：

seq(1, 10, by = 2)
## [1] 1 3 5 7 9

rep(0, 5)                        # 生成五个零
rep(c(1, 3), 2)                  # [1] 1 3 1 3
rep(c(1, 3), each = 2)           # [1] 1 1 3 3
rep(c(1, 3), times = c(2, 4))    # [1] 1 1 3 3 3 3

seq() 与 : 区别：1:5 生成整数序列，seq(1, 5, by=1) 更灵活，可设步长、长度。

9. 复数向量

R 中可用 complex() 生成复数向量，支持实部、虚部或模角定义：

z <- complex(real = c(1, 0, -1, 0), imaginary = c(0, 1, 0, -1))
z
## [1]  1+0i  0+1i -1+0i  0-1i

Re(z); Im(z); Mod(z); Arg(z); Conj(z)

当运算涉及复数时，需显式写出复数形式：

sqrt(-1)
## NaN with warning

sqrt(-1 + 0i)
## [1] 0+1i

七、逻辑型向量及其运算（Logical Vectors and Logical Operations）

1. 逻辑型向量与比较运算

逻辑型（logical）是 R 的基本数据类型之一，只有两个取值：TRUE 和 FALSE，缺失值表示为 NA。逻辑值通常来源于比较表达式。例如：

sele <- (log10(15) < 2)
print(sele)
## [1] TRUE

对向量进行比较时，会生成逻辑型向量，结果逐元素返回布尔值：

c(1, 3, 5) > 2
## [1] FALSE  TRUE  TRUE

(1:4) >= (4:1)
## [1] FALSE FALSE  TRUE  TRUE

R 的比较遵循向量间运算的一般规则：

• 向量与标量之间比较：每个元素与标量分别比较；
• 等长向量比较：对应元素逐一比较；
• 不等长但满足倍数关系：较短向量从头重复利用。

含缺失值的比较将产生 NA：

c(1, NA, 3) > 2
## [1] FALSE    NA  TRUE

NA == NA
## [1] NA

用 is.na() 判断是否为缺失值，用 is.finite() 判断是否为有限值：

is.na(c(1, NA, 3) > 2)
## [1] FALSE  TRUE FALSE

比较运算符包括：

%in% 将右侧向量视为集合，判断左侧元素是否存在其中：

c(1, 3) %in% c(2, 3, 4)
## [1] FALSE  TRUE

c(NA, 3) %in% c(NA, 3, 4)
## [1] TRUE TRUE

函数 match(x, y) 与 %in% 类似，但返回的是匹配元素在 y 中首次出现的位置，若找不到返回 NA：

match(c(1, 3), c(2, 3, 4, 3))
## [1] NA  2

2. 逻辑运算

为了表达复合条件，可以使用逻辑运算符将多个逻辑表达式连接：

示例：

age <- c(2, 5, 3, 6)
sex <- c("女", "女", "男", "男")

# 女婴（年龄≤3且性别为女）
age <= 3 & sex == "女"
## [1]  TRUE FALSE FALSE FALSE

# 婴儿或女性
age <= 3 | sex == "女"
## [1]  TRUE  TRUE  TRUE FALSE

# 既非婴儿也非女性
!(age <= 3 | sex == "女")
## [1] FALSE FALSE FALSE  TRUE

短路逻辑运算符 && 和 || 只比较第一个元素，常用于 if 或 while 等流程控制语句中：

if (TRUE || sqrt(-1) > 0) print("不会报错")

由于 TRUE || ... 的结果已确定，右侧不会被执行，避免了运行错误。

3. 逻辑运算函数

有时需要从逻辑型向量中计算汇总结果，R 提供了如下函数：

• all(x)：所有元素为 TRUE 时返回 TRUE
• any(x)：任意一个元素为 TRUE 即返回 TRUE
• which(x)：返回逻辑值为 TRUE 的下标

示例：

cond <- c(1, NA, 3) > 2

all(cond)
## [1] FALSE

any(cond)
## [1] TRUE

which(cond)
## [1] 3

当逻辑向量全为缺失时：

all(NA)
## [1] NA

any(NA)
## [1] NA

4.其他常用逻辑函数：

• identical(x, y)：判断两个对象是否完全相同（类型和值均一致）
• all.equal(x, y)：判断两个对象是否“接近相等”，常用于数值误差容忍比较
• duplicated(x)：判断每个元素是否在前面出现过
• unique(x)：返回去重后的结果

示例：

duplicated(c(1, 2, 1, 3, NA, 4, NA))
## [1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

unique(c(1, 2, 1, 3, NA, 4, NA))
## [1]  1  2  3 NA  4

identical(c(1L, 2L, 3L), c(1, 2, 3))
## [1] FALSE    # 类型不一致：一个是整数，一个是双精度

all.equal(c(1L, 2L, 3L), c(1, 2, 3))
## [1] TRUE

八、字符型数据及其处理（Character Data and String Handling）

1. 字符型向量

字符型向量是元素为字符串的一类向量。在 R 中，字符串使用双引号 "" 或单引号 '' 包裹。例如：

s1 <- c('abc', '', 'a cat', NA, '李明')

注意：空字符串 "" 不能自动识别为缺失值，字符型的缺失值需显式写为 NA。

字符串的常见来源包括文件读取、网络请求、数据库提取等，也可以直接在代码中写出。

2. 转义字符与原始字符串

在字符串中包含特殊字符（如引号、换行符）时需使用反斜杠 \ 进行转义：

cat("\"\n")
## "

\n 表示换行。若字符串中包含较多转义内容，可使用原始字符串语法 r"(...)"：

cat(r"(C:\disk\course\math\nFinished!\n)")
## C:\disk\course\math\nFinished!\n

若原始字符串中包含圆括号 ()，可改用 [] 或 {}，必要时还可加减号标识范围：

r"[(...)]"、r"{...}"、r"--((...))--"

3. 字符串拼接：paste() 函数

paste() 是处理字符型向量最常用的函数。默认逐元素拼接，并以空格分隔：

paste(c("ab", "cd"), c("ef", "gh"))
## [1] "ab ef" "cd gh"

R 遵循向量化运算规则，支持数值自动转换为字符串：

paste("x", 1:3)
## [1] "x 1" "x 2" "x 3"

• 使用 sep= 可指定分隔符：

  paste("x", 1:3, sep = "")
  ## [1] "x1" "x2" "x3"
  

• 使用 collapse= 可将整个字符向量合并为单个字符串：

  paste(c("a", "b", "c"), collapse = "")
  ## [1] "abc"
  

4. 转换大小写

R 提供了大小写转换函数：

• toupper() 将字符串转换为大写；
• tolower() 将字符串转换为小写。

toupper("aB cd")
## [1] "AB CD"

tolower(c("aB", "CD"))
## [1] "ab" "cd"

该方法常用于不区分大小写的比较：

toupper("jan") == "JAN"
## [1] TRUE

5. 字符串长度计算

• nchar(x, type = "chars")：按字符数统计（中文一个字符）；
• nchar(x, type = "bytes")：按字节统计（中文通常占两个字节）。

x <- c("abc", "李明")
nchar(x, type = "chars")   # [1] 3 2
nchar(x, type = "bytes")   # [1] 3 6

绘图时可用 strwidth() 计算文本所占空间宽度。

6. 提取子串

• substr(x, start, stop)：提取指定起止位置的子串；
• substring(x, start)：从指定位置提取到末尾。

substr("JAN07", 1, 3)
## [1] "JAN"

substr(c("JAN07", "MAR66"), 1, 3)
## [1] "JAN" "MAR"

substring(c("JAN07", "MAR66"), 4)
## [1] "07" "66"

7. 类型转换

• 用 as.numeric() 将字符串转换为数值；
• 用 as.character() 将数值转换为字符串；
• 用 sprintf() 进行格式控制的转换；
• 使用 readr::parse_number() 提取字符串中的数值部分。

as.numeric(substr("JAN07", 4, 5)) + 2000
## [1] 2007

as.character((1:5)*5)
## [1] "5"  "10" "15" "20" "25"

sprintf("file%03d.txt", c(1, 99, 100))
## [1] "file001.txt" "file099.txt" "file100.txt"

readr::parse_number(c("output-123.txt", "30.2%", "abc"))
## [1] -123.000  30.200       NA

parse_number() 可提取字符串中的数值部分，而 parse_integer() 等函数则要求字符串完全为目标类型，否则返回 NA 并提供提示信息。

8. 字符串替换

用 gsub() 函数可以实现字符串中模式的替换操作，例如将标点统一或清理空格：

x <- "1, 3; 5"
gsub(";", ",", x, fixed = TRUE)
## [1] "1, 3, 5"

此类功能常用于数据预处理、文本清洗等场景。

9. 正则表达式匹配

正则表达式（regular expression）可用于模式匹配、查找与替换等高级文本处理。R 中支持 Perl 风格的正则语法，常用函数包括：

• grepl() / grep()：匹配查询；
• gsub() / sub()：替换操作。

示例：替换多个空格为一个空格

gsub("[[:space:]]+", " ", "a   cat  in a box", perl = TRUE)
## [1] "a cat in a box"

正则表达式具有强大表达能力，在处理网络抓取文本、自然语言处理等任务中应用广泛。

参考引用

1. Wickham, H., & Grolemund, G. (2016). R for Data Science. O’Reilly Media.
   在线阅读：https://r4ds.hadley.nz

2. R 官方语言手册
   https://cran.r-project.org/manuals.html

3. RDocumentation: R 函数与包参考平台
   https://www.rdocumentation.org