R 编程/数据类型
向量（Vectors）是 R 中最简单的对象，一个给定类型（例如实数、字符串、逻辑值）的原始 R 对象的有序列表。向量由从 1 开始的整数索引。因子（Factors）类似于向量，但每个元素都是分类的，即固定数量的可能性之一（或水平（levels））。矩阵（Matrix）类似于向量，但具有特定的布局指令，使其看起来像一个矩阵，即元素由两个整数索引，每个整数都从 1 开始。数组（Arrays）类似于矩阵，但可以具有超过 2 个维度。列表（List）类似于向量，但元素不必都属于同一类型。列表的元素可以通过整数或命名字符串进行索引，即 R 列表可以用来实现其他语言中所谓的“关联数组”、“哈希表”、“映射”或“字典”。数据框（Dataframe）类似于矩阵，但不假设所有列都具有相同的类型。数据框是相同长度的变量/向量的列表。类（Classes）定义了特定类型对象（objects）的外观。类作为属性（attribute）附加到对象。所有 R 对象都具有类、类型和维度。
> class(object)
> typeof(object)
> dim(object)
您可以使用c()函数创建向量，该函数连接一些元素。您可以使用:符号或seq()函数创建序列。例如1:5给出 1 到 5 之间的所有数字。该seq()函数允许您指定连续数字之间的间隔。您还可以使用rep()函数重复模式。您还可以使用numeric()创建缺失值的数值向量，使用character()创建缺失值的字符向量，以及使用FALSE的逻辑向量创建缺失值（即）logical()
> c(1,2,3,4,5)
[1] 1 2 3 4 5
> c("a","b","c","d","e")
[1] "a" "b" "c" "d" "e"
> c(T,F,T,F)
[1] TRUE FALSE TRUE FALSE
> 1:5
[1] 1 2 3 4 5
> 5:1
[1] 5 4 3 2 1
> seq(1,5)
[1] 1 2 3 4 5
> seq(1,5,by=.5)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
> rep(1,5)
[1] 1 1 1 1 1
> rep(1:2,5)
[1] 1 2 1 2 1 2 1 2 1 2
> numeric(5)
[1] 0 0 0 0 0
> logical(5)
[1] FALSE FALSE FALSE FALSE FALSE
> character(5)
[1] "" "" "" "" ""
该length()计算向量的长度。last()(sfsmisc) 返回向量的最后一个元素，但这也可以在无需额外包的情况下简单地实现。
x <- seq(1,5,by=.5) # Create a sequence of number
x # Display this object
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
> length(x) # Get length of object x
[1] 9
> library(sfsmisc)
> last(x) # Select the last element of x
[1] 5.0
> x[length(x)] # Select the last element wihout an extra package.
[1] 5.0
factor()将向量转换为因子。因子也可以使用选项进行排序ordered=T或函数ordered(). levels()返回因子的水平。gl()生成因子。n是水平的数量，k每个因子的重复次数，以及length因子的总长度。labels是可选的，并为每个水平提供标签。
因子最容易被认为是分类变量。因子分析的一个重要函数是table()函数，它提供了一种摘要类型。在考虑统计数据类型（名义、有序、区间和比率）时，因子可以是名义、有序或区间。名义因子是分类名称，例如与某些其他信息配对的国家名称。有序因子的一个例子是特定运动员的一组比赛时间，以及与运动员的完成位置（第一名、第二名等）配对。在尝试总结此因子时，请参阅下面关于有序示例的示例，了解有关自行排序因子的示例。最后，区间级因子的一个示例是年龄组，例如“20-29”、“30-39”等。通常，R 可以自动适当地对存储为因子的数字进行排序，但程序员可以使用相同的方法处理此类数据，以使其以最适合其应用程序的方式进行排序。
另请参阅is.factor(), as.factor(), is.ordered()和as.ordered().
> factor(c("yes","no","yes","maybe","maybe","no","maybe","no","no"))
[1] yes no yes maybe maybe no maybe no no
Levels: maybe no yes
>
> factor(c("yes","no","yes","maybe","maybe","no","maybe","no","no"), ordered = T)
[1] yes no yes maybe maybe no maybe no no
Levels: maybe < no < yes
>
> ordered(c("yes","no","yes","maybe","maybe","no","maybe","no","no"))
[1] yes no yes maybe maybe no maybe no no
Levels: maybe < no < yes
>
> ordered(as.factor(c("First","Third","Second","Fifth","First","First","Third")),
+ levels = c("First","Second","Third","Fourth","Fifth"))
[1] First Third Second Fifth First First Third
Levels: First < Second < Third < Fourth < Fifth
>
> gl(n=2, k=2, length=10, labels = c("Male", "Female")) # generate factor levels
[1] Male Male Female Female Male Male Female Female Male Male
Levels: Male Female
- 如果要创建一个新矩阵，一种方法是使用matrix()函数。您必须输入一个数据向量、行数和/或列数，最后您可以指定是否希望 R 按行或按列读取您的向量（默认选项）。以下为两个示例。
> matrix(data = NA, nrow = 5, ncol = 5, byrow = T)
[,1] [,2] [,3] [,4] [,5]
[1,] NA NA NA NA NA
[2,] NA NA NA NA NA
[3,] NA NA NA NA NA
[4,] NA NA NA NA NA
[5,] NA NA NA NA NA
> matrix(data = 1:15, nrow = 5, ncol = 5, byrow = T)
[,1] [,2] [,3] [,4] [,5]
[1,] 1 2 3 4 5
[2,] 6 7 8 9 10
[3,] 11 12 13 14 15
[4,] 1 2 3 4 5
[5,] 6 7 8 9 10
- 函数cbind()和rbind()以列对列或行对行模式将向量组合成矩阵
> v1 <- 1:5
> v2 <- 5:1
> v2
[1] 5 4 3 2 1
> cbind(v1,v2)
v1 v2
[1,] 1 5
[2,] 2 4
[3,] 3 3
[4,] 4 2
[5,] 5 1
> rbind(v1,v2)
[,1] [,2] [,3] [,4] [,5]
v1 1 2 3 4 5
v2 5 4 3 2 1
- 可以使用dim()函数获取矩阵的维度。或者nrow()和ncol()返回矩阵中的行数和列数
> X <- matrix(data = 1:15, nrow = 5, ncol = 5, byrow = T)
> dim(X)
[1] 5 5
> nrow(X)
[1] 5
> ncol(X)
[1] 5
- 函数t()转置矩阵
> t(X)
[,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 1 6
[2,] 2 7 12 2 7
[3,] 3 8 13 3 8
[4,] 4 9 14 4 9
[5,] 5 10 15 5 10
- 与数据框不同，矩阵必须是数值型或字符型。
> a=matrix(2,2,2)
> a
[,1] [,2]
[1,] 2 2
[2,] 2 2
> a = rbind(a,c("A","A"))
> a
[,1] [,2]
[1,] "2" "2"
[2,] "2" "2"
[3,] "A" "A"
数组由 n 个维度组成，每个维度都是相同类型 R 对象的向量。可以如下构造一个具有一个元素的一维数组。
> x <- array(c(T,F),dim=c(1))
> print(x)
[1] TRUE
数组 x 是使用从可能值向量 c(T,F) 中提取的单个维度 (dim=c(1)) 创建的。可以使用单个维度和两个值创建类似的数组 y。
> y <- array(c(T,F),dim=c(2))
> print(y)
[1] TRUE FALSE
可以如下创建三维数组 - 3x3x3 -。
> z <- array(1:27,dim=c(3,3,3))
> dim(z)
[1] 3 3 3
> print(z)
, , 1
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
, , 2
[,1] [,2] [,3]
[1,] 10 13 16
[2,] 11 14 17
[3,] 12 15 18
, , 3
[,1] [,2] [,3]
[1,] 19 22 25
[2,] 20 23 26
[3,] 21 24 27
R 数组的访问方式类似于其他语言中的数组：通过整数索引，从 1 开始（而不是 0）。以下代码显示了如何访问 3x3x3 数组的第三个维度。第三个维度是一个 3x3 数组。
> z[,,3]
[,1] [,2] [,3]
[1,] 19 22 25
[2,] 20 23 26
[3,] 21 24 27
指定三个维度中的两个会返回一个一维数组。
> z[,3,3]
[1] 25 26 27
指定三个维度中的三个会返回 3x3x3 数组的一个元素。
> z[3,3,3]
[1] 27
可以进行更复杂的数组分区。
> z[,c(2,3),c(2,3)]
, , 1
[,1] [,2]
[1,] 13 16
[2,] 14 17
[3,] 15 18
, , 2
[,1] [,2]
[1,] 22 25
[2,] 23 26
[3,] 24 27
数组不必在所有维度上都是对称的。以下代码创建了一对 3x3 数组。
> w <- array(1:18,dim=c(3,3,2))
> print(w)
, , 1
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
, , 2
[,1] [,2] [,3]
[1,] 10 13 16
[2,] 11 14 17
[3,] 12 15 18
组成数组的向量的对象必须是相同类型，但不必是数字。
> u <- array(c(T,F),dim=c(3,3,2))
> print(u)
, , 1
[,1] [,2] [,3]
[1,] TRUE FALSE TRUE
[2,] FALSE TRUE FALSE
[3,] TRUE FALSE TRUE
, , 2
[,1] [,2] [,3]
[1,] FALSE TRUE FALSE
[2,] TRUE FALSE TRUE
[3,] FALSE TRUE FALSE
列表是 R 对象的集合。list()创建列表。unlist()将列表转换为向量。列表中的对象不必具有相同的类型或长度。
> x <- c(1:4)
> y <- FALSE
> z <- matrix(c(1:4),nrow=2,ncol=2)
> myList <- list(x,y,z)
> myList
[[1]]
[1] 1 2 3 4
[[2]]
[1] FALSE
[[3]]
[,1] [,2]
[1,] 1 2
[2,] 3 4
列表具有非常灵活的引用方法
- 按索引号
> a <- list()
> a
list()
> a[[1]] = "A"
> a
[[1]]
[1] "A"
> a[[2]]="B"
> a
[[1]]
[1] "A"
[[2]]
[1] "B"
- 按名称
> a
list()
> a$fruit = "Apple"
> a
$fruit
[1] "Apple"
> a$color = "green"
> a
$fruit
[1] "Apple"
$color
[1] "green"
- 这也可以是递归的，并且可以组合使用
> a = list()
> a[[1]] = "house"
> a$park = "green's park"
> a
[[1]]
[1] "house"
$park
[1] "green's park"
> a$park = "green's park"
> a[[1]]$address = "1 main st."
> a
[[1]]
[[1]][[1]]
[1] "house"
[[1]]$address
[1] "1 main st."
$park
[1] "green's park"
使用 R 中的作用域规则，还可以动态命名和创建列表元素
> a <- list()
> n <- 1:10
> fruit = paste("number of coconuts in bin",n)
> my.number = paste("I have",10:1,"coconuts")
> for (i in 1:10)a[fruit[i]] = my.number[i]
> a$'number of coconuts in bin 7'
[1] "I have 4 coconuts"
数据框被称为“相同长度的变量/向量的列表”。在以下示例中，创建了一个由两个向量组成的数据框，每个向量有五个元素。第一个向量 v1 由 1 到 5 的整数序列组成。第二个向量 v2 由五种类型的 T 和 F 逻辑值组成。然后创建数据框，由这些向量组成。可以使用整数下标或列名称和$符号访问数据框的列。
> v1 <- 1:5
> v2 <- c(T,T,F,F,T)
> df <- data.frame(v1,v2)
> print(df)
v1 v2
1 1 TRUE
2 2 TRUE
3 3 FALSE
4 4 FALSE
5 5 TRUE
> df[,1]
[1] 1 2 3 4 5
> df$v2
[1] TRUE TRUE FALSE FALSE TRUE
可以直接创建数据框。在以下代码中，创建数据框 - 将组成数据框的每个向量命名为参数列表的一部分。
> df <- data.frame(foo=1:5,bar=c(T,T,F,F,T))
> print(df)
foo bar
1 1 TRUE
2 2 TRUE
3 3 FALSE
4 4 FALSE
5 5 TRUE
- R 中的数据框对象（“R in Action”书籍中的示例章节）
- 数据框对象的聚合和重构（“R in Action”书籍中的示例章节）