R语言基础数据类型/数据结构/常用函数

Posted 2021-04-12 五李三张

前面讲了；；。随后想梳理一下R语言数据格式，恰好今天在网上冲浪是发现了关于数据类型、数据格式以及常用函数的超直白介绍，通俗易懂。原文连接：

https://bookdown.org/qiyuandong/intro_r

数据类型

主要有这几种：

• 数值型 numerics (1, 2.5)
• 逻辑判断 logical (TRUE or FALSE)
• 字符型 characters
• 因子 factors

# Change my_numeric to be 42
my_numeric <-42

# Change my_character to be "universe"
my_character <- "universe"

# Change my_logical to be FALSE
my_logical <-FALSE

# 思考：不同的类型能加减吗？

因子factors复杂一点，也非常有用，单独来讲一下。

如何判断数据类型？ 使用class() 函数。

示例：

# Declare variables of different types:
my_numeric <-42
my_character <- "universe"
my_logical <-FALSE

# Check class of my_numeric
class(my_numeric)
## [1] "numeric"
# Check class of my_character
class(my_character)
## [1] "character"
# Check class of my_logical
class(my_logical)
## [1] "logical"

数据结构

有这么几个：vector 向量、matrix 矩阵，dataframe 数据集，list 列表。其中：向量可以构成矩阵 ；矩阵是特殊的数据集 ；list 是个筐，什么都能装。

1 vector 向量

向量是用于存储数值型、字符型或逻辑型数据的一维数组。执行组合功能的函数c()可用来创建向量。

a <-c(1, 2, 5, 3, 6, -2, 4)
b <-c("apple", "pear", "orange")
c <-c(TRUE, FALSE, TRUE, FALSE, TRUE, FALSE)

这里，a是数值型向量，b是字符型向量，而c是逻辑型向量。

注意：单个向量中的数据必须拥有相同的类型或模式（数值型、字符型或逻辑型）。物以类聚，各从其类，同一向量中无法混杂不同模式的数据。

通过在方括号中给定元素所处位置的数值，我们可以访问向量中的元素。例如a[c(2)]用于访问向量a中的第二个元素。

a[c(2)]
## [1] 2

更多示例如下：

b[c(1,3)]
## [1] "apple"  "orange"
c[c(2:4)]
## [1] FALSE  TRUE FALSE

最后一个语句中使用的冒号,意思是取第二个到第三元素。

2 matrix 矩阵

矩阵是一个二维数组，只是每个元素都拥有相同的模式（数值型、字符型或逻辑型）。可通过函数matrix()创建矩阵。一般使用格式为：

myymatrix <-matrix(vector, nrow=number_of_rows, ncol=number_of_columns,
                    byrow=logical_value)

其中vector包含了矩阵的元素，nrow和ncol用以指定行和列的维数，dimnames包含了可选的、以字符型向量表示的行名和列名。选项byrow则表明矩阵应当按行填充（byrow=TRUE）还是按列填充（byrow=FALSE），默认情况下按列填充。

myMatrix <-matrix(1:15, nrow=3, ncol=5)
myMatrix
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    4    7   10   13
## [2,]    2    5    8   11   14
## [3,]    3    6    9   12   15

我们可以使用下标和方括号来选择矩阵中的行、列或元素。X[i,]指矩阵X中的第i行，X[,j]指第j列，X[i, j]指第 i 行第 j 个元素。选择多行或多列时，下标 i 和 j 可为数值型向量。

y <-matrix(1:18, nrow=2)
y
##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
## [1,]    1    3    5    7    9   11   13   15   17
## [2,]    2    4    6    8   10   12   14   16   18
y[2,]
## [1]  2  4  6  8 10 12 14 16 18
y[,1]
## [1] 1 2
y[2,c(3:5)]
## [1]  6  8 10

矩阵都是二维的，和向量类似，矩阵中也仅能包含一种数据类型。

3 dataframe 数据框

由于不同的列可以包含不同模式（数值型、字符型等）的数据，所以啊，数据框真是是个筐，什么都能装！数据框将是你在R中最常处理的数据结构。

