Elements and data structure

在R中，有五种数据类型（元素）

元素 含义
numeric 数字（实数）
logical 逻辑型
character 字符型
complex 复数

元素类型转换

x <- 1
as.numeric(x)
## [1] 1
as.logical(x)
## [1] TRUE
as.character(x)
## [1] "1"
as.complex(x)
## [1] 1+0i

数据结构

向量(vector)

向量中只能包含同一类型的对象。

x <- c(1,2,3,4)#用c（）来为向量中的个元素进行赋值
x <- 1:4#用：的方式为向量添加等差数列作为向量
x <- vector(mode = "numeric" , length = 4L) #生成的是长度为4的数值型向量,元素都是0，4L代表整数4

矩阵(matrix)

矩阵就是向量+维度的属性，可以有不同类型的元素

#创建矩阵
#方案1：调用函数matrix,不输入变量标签的话是按照先列后行的顺序填充
str(matrix)
## function (data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)
m <- matrix(nrow = 2, ncol = 3)
dim(m)#查看维度
## [1] 2 3
attributes(m)#查看矩阵的属性
## $dim
## [1] 2 3
m <- matrix(1:6, nrow = 2, ncol = 3)
m
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
#方案2：用向量加维度的方法
x <- 1:4
dim(x) <- c(2,2)
x
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
#方案3：捆绑向量的方式,分为按行/按列绑定
a <-c(1,1)
b <-c(2,2)
cbind(a,b)
##      a b
## [1,] 1 2
## [2,] 1 2
rbind(a,b)
##   [,1] [,2]
## a    1    1
## b    2    2

列表(list)

列表也可以包含不同的元素。

#创建列表的方式：
x <- list(1, "a", TRUE, 1 + 4i)
x
## [[1]]
## [1] 1
## 
## [[2]]
## [1] "a"
## 
## [[3]]
## [1] TRUE
## 
## [[4]]
## [1] 1+4i
#或者也可以将列表的元素进行取名：
x <- list(a=c(1,2,3),b=3:5)
x
## $a
## [1] 1 2 3
## 
## $b
## [1] 3 4 5

因子(factor)

因子是分类的依据，分为有序因子和无序因子。因子之间可以有实质的大小关系，如用1,2,3,4表示大学的四个阶段；也可以无实质的大小关系，如用1,2表示男女。因子是一个整数向量+标签的形式，通常用于回归，如lm(),glm().

x <- factor(c("yes", "yes", "no", "yes", "no"))
x
## [1] yes yes no  yes no 
## Levels: no yes
table(x)#查看数据概貌
## x
##  no yes 
##   2   3
unclass(x)#以整数向量的方式查看（去除了标签）
## [1] 2 2 1 2 1
## attr(,"levels")
## [1] "no"  "yes"
attr(x,"levels")#查看标签
## [1] "no"  "yes"

数据帧(data frame)

  以列为单位的，可以想象成SPSS；是个元素长度相同的列表，每个元素代表一列数据，每个元素的长度代表行数，元素类型可以不同   row.names用来标注每个样本的名字   read.table() or read.csv()来创建数据框，或者用data.frame()   data.matrix() 将数据框转换为矩阵——可能会转换成同一类型的数据！！

x <- data.frame(foo = 1:4, bar = c(T, T, F, F))
x
##   foo   bar
## 1   1  TRUE
## 2   2  TRUE
## 3   3 FALSE
## 4   4 FALSE
row.names(x) <- c("a","b","c","d")
x
##   foo   bar
## a   1  TRUE
## b   2  TRUE
## c   3 FALSE
## d   4 FALSE

缺失值(Missing Values)

NA or NaN,NaN是NA的一种。

x <- c(1, 2, NA, 10, 3)
is.na(x)#返回是否是NA的逻辑值
## [1] FALSE FALSE  TRUE FALSE FALSE
is.nan(x)#返回是否是NaN的逻辑值
## [1] FALSE FALSE FALSE FALSE FALSE
x <- c(1, 2, NaN, NA, 4)
is.na(x)
## [1] FALSE FALSE  TRUE  TRUE FALSE
is.nan(x)
## [1] FALSE FALSE  TRUE FALSE FALSE

