R语言学习笔记3-基本类型篇

基本类型介绍

1. 数值型（Numeric）：用于存储数值数据，可以是整数或浮点数。例如：2, 3.14, -5
2. 字符型（Character）：用于存储文本数据，必须用引号括起来。例如：“Hello, World!”, “R Programming”
3. 逻辑型（Logical）：用于存储逻辑值，表示真（True）或假（False）。在 R 中用 TRUE 或 FALSE 表示逻辑值，也可以用 T 或 F 的简写形式
4. 因子型（Factor）：可表示分类数据，具有预定义的取值范围和顺序。可通过 factor() 函数创建因子变量
5. 复数型（Complex）：用于存储复数数据，由实部和虚部组成，形式为 a + bi，其中 a 和 b 是实数，i 是虚数单位

数值型（Numeric）

整数型（Integer）

整数是没有小数部分的数值。整数通常会自动转换为数值型，但可使用 as.integer() 函数明确指定为整数类型

# 自动转换为数值型
num1 <- 42
class(num1)  # 输出 "numeric"

# 明确指定为整数型
num2 <- as.integer(10)
class(num2)  # 输出 "integer"

浮点数型（Double）

浮点数包含小数点，所有的数值默认为双精度浮点数

# 浮点数
num3 <- 3.14159
class(num3)  # 输出 "numeric"

# 科学计数法表示
num4 <- 6.022e23  # 6.022 × 10^23
class(num4)  # 输出 "numeric"

数值运算

数值型支持常见的算术运算和数学函数，如加法、减法、乘法、除法以及三角函数、对数函数等

# 算术运算
result1 <- 10 + 5
result2 <- 10 / 2
result3 <- sin(pi/2)

# 输出结果
print(result1)  # 输出 15
print(result2)  # 输出 5
print(result3)  # 输出 1 （sin(π/2) = 1）

数值型 NA（缺失值）

数值型可以是缺失值（NA），用来表示缺少数据或未知数据

missing_value <- NA

字符型（Character）

字符型可用于存储文本数据。字符型数据必须用引号（单引号或双引号）括起来，以区分其它数据类型

字符型的特点和用途