表2-1所示的分数数据集包含了数值型和字符型数据。由于数据有多种模式，无法将此数据集放入一个矩阵。在这种情况下，使用数据框是最佳选择。

students <-c("A", "B", "C", "D")
math_score<-c(100, 80, 70, 95)
english_score<-c(96, 86, 77, 99)
students_scores<-data.frame(students, math_score,english_score)

划重点：列与列之间数据类型可以不一样，但是每一列数据类型必须一直。 我们在讨论数据框时将交替使用术语列和变量。* 选取数据框中元素的方式：可以使用前述（如矩阵中的）下标记号，亦可直接指定列名，例如：

students_scores[,2]
## [1] 100  80  70  95
students_scores[,"math_score"]
## [1] 100  80  70  95
students_scores$math_score
## [1] 100  80  70  95

第三个例子中的记号$是新出现的,它被用来选取一个给定数据框中的某个特定变量。例如，如果你想生成学生名字变量students和数学成绩变量math的新数据框，使用以下代码即可：

data.frame(students_scores$students, students_scores$math_score)
##   students_scores.students students_scores.math_score
## 1                        A                        100
## 2                        B                         80
## 3                        C                         70
## 4                        D                         95

4 因子 factor

因子 factor又叫分类变量，有两种：名义型、有序型。名义型，例如，学生的名字，它们之间是没有顺序的；有序型，例如，好评，中评，差评，它们之间有顺序关系，但是没有数量关系，得不出来不同级别之间的差异具体是多少。

相对应的，像之前例子里，分数则是一个连续性变量，呈现为某个范围内的任意值，并同时表示了顺序和数量，例如95分就是比90分要高，并且是高5分。

因子在R中非常重要，因为它决定了数据的分析方式以及如何进行视觉呈现。

函数factor()以一个整数向量的形式存储类别值，整数的取值范围是[1…k]（其中 k 是名义型变量中唯一值的个数），同时一个由字符串（原始值）组成的内部向量将映射到这些整数上。

是不是有点晕，不着急，我们看点例子：

excellence<-c("excellent", "bad", "good", "okay", "bad")
excellence<-factor(excellence)
excellence
## [1] excellent bad       good      okay      bad
## Levels: bad excellent good okay
excellence <-factor(excellence, order=TRUE,
                     levels=c("bad", "okay","good","excellent"))
excellence
## [1] excellent bad       good      okay      bad
## Levels: bad < okay < good < excellent

这里我们成功的把字符型变量excellence，先转换成了无序因子变量，再转换成了有顺序的因子变量。

数值型变量可以用levels和labels参数来编码成因子。如果男性被编码成1，女性被编码成2，则以下语句：

sex<-c(1,2,2,1,2,1,1,3)
sex
## [1] 1 2 2 1 2 1 1 3
sex <-factor(sex, levels=c(1, 2), labels=c("Male", "Female"))
sex
## [1] Male   Female Female Male   Female Male   Male   <NA>
## Levels: Male Female

在这个栗子里，性别被当成类别型变量，标签“Male”和“Female”替代了1和2在结果中输出，而且所有不是1或2的性别变量将被设为缺失值。

5 list 列表

列表（list）是R的数据类型中最为复杂的一种。一般来说，列表就是一些对象（或成分，component）的有序集合。列表允许你整合若干（可能无关的）对象到单个对象名下。例如，某个列表中可能是若干向量、矩阵、数据框，甚至其他列表的组合。可以使用函数list()创建列表：

a <- "My First List"
b <-c(25, 26, 18, 39)
c <-matrix(1:10, nrow=5)
d <-c("one", "two", "three")
mylist <-list(title=a ,b,c,d)
mylist
## $title
## [1] "My First List"
##
## [[2]]
## [1] 25 26 18 39
##
## [[3]]
##      [,1] [,2]
## [1,]    1    6
## [2,]    2    7
## [3,]    3    8
## [4,]    4    9
## [5,]    5   10
##
## [[4]]
## [1] "one"   "two"   "three"

