第四章 数据类型
由数据构成的一个矩形数组称为数据集，行称为观测，列称为变量
查看R中所有内置的数据集
data(package = .packages(all.available = TRUE))
查看指定包中的数据集
data(package =“package name”)
查看某个数据集的信息
Help函数 or ?
4.1向量
向量是数值的有序集，它在统计学中极其重要，因为通常的分析对象是整个数据集， 而不仅是一条数据
在 R 中，向量化有几种含义，其中最常见的含义是：运算符或函数能作用于向量中的每个元 素，而无需显式地编写循环语句（这种内置的基于元素的隐式循环也远远快于显式地写循环 语句） 。
向量化的第二个含义是：当一个函数把一个向量作为输入时，能计算汇总统计。
向量化的第三种含义不太常见，即参数的向量化运算符或函数能作用于向量的每个元素；当一个函数把一个向量作为输入时，能计算汇总统计：min(1:5) sd(1:5) c(1,2,3)*2
向量的创建：
用：运算符创建从某个数到另一个数的序列
c函数把一系列值拼接起来创建向量/选择向量。c可以创建括号里面的元素，也可以连接括号里面的元素
vector 函数能创建一个指定类型和长度的矢量。其结果中的值可为零、FALSE、空字符串，或任何相当于“什么都没有”（nothing）的类型
访问向量元素：
指定元素位置
如果x[n]中的n为正数，则取第n个数，如果x[n]中的n为负数，则取第n个数之外的所有元素
使用逻辑向量访问
通过名字访问
修改向量元素:
删除向量元素:
> a <- 1:5
> is.vector(a)
[1] TRUE
> c <- c(1, 2, 3)
> is.vector(c)
> vector("numeric", 5) #等价于numeric(5)
[1] 0 0 0 0 0
> vector("complex", 5) #等价于complex(5)
[1] 0+0i 0+0i 0+0i 0+0i 0+0i
> vector("logical", 5) #等价于logical(5)
[1] FALSE FALSE FALSE FALSE FALSE
> vector("character", 5) #等价于character(5)
[1] "" "" "" "" ""
> vector("list", 5)
[[1]]
NULL
[[2]]
NULL
[[3]]
NULL
[[4]]
NULL
[[5]]
NULL
4.1.1序列
创建序列：
用：运算符创建从某个数到另一个数的序列
seq.int也 可创建一个序列，序列的范围由两个数字指定。只需两个参数，原理与冒号运算符完全相同。但seq.int 稍微比 : 更通用些，因为它可以指定步长。
seq_len 函数将创建一个从 1 到它的输入值的序列，但当输入值为零时，该函数非常有用：
seq_along 创建一个从 1 开始、长度为其输入值的序列
> a <- 1:5
> a
[1] 1 2 3 4 5
> b <- seq.int(1,5)
> b
[1] 1 2 3 4 5
> c <- seq.int(1,5,2)
> c
[1] 1 3 5
> d <- seq.int(0.1, 0.01, -0.01)
> d
[1] 0.10 0.09 0.08 0.07 0.06 0.05 0.04 0.03 0.02 0.01
> n <- 0
> 1:n
[1] 1 0
> seq_len(n)
integer(0)
e <- letters[1:21] #创建索引限制的小写值，LETTERS创建索引限制的大写值
for(i in seq_along(e)){
print(e[i])
}
4.1.2 长度
所有的向量都有一个长度，它告诉我 们向量包含多少个元素。向量的长度可以为零。
可以通过 length 函数查到这个值。缺失值也会被计入长度：
> length(1:5)
[1] 5
可以为向量重新分配一个长度，如果向量的长度缩短，那么后面的值将会被删除；而如果长度增加，则缺失值会添加到最后：
> poincare <- c(1, 0, 0, 0, 2, 0, 2, 0)
> length(poincare) <- 3
> poincare
[1] 1 0 0
> length(poincare) <- 8
> poincare
[1] 1 0 0 NA NA NA NA NA
4.1.3命名
可以用 name = value 的形式在创建向量时为其指定名称。
> f <- c(apple = 1, banana = 2, "kiwi fruit" = 3, 4)
> f
apple banana kiwi fruit
1 2 3 4
也可以在向量创建后用 names 函数为元素添加名字。
> x <- 1:4
> names(x) <- c("apple", "bananas", "kiwi fruit", "")
> x
apple bananas kiwi fruit
1 2 3 4
name 函数也可用于取得向量的名称，如果向量中没有一个元素有名字，则 names 函数返回 NULL。
> names(x)
[1] "apple" "bananas" "kiwi fruit" ""
> names(1:4)
NULL
4.1.4 索引向量
通常，我们只要访问向量中的部分或个别元素。这就是所谓的索引，它用方括号 [] 来实现。（有人也称之为子集、下标或切片），R提供如下多种索引方法。
- 给向量传入正数，它会返回此位置上的向量元素切片。它的第一个位置是 1 。
- 给向量传入负数，它会返回一个向量切片，它将包含除了这些位置以外的所有元素。
- 给向量传入一个逻辑向量，它会返回一个向量切片，里面只包含索引为TRUE 的元素。 对于已命名的向量，给向量传入命名的字符向量，将会返回向量中包含这些名字的元素切片。
> x <- 1:5
> x[c(1, 3, 5)]
[1] 1 3 5
> x[c(-2, -4)]
[1] 1 3 5
> x[c(TRUE, FALSE, TRUE, FALSE, TRUE)]
[1] 1 3 5
如果给每个元素命名，以下方法也将返回相同的值：
> names(x) <- c("one", "four", "nine", "sixteen", "twenty five")
> x[c("one", "nine", "twenty five")]
one nine twenty five
1 3 5
注意：
-
混合使用正负值是不允许的，会抛出一个错误
-
如果你使用正数或逻辑值作为下标，那么缺失索引所对应的值同样也是缺失值
-
对于负的下标值来说，不允许存在缺失值，会产生错误
-
超出范围的下标值（即超出了矢量的长度）不会导致错误，而是返回缺失值 NA
-
非整数下标会默认向零舍入。
-
不传递任何下标值将返回整个向量
which 函数将返回逻辑向量中为 TRUE 的位置。如果要将逻辑索引切换到整数索引中
> which(x > 3)
sixteen twenty five
4 5
> which.min(x)
one
1
>
> which.max(x)
twenty five
5
4.1.5向量循环与重复
把一个单独的数字与向量相加，则向量的每个元素都会与该数字相加：
> 1:5 +1
[1] 2 3 4 5 6
将两个向量相加时，R 将会循环较短向量中的元素以加较长的那个
> 1:5 + 1:15
[1] 2 4 6 8 10 7 9 11 13 15 12 14 16 18 20
> 1:5 + 1:7
[1] 2 4 6 8 10 7 9
Warning message:
In 1:5 + 1:7 : 长的对象长度不是短的对象长度的整倍数
rep函数允许我们重复使用元素来创建矢量
> rep(1:5, 3)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
> rep(1:5, each = 3)
[1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5
> rep(1:5, times = 1:5)
[1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
> rep(1:5, length.out = 7)
[1] 1 2 3 4 5 1 2
> rep.int(1:5, 3) # 与 rep(1:5, 3) 一样
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
>
> rep_len(1:5, 13)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3
4.1.6向量化函数
- 舍入：
ceiling,floor,round,signif,trunc,zapsmall - 符号函数
sign - 绝对值
abs - 平方根
sqrt - 对数与指数函数
log,exp,log10,log2 - 三角函数
sin,cos,tan - 反三角函数
asin,acos,atan,atan2 - 双曲函数
sinh,cosh,tanh - 反双曲函数
asinh,acosh,atanh - 贝塔函数
beta,lbeta - 伽玛函数
gamma,lgamma,digamma,trigamma,tetragamma,pentagamma - 组合数
choose,lchoose - 富利叶变换和卷积
fft,mvfft,convolve - 正交多项式
poly - 求根
polyroot,uniroot - 最优化
optimize,optim - Bessel函数
besselI,besselK,besselJ,besselY - 样条插值
spline,splinefun - 简单的微分
deriv
4.2 矩阵和数组
4.2.1创建数组和矩阵
使用array()函数创建数组
> three_d_array <- array(
1:24,
dim = c(4, 3, 2),
dimnames = list(
c("one","two","three","four"),
c("ein","zwei","drei"),
c("un","deux")
)
)
> three_d_array
, , un
ein zwei drei
one 1 5 9
two 2 6 10
three 3 7 11
four 4 8 12
, , deux
ein zwei drei
one 13 17 21
two 14 18 22
three 15 19 23
four 16 20 24
使用matrix()创建矩阵
> a_matrix <- matrix(
1:12,
nrow = 4, #ncol = 3 也是同样的效果
dimnames = list(
c("one","two","three","four"), c("ein","zwei","drei")
)
)
> a_matrix
ein zwei drei
one 1 5 9
two 2 6 10
three 3 7 11
four 4 8 12
该矩阵也可以用 array 函数来创建。
> two_d_array <- array(
1:12,
dim = c(4, 3),
dimnames = list(
c("one", "two", "three", "four"),
c("ein", "zwei", "drei")
))
> two_d_array
ein zwei drei
one 1 5 9
two 2 6 10
three 3 7 11
four 4 8 12
创建矩阵时，传入的值会按列填充矩阵。也可指定参数 byrow = TRUE 来按行填充矩阵：
> matrix(
1:12,
nrow = 4,
byrow = TRUE,
dimnames = list(
c("one", "two", "three", "four"),
c("ein", "zwei", "drei")
) )
ein zwei drei
one 1 2 3
two 4 5 6
three 7 8 9
four 10 11 12
4.2.2行、列和维度
对于矩阵和数组，dim 函数将返回其维度的整数值向量：
> dim(three_d_array)
[1] 4 3 2
对于矩阵，函数 nrow 和 ncol 将分别返回行数和列数；nrow 和 ncol 也能用于数组，分别返回第一和第二个维度。但对于更高维度的对象，通常 最好使用 dim 函数
> nrow(a_matrix)
[1] 4
> nrow(three_d_array)
[1] 4
> ncol(a_matrix)
[1] 3
> ncol(three_d_array)
[1] 3
length 函数也能用于矩阵和数组。在这种情况下，它将返回所有维度的乘积：
> length(three_d_array)
[1] 24
> length(a_matrix)
[1] 12
还可通过给 dim 函数分配一个新的维度来重塑矩阵或数组。
> dim(a_matrix) <- c(6, 2)
> a_matrix
[,1] [,2]
[1,] 1 7
[2,] 2 8
[3,] 3 9
[4,] 4 10
[5,] 5 11
[6,] 6 12
把 nrow、ncol 和 dim 用于向量时将返回 NULL 值。与 nrow 和 ncol 相对的函数是 NROW 和 NCOL，它们把向量看做具有单个列的矩阵（也即数学意义上的列向量）：
> identical(nrow(a_matrix), NROW(a_matrix))
[1] TRUE
> identical(ncol(a_matrix), NCOL(a_matrix))
[1] TRUE
> recaman <- c(0, 1, 3, 6, 2, 7, 13, 20)
> nrow(recaman)
NULL
> NROW(recaman)
[1] 8
> ncol(recaman)
NULL
> NCOL(recaman)
[1] 1
> dim(recaman)
NULL
4.2.3行名、列名和维度名
矩阵的行和列有行名 rownames 和列名 colnames。出于历史的原因，还有一个 row.names 函数，它的作用与 rownames 函数相同。
> rownames(a_matrix)
[1] "one" "two" "three" "four"
> colnames(a_matrix)
[1] "ein" "zwei" "drei"
> dimnames(a_matrix)
[[1]]
[1] "one" "two" "three" "four"
[[2]]
[1] "ein" "zwei" "drei"
4.2.4索引数组
索引数组用方括号来表示索引，且仍有四种指定索引的方法（正整数、负整数、逻辑值和元素的名称）。在不同的维度上用不同的方式指定索引下标完全没问题。每个维度的下标用逗号分隔,如果省略某个下标位置，则表示选取该下标的全部元素：
> a_matrix[1, c("zwei", "drei")] # 在第一行、第二列和第三列的两个元素
zwei drei
5 9
4.2.5合并矩阵
> a_matrix <- matrix(
1:12,
nrow = 4,
dimnames = list(
c("one", "two", "three", "four"),
c("ein", "zwei", "drei")
) )
> another_matrix <- matrix(
seq.int(2, 24, 2),
nrow = 4,dimnames = list(
c("five", "six", "seven", "eight"), c("vier", "funf", "sechs")
) )
> c(a_matrix, another_matrix)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8
[17] 10 12 14 16 18 20 22 24
通过使用 cbind 和 rbind 函数按行和列来绑定两个矩阵，能更自然地合并它们：
> cbind(a_matrix, another_matrix)
ein zwei drei vier funf sechs
one 1 5 9 2 10 18
two 2 6 10 4 12 20
three 3 7 11 6 14 22
four 4 8 12 8 16 24
> rbind(a_matrix, another_matrix)
ein zwei drei
one 1 5 9
two 2 6 10
three 3 7 11
four 4 8 12
five 2 10 18
six 4 12 20
seven 6 14 22
eight 8 16 24
4.2.6数组算术
和向量中的运算一样，标准算术运算符（+、-、*、/）将以同样的方式按元素来处理矩阵和数组;
注：当对两个数组执行算术运算时，须确保它们的大小适当（以线性代数的术语来说，它们必 须是“一致的”）。两个数组在相加时大小必须相等，而矩阵相乘时第一个矩阵的行数必须和第二矩阵的列数相等.
> a_matrix + another_matrix
ein zwei drei
one 3 15 27
two 6 18 30
three 9 21 33
four 12 24 36
t 函数用于转置矩阵，但不能转置更高维的数组
> t(a_matrix)
one two three four
ein 1 2 3 4
zwei 5 6 7 8
drei 9 10 11 12
对于矩阵内乘和外乘运算，我们有特殊运算符 %*% 和 %o%。
> a_matrix %*% t(a_matrix)
one two three four
one 107 122 137 152
two 122 140 158 176
three 137 158 179 200
four 152 176 200 224
> 1:3 %o% 4:6
[,1] [,2] [,3]
[1,] 4 5 6
[2,] 8 10 12
[3,] 12 15 18
幂运算符 ^ 作用于矩阵中的每个元素，所以在为矩阵求反时不能简单地为矩阵使用负一次方运算，而应使用 solve 函数 ：
> m <- matrix(c(1, 0, 1, 5, -3, 1, 2, 4, 7), nrow = 3)
> m ^ -1
[,1] [,2] [,3]
[1,] 1 0.2000000 0.5000000
[2,] Inf -0.3333333 0.2500000
[3,] 1 1.0000000 0.1428571
> (inverse_of_m <- solve(m))
[,1] [,2] [,3]
[1,] -25 -33 26
[2,] 4 5 -4
[3,] 3 4 -3
> m %*% inverse_of_m
[,1] [,2] [,3]
[1,] 1 0 0
[2,] 0 1 0
[3,] 0 0 1
solve(): 从方程a%*%x = b中求x。若不指定b， 则求a的逆矩阵
4.3 列表
列表是一个向量，其中每个元素的类型可以不同。
4.3.1创建列表
列表由 list 函数创建，且能像 c 函数那样指定内容。你只需简单地用逗号分隔每个参数即 可指定列表中的内容。列表中的元素变量的类型不限 , 可以是向量、矩阵，甚至函数：
> (a_list <- list( c(1, 1, 2, 5, 14, 42), month.abb, matrix(c(3, -8, 1, -3), nrow = 2), asin ))
[[1]]
[1] 1 1 2 5 14 42
[[2]]
[1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug"
[9] "Sep" "Oct" "Nov" "Dec"
[[3]]
[,1] [,2]
[1,] 3 1
[2,] -8 -3
[[4]]
function (x) .Primitive("asin")
与向量的命名类似，可以在构造列表时就给元素命名，或在构造之后使用 names 函数命名：
> names(a_list) <- c("catalan", "months", "involutary", "arcsin")
> a_list
$catalan
[1] 1 1 2 5 14 42
$months
[1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug"
[9] "Sep" "Oct" "Nov" "Dec"
$involutary
[,1] [,2]
[1,] 3 1
[2,] -8 -3
$arcsin
function (x) .Primitive("asin")
4.3.2原子变量和递归变量
由于列表具有这种把其他列表包含在内的能力，它被认为是递归变量。与之相对，向量、 矩阵和数组则是原子变量（变量或是递归的，或是原子的，从不两者兼具。 函数is.recursive 和 is.atomic 可测试它们的类型：
is.atomic(list())
[1] FALSE
is.recursive(list())
[1] TRUE
矢量、原子、递归或语言对象的变量类型
| 数据类型 | is.vector | is.atomic | is.recursive | is.language |
|---|---|---|---|---|
| Logical | TRUE | TRUE | FALSE | FALSE |
| Integer | TRUE | TRUE | FALSE | FALSE |
| Floating Point | TRUE | TRUE | FALSE | FALSE |
| Complex | TRUE | TRUE | FALSE | FALSE |
| String | TRUE | TRUE | FALSE | FALSE |
| Raw Byte | TRUE | TRUE | FALSE | FALSE |
| Categorical | FALSE | TRUE | FALSE | FALSE |
| Null | FALSE | TRUE | FALSE | FALSE |
| Logical Matrix | FALSE | TRUE | FALSE | FALSE |
| Numeric Matrix | FALSE | TRUE | FALSE | FALSE |
| Character Matrix | FALSE | TRUE | FALSE | FALSE |
| Logical Array | FALSE | TRUE | FALSE | FALSE |
| Numeric Array | FALSE | TRUE | FALSE | FALSE |
| Character Array | FALSE | TRUE | FALSE | FALSE |
| List | TRUE | FALSE | TRUE | FALSE |
| Data Frame | FALSE | FALSE | TRUE | FALSE |
| Function | FALSE | FALSE | TRUE | FALSE |
| Environment | FALSE | FALSE | TRUE | FALSE |
| Expression | TRUE | FALSE | TRUE | TRUE |
| Call | FALSE | FALSE | TRUE | TRUE |
| Formula | FALSE | FALSE | TRUE | TRUE |
4.3.3列表维度和算术运算
列表与向量一样也有长度，其长度是它顶层元素的数目；但是没有维度，因此把dim函数作用于列表上会返回NULL：
> length(a_list)
[1] 4
> dim(a_list)
NULL
nrow、NROW 及相应的列函数作用于列表时，与作用于矢量上的原理基本相同：
> nrow(a_list)
NULL
> ncol(a_list)
NULL
> NROW(a_list)
[1] 4
> NCOL(a_list)
[1] 1
与向量不同的是，算术运算对列表不起作用。由于每个元素的类型可以不同，将两个列表相加或相乘没有任何意义。然而，如果两个列表中的元素类型相同，则可对它们进行算术 运算。在这种情况下，一般的算术运算法都适用。
> l1 <- list(1:5)
> l2 <- list(6:10)
> l1[[1]] + l2[[1]]
[1] 7 9 11 13 15
4.3.4索引列表
与向量类似，我们可通过方括号 []、正或负的下标数字、元素名称或逻辑索引这四种方法 访问列表中的元素。
> l <- list(first = 1, second = 2, third = list(alpha = 3.1, beta = 3.2))
> l[1:2]
$first
[1] 1
$second
[1] 2
> l[-3]
$first
[1] 1
$second
[1] 2
> l[c("first", "second")]
$first
[1] 1
$second
[1] 2
> l[c(TRUE, TRUE, FALSE)]
$first
[1] 1
$second
[1] 2
这些索引操作的结果催生了另一个列表。有时，我们要访问的是列表元素中的内容。有两个操作符能帮助我们做到这一点：
可给双方括号 [[ ]] 传入正整数，它代表返回的索引下 标，或指定该元素的名称字符串：
> l[[1]]
[1] 1
> l[["first"]]
[1] 1
如果输入的是一个列表，is.list 函数将返回 TRUE，否则将返回 FALSE。
> is.list(l[1])
[1] TRUE
> is.list(l[[1]])
[1] FALSE
对于列表中的命名元素，我们也可以使用美元符号运算符 $。
> l$first
[1] 1
如果我们使用单方括号的索引，那么将返回只带一个 NULL 元素的列表（且名称为 NA，如 原列表有名字的话）。与之相比，对于一个无效的向量索引，其返回值将是 NA：
> l[c(4,2,5)]
$<NA>
NULL
$second
[1] 2
$<NA>
NULL
> l[c("fourth", "second", "fifth")]
$<NA>
NULL
$second
[1] 2
$<NA>
NULL
无论是以双方括号还是美元符号来访问元素的内容，如果名字错误，都将返回 NULL
4.3.5向量和列表间的转换
向量可使用函数 as.list 函数来转换成列表。所创建的可见列表与向量中元素的值一一对应：
> busy_beaver <- c(1, 6, 21, 107)
> as.list(busy_beaver)
[[1]]
[1] 1
[[2]]
[1] 6
[[3]]
[1] 21
[[4]]
[1] 107
如果列表中每个元素都是标量值，则亦可使用之前出现过的函数（as.numeric、as.character 等）将其转换成向量：
> as.numeric(list(1, 6, 21, 107))
[1] 1 6 21 107
可用 unlist 函数将列表转换为向量
> (prime_factor <- list(two=2,three=3,four=c(2,2),five=5,six=c(2,3),seven=7,eight=c(2,2,2),nine=c(3,3),ten=c(2,5)))
$two
[1] 2
$three
[1] 3
$four
[1] 2 2
$five
[1] 5
$six
[1] 2 3
$seven
[1] 7
$eight
[1] 2 2 2
$nine
[1] 3 3
$ten
[1] 2 5
> unlist(prime_factor)
two three four1 four2 five six1 six2
2 3 2 2 5 2 3
seven eight1 eight2 eight3 nine1 nine2 ten1
7 2 2 2 3 3 2
ten2
5
4.3.6组合列表
c 函数既能用于拼接向量，亦能用于拼接列表：
> c(list(a = 1, b = 2), list(3))
$a
[1] 1
$b
[1] 2
[[3]]
[1] 3
4.3.7NULL
NULL 是个特殊值，它表示一个空的变量。在创建列表时，你可能会想指定一个元素，表明它必须存在但没有赋值。
> (uk_bank_holidays_2013 <- list(
Jan = "New Year's Day",
Feb = NULL,
Mar = "Good Friday",
Apr = "Easter Monday",
May = c("Early May Bank Holiday",
"Spring Bank Holiday"),
Jun = NULL,
Jul = NULL,
Aug = "Summer Bank Holiday",
Sep = NULL,
Oct = NULL,
Nov = NULL,
Dec = c("Christmas Day", "Boxing Day")
))
$Jan
[1] "New Year's Day"
$Feb
NULL
$Mar
[1] "Good Friday"
$Apr
[1] "Easter Monday"
$May
[1] "Early May Bank Holiday" "Spring Bank Holiday"
$Jun
NULL
$Jul
NULL
$Aug
[1] "Summer Bank Holiday"
$Sep
NULL
$Oct
NULL
$Nov
NULL
$Dec
[1] "Christmas Day" "Boxing Day"
，NA 是一个标量值，而 NULL 不会占用任何空间——它的长度为零：
> length(NULL)
[1] 0
> length(NA)
[1] 1
可以使用函数 is.null 测试变量是否为 NULL 值。缺失值不是 NULL：
> is.null(NULL)
[1] TRUE
> is.null(NA)
[1] FALSE
4.3.8成对列表
R 有另外一种形式的列表：成对列表（Pairlists） 。成对列表只在内部使用，用于将参数传 递到函数中
> (arguments_of_sd <- formals(sd))
$x
$na.rm
[1] FALSE
> class(arguments_of_sd)
[1] "pairlist"
在实际使用中，成对列表与列表几乎一样。唯一的区别是，长度为零的成对列表为 NULL， 而长度为零的列表是一个空列表：
> pairlist()
NULL
> list()
list()
4.4数据框
数据框用于存储类似电子表格的数据。它们既可被看作是每列可存储不同数据类型的矩 阵，或是非嵌套的列表，其中每个元素具有相同的长度。
4.4.1创建数据框
用 data.frame 函数创建数据框：
> (a_data_frame <- data.frame(
x = letters[1:5],
y = rnorm(5),
z = runif(5) > 0.5
))
x y z
1 a 0.05229781 TRUE
2 b -1.28936847 FALSE
3 c -0.19655250 TRUE
4 d 0.74395375 FALSE
5 e -0.39965810 TRUE
注：每列的类型可与其他列不同，但在同一列中的元素类型必须相同。还要注意的 是，对象的类名是 data.frame，中间有一个点，而非空字符。
str(): 查看数据框结构
如果输入的任何向量有名称，那么行名称就取自第一个向量名称。
> y <- rnorm(5)
> names(y) <- month.name[1:5]
> data.frame( x = letters[1:5], y = y, z = runif(5) > 0.5 )
x y z
January a 0.8580037 FALSE
February b -0.7483595 TRUE
March c 0.5845473 TRUE
April d -0.7912231 FALSE
May e -0.9649648 FALSE
还可以通过给 row.names 传入一个向量来为每行命名。这个向量将被转换为字符 character
> y <- rnorm(5)
> data.frame( x = letters[1:5], y = y, z = runif(5) > 0.5, row.names = c("Jackie", "Tito", "Jermaine", "Marlon", "Michael") )
x y z
Jackie a -0.7651689 TRUE
Tito b 0.2035682 TRUE
Jermaine c 0.7577606 TRUE
Marlon d -1.1436287 FALSE
Michael e 0.3948775 FALSE
像矩阵一样行的名称可通过使用 rownames（或row.names）在后期进行检索或更改。同样 地，也可以使用 colnames 和 dimnames 来分别获取或置列和维度的名称。事实上，几乎所 有用于矩阵的函数亦可用在数据框上。
> rownames(a_data_frame)
[1] "1" "2" "3" "4" "5"
> colnames(a_data_frame)
[1] "x" "y" "z"
> dimnames(a_data_frame)
[[1]]
[1] "1" "2" "3" "4" "5"
[[2]]
[1] "x" "y" "z"
> nrow(a_data_frame)
[1] 5
> ncol(a_data_frame)
[1] 3
> dim(a_data_frame)
[1] 5 3
注：length 将返回与 ncol 相同的值，而不是数据框元素的总数。 同样地，names 将返回与 colnames 相同的值。为了使代码易于理解，建议你避开这两个函 数，而使用 ncol 和 colnames：
可以使用不同长度的向量来创建数据框，只要长度较短的向量能刚好循环至总长度。从技术上讲，所有向量长度的最小公倍数必须与最长向量的长度相等：
> data.frame(x=1,y=2:3,z=4:7)
x y z
1 1 2 4
2 1 3 5
3 1 2 6
4 1 3 7
创建数据框时的另一个要点为：在默认情况下，列名必须是唯一且有效的变量名称。此功能可通过给 data.frame 传入 check.names = FALSE 来关闭
> data.frame(
"a" = letters[1:5],
"b" = rnorm(5),
"c" = runif(5) > 0.5,
check.names = FALSE
)
a b c
1 a 2.38374671 FALSE
2 b -1.35297300 FALSE
3 c 0.09948782 FALSE
4 d -1.11156918 FALSE
5 e 0.43652844 FALSE
4.4.2索引数据框
有很多种不同的方式可用于索引数据框。首先，与矩阵索引的方式一样，可使用四种不同 的向量索引（正整数、负整数、逻辑值和字符）。
> a_data_frame[2:3, -3]
x y
2 b -1.2893685
3 c -0.1965525
> a_data_frame[c(FALSE, TRUE, TRUE, FALSE, FALSE), c("x", "y")]
x y
2 b -1.2893685
3 c -0.1965525
也可以使用列表样式的索引（带有正整数或名称的双方括号，或者带有名称的美元符号运算符）。
> a_data_frame$x[2:3]
[1] b c
Levels: a b c d e
> a_data_frame[[1]][2:3]
[1] b c
Levels: a b c d e
> a_data_frame[["x"]][2:3]
[1] b c
Levels: a b c d e
subset 函数能要给列加上条件来得到一个数据框子集。subset 需要三个参数：一个数据框，一个行的条件逻辑向量，以及一个需要保留的名字向量（如果最后这个参数被省略了，那么将保留所有列）。
> a_data_frame[a_data_frame$y > 0 | a_data_frame$z, "x"]
[1] a c d e
Levels: a b c d e
> subset(a_data_frame, y > 0 | z, x)
x
1 a
3 c
4 d
5 e
4.4.3基本数据框操作
像矩阵一样，数据框可使用 t 函数进行转置
> t(a_data_frame)
[,1] [,2] [,3]
x "a" "b" "c"
y " 0.05229781" "-1.28936847" "-0.19655250"
z "TRUE" "FALSE" "TRUE"
[,4] [,5]
x "d" "e"
y " 0.74395375" "-0.39965810"
z "FALSE" "TRUE"
如果两个数据框的大小一致，也可使用 cbind 和 rbind 把它们连接（join）起来。rbind能智能地对列重新排序以匹配。然而，因为 cbind 不会对列名作重复性检查，使用时要格外小心，sample() 函数能够让你从数据集中（有放回或无放回地）抽取大小为 n 的一个随机样本 ：
> another_data_frame <- data.frame(
z = rlnorm(5),
y = sample(5),
x = letters[3:7]
)
> rbind(a_data_frame, another_data_frame)
x y z
1 a 0.05229781 1.0000000
2 b -1.28936847 0.0000000
3 c -0.19655250 1.0000000
4 d 0.74395375 0.0000000
5 e -0.39965810 1.0000000
6 c 4.00000000 0.3007467
7 d 5.00000000 0.9037895
8 e 3.00000000 0.8453404
9 f 1.00000000 0.8963851
10 g 2.00000000 1.1220246
> cbind(a_data_frame, another_data_frame)
x y z z y x
1 a 0.05229781 TRUE 0.3007467 4 c
2 b -1.28936847 FALSE 0.9037895 5 d
3 c -0.19655250 TRUE 0.8453404 3 e
4 d 0.74395375 FALSE 0.8963851 1 f
5 e -0.39965810 TRUE 1.1220246 2 g
当两个数据框有相同的列时，可使用 merge 函数合并。merge 为数据库风格的连接提供了 多种选择。当要连接两个数据框时，你需要指定包含键值的列以作匹配。默认情况下， merge 函数会使用两个数据框中所有共同的列，但通常你会想用一个共享 ID 列。在下例 中，我们将通过 by 参数指定 x 为我们所要包含的 ID：
> merge(a_data_frame, another_data_frame, by = "x")
x y.x z.x z.y y.y
1 c -0.1965525 TRUE 0.3007467 4
2 d 0.7439538 FALSE 0.9037895 5
3 e -0.3996581 TRUE 0.8453404 3
> merge(a_data_frame, another_data_frame, by = "x", all = TRUE)
x y.x z.x z.y y.y
1 a 0.05229781 TRUE NA NA
2 b -1.28936847 FALSE NA NA
3 c -0.19655250 TRUE 0.3007467 4
4 d 0.74395375 FALSE 0.9037895 5
5 e -0.39965810 TRUE 0.8453404 3
6 f NA NA 0.8963851 1
7 g NA NA 1.1220246 2
如果数据框中只包含数值，那么 colSums 和 colMeans 函数可分别用于计算每列的总和和平均值。
> colSums(a_data_frame[, 2:3])
y z
-1.089328 3.000000
>
> colMeans(a_data_frame[, 2:3])
y z
-0.2178655 0.6000000
attach()：将数据框添加到R的搜索路径中
detach()： 将数据框从搜索路径中移除
注：使用attach()后，变量名容易与系统中原有对象 的名字重名
标签：FALSE,函数,TRUE,frame,数据类型,第四章,data,向量 From： https://www.cnblogs.com/simpleness/p/17626111.html