read and write data

Reading Data

#行列的格式存储到R中的Frame，**文件名要加双引号**
str(read.table)
## function (file, header = FALSE, sep = "", quote = "\"'", dec = ".", 
##     numerals = c("allow.loss", "warn.loss", "no.loss"), row.names, 
##     col.names, as.is = !stringsAsFactors, na.strings = "NA", colClasses = NA, 
##     nrows = -1, skip = 0, check.names = TRUE, fill = !blank.lines.skip, 
##     strip.white = FALSE, blank.lines.skip = TRUE, comment.char = "#", 
##     allowEscapes = FALSE, flush = FALSE, stringsAsFactors = default.stringsAsFactors(), 
##     fileEncoding = "", encoding = "unknown", text, skipNul = FALSE)
str(read.csv)
## function (file, header = TRUE, sep = ",", quote = "\"", dec = ".", 
##     fill = TRUE, comment.char = "", ...)
str(readLines)#用于读取文本，在R中返回一个String
## function (con = stdin(), n = -1L, ok = TRUE, warn = TRUE, encoding = "unknown", 
##     skipNul = FALSE)
str(source)#读取Rcode的函数
## function (file, local = FALSE, echo = verbose, print.eval = echo, 
##     exprs, spaced = use_file, verbose = getOption("verbose"), prompt.echo = getOption("prompt"), 
##     max.deparse.length = 150, width.cutoff = 60L, deparseCtrl = "showAttributes", 
##     chdir = FALSE, encoding = getOption("encoding"), continue.echo = getOption("continue"), 
##     skip.echo = 0, keep.source = getOption("keep.source"))
str(dget)#读取Rcode,不同的是读取的是逆句法分析过后以文本文件储存的R对象
## function (file, keep.source = FALSE)
str(load)
## function (file, envir = parent.frame(), verbose = FALSE)
str(unserialize)#二进制对象读入R
## function (connection, refhook = NULL)

dput() and dump()

-dput(): 读取文本的数据 1. 可编辑的(不是很推荐) 2. 长期储存,避免损坏 3. 空间利用率不高,占内存 用dput进行存储，dget来读取写入的R文件,多用于数据的重建

-dump(): 与dput()用法类似，但是可以进行多数据的重建

Write Data

    write.table()
    writeLines()
    dump()
    dput()
    save()
    serialize()

Tips for large data

    read.table（默认的分隔符是" "）
    read.csv（默认的分隔符是","）

read.table:

参数 含义
file 文件的名字，路径
header 逻辑值，表明文件中第一行是否是表头
sep 分隔符，数据的分隔符（“,” or “:” or " “)
colClass 非必要的，数据类型。
nRows 读入的行数
comment.char 表示注释符，通常是#。设置为空（如果没有注释）
skip 跳过前几行再读取
stringAsFactor 字符变量是否转换成因子（默认true，可以改成false） 
    colClass:告诉R每列的数据类型，可以节省读取时间和内存
    initial <- read.table("database.txt" , nrows = 100)
    classes <- sallpy(initial, class)
    tabAll <- read.table("database.txt" , colClasses = classes)
    这时候tabAll就可以用来对大数据进行指定类型，从而减少内存的占用
    nrows: 估计大致的读取行数可以帮助计算大致的内容，从而减少内存的占用，可以略多估计一点
    Calculating Memory Requirements
    rows * columns * 8(bytes/numeric) / 220 (bytes/MB)
    系统运行需要的内存，是上述计算的两倍

Subsetting

取子集的符号