本例创建了一个列表，其中有四个成分：一个字符串、一个数值型向量、一个矩阵以及一个字符型向量。可以组合任意多的对象，并将它们保存为一个列表。

常用函数

• length(object) ：显示对象中元素/成分的数量

length(mtcars)
## [1] 11
length(mtcars$mpg)
## [1] 32

• dim(object)：显示某个对象的维度

dim(mtcars)
## [1] 32 11

• str(object) ：显示某个对象的结构

str(mtcars)
## 'data.frame':    32 obs. of  11 variables:
##  $ mpg : num  21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
##  $ cyl : num  6 6 4 6 8 6 8 4 4 6 ...
##  $ disp: num  160 160 108 258 360 ...
##  $ hp  : num  110 110 93 110 175 105 245 62 95 123 ...
##  $ drat: num  3.9 3.9 3.85 3.08 3.15 2.76 3.21 3.69 3.92 3.92 ...
##  $ wt  : num  2.62 2.88 2.32 3.21 3.44 ...
##  $ qsec: num  16.5 17 18.6 19.4 17 ...
##  $ vs  : num  0 0 1 1 0 1 0 1 1 1 ...
##  $ am  : num  1 1 1 0 0 0 0 0 0 0 ...
##  $ gear: num  4 4 4 3 3 3 3 4 4 4 ...
##  $ carb: num  4 4 1 1 2 1 4 2 2 4 ...

• class(object)：显示某个对象的类或类型

class(mtcars)
## [1] "data.frame"

• names(object)：显示某对象中各成分的名称

names(mtcars)
##  [1] "mpg"  "cyl"  "disp" "hp"   "drat" "wt"   "qsec" "vs"   "am"   "gear"
## [11] "carb"

• c(object, object,…)：将对象合并入一个向量

c(2, 20)
## [1]  2 20

• cbind(object, object, …)：按列合并对象

cbind(students, math_score)
##      students math_score
## [1,] "A"      "100"
## [2,] "B"      "80"
## [3,] "C"      "70"
## [4,] "D"      "95"

• rbind(object, object, …)：按行合并对象

rbind(students, math_score)
##            [,1]  [,2] [,3] [,4]
## students   "A"   "B"  "C"  "D"
## math_score "100" "80" "70" "95"

• head(object)：列出某个对象的开始部分

head(mtcars)
##                    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
## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

• tail(object)：列出某个对象的最后部分

tail(mtcars)
##                 mpg cyl  disp  hp drat    wt qsec vs am gear carb
## Porsche 914-2  26.0   4 120.3  91 4.43 2.140 16.7  0  1    5    2
## Lotus Europa   30.4   4  95.1 113 3.77 1.513 16.9  1  1    5    2
## Ford Pantera L 15.8   8 351.0 264 4.22 3.170 14.5  0  1    5    4
## Ferrari Dino   19.7   6 145.0 175 3.62 2.770 15.5  0  1    5    6
## Maserati Bora  15.0   8 301.0 335 3.54 3.570 14.6  0  1    5    8
## Volvo 142E     21.4   4 121.0 109 4.11 2.780 18.6  1  1    4    2

• ls()：显示当前的对象列表

ls()
##  [1] "a"               "b"               "c"
##  [4] "d"               "english_score"   "excellence"
##  [7] "lucky_numbers"   "math_score"      "my_character"
## [10] "my_logical"      "my_numeric"      "my_var"
## [13] "mylist"          "myMatrix"        "sex"
## [16] "students"        "students_scores" "y"

• rm(object, object, …)：删除一个或更多个对象。

rm(a, b, c)
ls()
##  [1] "d"               "english_score"   "excellence"
##  [4] "lucky_numbers"   "math_score"      "my_character"
##  [7] "my_logical"      "my_numeric"      "my_var"
## [10] "mylist"          "myMatrix"        "sex"
## [13] "students"        "students_scores" "y"

• rm(list = ls())：将删除当前工作环境中的几乎所有对象。

今天的分享就到这里，欢迎关注，点赞，再看，转发~