1. 存储文本数据：字符型主要用于存储字符串，例如单词、句子、文件路径等
2. 使用引号：字符型数据必须用引号括起来，可使用单引号 (') 或双引号 (")，但在 R 编程中推荐使用双引号
3. 灵活性：可以包含字母、数字、特殊字符等，几乎可以表示任何文本信息

基本字符型示例

# 使用双引号定义字符型变量
message <- "Hello, World!"
class(message)  # 输出 "character"

# 使用单引号定义字符型变量
file_path <- 'C:/Users/Documents/data.csv'
class(file_path)  # 输出 "character"

含有特殊字符的字符型示例

# 包含特殊字符和空格的字符串
special_string <- "R is a statistical language."
class(special_string)  # 输出 "character"

# 包含引号的字符串
quoted_string <- "He said, \"Hello!\""
print(quoted_string)  # 输出 He said, "Hello!"

字符串连接和处理

# 字符串连接
first_name <- "John"
last_name <- "Doe"
full_name <- paste(first_name, last_name, sep = " ")
print(full_name)  # 输出 "John Doe"

# 获取字符串长度
name_length <- nchar(full_name)
print(name_length)  # 输出 8

处理空字符串和空格

# 空字符串
empty_string <- ""
class(empty_string)  # 输出 "character"

# 去除字符串两端的空格
spaces_string <- "  Data Science  "
trimmed_string <- trimws(spaces_string)
print(trimmed_string)  # 输出 "Data Science"

逻辑型（Logical）

逻辑型用来表示逻辑值的数据类型，主要用于存储真（True）或假（False）两种逻辑状态

基本逻辑型示例

# 定义逻辑型变量
is_true <- TRUE
class(is_true)  # 输出 "logical"

is_false <- FALSE
class(is_false)  # 输出 "logical"

使用逻辑运算符

# 逻辑与运算符 &&
result1 <- TRUE && FALSE
print(result1)  # 输出 FALSE

# 逻辑或运算符 ||
result2 <- TRUE || FALSE
print(result2)  # 输出 TRUE

# 逻辑非运算符 !
result3 <- !TRUE
print(result3)  # 输出 FALSE

逻辑型在条件语句中的应用

# 条件判断
age <- 25
is_adult <- age >= 18
if (is_adult) {
  print("成年人")
} else {
  print("未成年人")
}

逻辑型与向量运算

# 创建一个数值型向量
numbers <- c(5, 10, 15, 20, 25)

# 逻辑条件判断
greater_than_10 <- numbers > 10
print(greater_than_10)  # 输出 TRUE FALSE TRUE TRUE TRUE

# 使用逻辑向量过滤数据
numbers_filtered <- numbers[greater_than_10]
print(numbers_filtered)  # 输出 15 20 25

逻辑型 NA（缺失值）

逻辑型也可以表示缺失值（NA），在某些情况下用于表示未知或不适用的状态。

missing_value <- NA
is_missing <- is.na(missing_value)
print(is_missing)  # 输出 TRUE

因子型（Factor）

因子型是一种特定的数据类型，用于表示分类数据，通常具有预定义的取值范围和顺序。因子型数据在统计分析中特别有用，因其可指定数据的类别和顺序，以便在分析中进行正确的排序和比较

因子型的特点和用途

1. 存储分类数据：主要用于存储和表示有限个类别的数据，如性别（男、女）、教育水平（高中、本科、硕士）、喜好（喜欢、不喜欢）等
2. 预定义的水平：因子型数据由预先定义的水平（levels）组成，每个水平代表一个可能的类别值
3. 有序和无序因子：因子可以是有序的（ordered），其中水平有明确的顺序，或者是无序的（unordered），其中水平没有特定的顺序

创建因子型变量

# 创建一个无序因子
education <- c("高中", "本科", "硕士", "本科", "高中", "硕士")
education_factor <- factor(education)
print(education_factor)
# 输出：
# [1] 高中 本科 硕士 本科 高中 硕士
# Levels: 本科 硕士 高中

# 查看因子的水平
levels(education_factor)
# 输出： "本科" "硕士" "高中"

# 创建一个有序因子
temperature <- c("高", "低", "中", "中", "高", "低")
temp_factor <- factor(temperature, ordered = TRUE, levels = c("低", "中", "高"))
print(temp_factor)
# 输出：
# [1] 高 低 中 中 高 低
# Levels: 低 < 中 < 高

# 查看有序因子的水平
levels(temp_factor)
# 输出： "低" "中" "高"

使用因子型进行数据分析

因子型在统计分析中很有用，特别是在绘图和汇总统计信息时

# 创建一个因子型向量
gender <- c("男", "女", "女", "男", "男")
gender_factor <- factor(gender)

# 统计各水平的频数
table(gender_factor)
# 输出：
# gender_factor
# 女 男 
#  2  3

修改因子的水平和标签

# 创建一个因子
seasons <- c("春", "夏", "秋", "冬", "春", "夏")
seasons_factor <- factor(seasons)

# 修改因子的水平顺序
seasons_factor <- factor(seasons_factor, levels = c("春", "夏", "秋", "冬"))

# 修改因子的标签
levels(seasons_factor) <- c("Spring", "Summer", "Autumn", "Winter")

print(seasons_factor)
# 输出：
# [1] Spring Summer Autumn Winter Spring Summer
# Levels: Spring Summer Autumn Winter

复数型（Complex）

在 R 语言中，并没有直接支持复数型作为基本的数据类型，复数通常在数学和工程领域中使用，但可以使用两个数值型的向量来表示复数的实部和虚部

创建复数

# 创建一个复数向量
complex_number <- complex(real = 3, imaginary = 4)
print(complex_number)
# 输出：
# [1] 3+4i

获取复数的实部和虚部

# 获取实部
real_part <- Re(complex_number)
print(real_part)
# 输出：
# [1] 3

# 获取虚部
imaginary_part <- Im(complex_number)
print(imaginary_part)
# 输出：
# [1] 4

复数的运算

R 提供了一些内置函数来处理复数的运算，例如加法、乘法等

# 定义两个复数
z1 <- complex(real = 3, imaginary = 4)
z2 <- complex(real = -2, imaginary = 5)

# 加法
sum_result <- z1 + z2
print(sum_result)
# 输出：
# [1] 1+9i

# 乘法
product_result <- z1 * z2
print(product_result)
# 输出：
# [1] -26+7i

复数的模和参数表示

可以使用 Mod() 函数获取复数的模，使用 Arg() 函数获取复数的幅角（弧度）

# 获取模
modulus <- Mod(complex_number)
print(modulus)
# 输出：
# [1] 5

# 获取幅角
argument <- Arg(complex_number)
print(argument)
# 输出：
# [1] 0.9272952

类型转换

数值型转换

数值型转换为字符型

可以使用 as.character() 函数将数值型转换为字符型

# 数值型转换为字符型
number <- 42
number_as_string <- as.character(number)
class(number_as_string)  # 输出 "character"

字符型转换为数值型

使用 as.numeric() 函数将字符型转换为数值型。注意，字符型必须表示为有效的数值形式，否则会产生 NA

# 字符型转换为数值型
number_as_string <- "42"
number <- as.numeric(number_as_string)
class(number)  # 输出 "numeric"

逻辑型转换

数值型转换为逻辑型

使用 as.logical() 函数将数值型数据转换为逻辑型，非零值为 TRUE，零值为 FALSE

# 数值型转换为逻辑型
number <- 1
logical_value <- as.logical(number)
class(logical_value)  # 输出 "logical"

逻辑型转换为数值型

逻辑型可以直接使用 as.numeric() 转换为数值型，TRUE 转换为 1，FALSE 转换为 0

# 逻辑型转换为数值型
is_true <- TRUE
number <- as.numeric(is_true)
class(number)  # 输出 "numeric"

因子型转换

因子型转换为字符型

使用 as.character() 函数将因子型数据转换为字符型

# 因子型转换为字符型
education <- factor(c("高中", "本科", "硕士"))
education_as_character <- as.character(education)
class(education_as_character)  # 输出 "character"

因子型转换为数值型

可以使用 as.numeric() 将因子转换为数值型，此时会得到因子水平的编码值

# 因子型转换为数值型
education <- factor(c("高中", "本科", "硕士"))
education_as_numeric <- as.numeric(education)
class(education_as_numeric)  # 输出 "numeric"