符号 用法
[ 返回的对象和原来的相同：向量的子集还是向量;可以在对象中选择超过一个元素
[[ 提取list 或data.frame的元素;只能提取单个元素;返回的对象类型不一定是list 或data.frame
$ 有名字的对象

Subsetting List

x <- list(foo = 1:4, bar = 0.6)
#1. 只有单方括号的返回是列表，双方括号和$的返回数据类型是一样的。
x[1]
## $foo
## [1] 1 2 3 4
x[[1]]
## [1] 1 2 3 4
x$bar
## [1] 0.6
x[["bar"]]
## [1] 0.6
x["bar"]
## $bar
## [1] 0.6
#2. 利用单方括号和向量c()来获取多个元素
x <- list(foo = 1:4, bar = 0.6, baz = "hello")
x[c(1, 3)]
## $foo
## [1] 1 2 3 4
## 
## $baz
## [1] "hello"
#3. 使用需要计算的索引只有双方括号可以做到，$或者单方括号都不可以
x <- list(foo = 1:4, bar = 0.6, baz = "hello")
name <- "foo"
x[[name]]
## [1] 1 2 3 4
#4. 在list里有多种类型的元素情况下，用双方括号。与第3点比，双方括号里的c(1,3)表示第一个元素的第三个元素；单方括号里的c(1,3)表示了第一个元素和第三个元素。
x <- list(a = list(10, 12, 14), b = c(3.14, 2.81))
x[[c(1, 3)]]
## [1] 14
x[[1]][[3]]
## [1] 14

Subsetting Matrix

x <- matrix(1:6, 2, 3)
x[1, 2]
## [1] 3
x[1, 2, drop = FALSE]#利用drop，使得返回是一个矩阵，而非向量
##      [,1]
## [1,]    3
x[1, ]
## [1] 1 3 5

Partial Matching(模糊匹配)

通常与双括号，单括号和$一起使用，对于变量名称很长，且前缀唯一的情况。

x <- list(aardvark = 1:5)
x$a
## [1] 1 2 3 4 5
x[["a", exact = FALSE]]
## [1] 1 2 3 4 5

Removing Missing Values

x <- c(1, 2, NA, 4, NA, 5)
#is.na()函数用来返回一个逻辑向量
bad <- is.na(x)
x[!bad]
## [1] 1 2 4 5
#complete.cases()用来返回一个或者多个数据是否是缺失值
x <- c(1, 2, NA, 4, NA, 5)
y <- c("a", "b", NA, "d", NA, "f")
complete.cases(x, y)
## [1]  TRUE  TRUE FALSE  TRUE FALSE  TRUE
#complete.cases()的另一个妙用在于剔除含有缺失值的行
x <- c(1,2,3,4,NA,6,7,8,9,10,NA,12)
dim(x) <- c(4,3)
x[complete.cases(x[,3]),]#过滤第三列中有缺失值的数据
##      [,1] [,2] [,3]
## [1,]    1   NA    9
## [2,]    2    6   10
## [3,]    4    8   12
x[complete.cases(x),]#过滤所有含有缺失值的数据
##      [,1] [,2] [,3]
## [1,]    2    6   10
## [2,]    4    8   12
na.omit(x)#过滤所有含有确实值的数据，但是有其他的内容混杂
##      [,1] [,2] [,3]
## [1,]    2    6   10
## [2,]    4    8   12
## attr(,"na.action")
## [1] 1 3
## attr(,"class")
## [1] "omit"

Vectorized Operations(R语言的向量化运算)

R语言的向量化运算易于相加和做逻辑判断（向量具有可加性，而其他语言需要遍历），可以直接一一对应做计算（数量和逻辑）

x <- matrix(1:4, 2, 2)
y <- matrix(rep(10, 4), 2, 2)
x+y#对应元素一一相加
##      [,1] [,2]
## [1,]   11   13
## [2,]   12   14
x>2#对应元素一一判断
##       [,1] [,2]
## [1,] FALSE TRUE
## [2,] FALSE TRUE
x*y#对应元素一一相乘
##      [,1] [,2]
## [1,]   10   30
## [2,]   20   40
x/y#对应元素一一相除
##      [,1] [,2]
## [1,]  0.1  0.3
## [2,]  0.2  0.4
x %*% y#矩阵乘法运算
##      [,1] [,2]
## [1,]   40   40
## [2,]   60   60