R_base
ref
base
基本语法
-
只提供单行注释；tips：使用
if(FALSE){"content"}作为多行注释的样式 -
赋值：使用
<-符号 -
输出：
print(var) -
运行：
- 终端运行：终端输入
R, 启动R语言解释器 - 脚本运行：
Rscript xxx.R
if(FALSE) { "This is a demo for multi-line comments and it should be put inside either a single OR double quote" } myString <- "Hello, World!" # 赋值到字符串变量myString print ( myString) - 终端运行：终端输入
数据类型
R变量是引用，存储数据地址；R变量分配有R对象；R对象包含多种数据类型。
R称为动态类型语言,类似python
变量只是保留值的存储位置。
这意味着，当你创建一个变量，你必须在内存中保留一些空间来存储它们。
变量不会声明为某种数据类型。
变量分配有 R 对象，R 对象的数据类型变为变量的数据类型。
常用R对象：
- 矢量
- 列表
- 矩阵
- 数组
- 因子
- 数据帧
原子向量有六种数据类型：
- Logical（逻辑型）
- TRUE、FALSE
- Numeric（数字）
- 12.3，5，999
- Integer（整型）
- 2L，34L，0L
- Complex（复合型、复数）
- 3+2i
- Character（字符）
- ‘a’，“good”，“True”，“23.4”
- Raw(原型)
- “Hello” 被存储为 48 65 6c 6c 6f
输出数据类型：print(class(var))
v <- charToRaw("Hello")
print(class(v))
# [1] "raw"
-
Vectors 向量:使用 c() 函数
-
可以是不同类型混合
- 向量c（TRUE，1）具有逻辑和数值类的混合。 因此，逻辑类强制转换为数字类，使TRUE为1
-
apple <- c('red','green',"yellow") # Get the class of the vector. print(class(apple)) -
[1] "red" "green" "yellow" [1] "character"
-
-
Lists 列表:包含许多不同类型的元素
-
# Create a list. list1 <- list(c(2,5,3),21.3,sin) # Print the list. print(list1) -
[[1]] [1] 2 5 3 [[2]] [1] 21.3 [[3]] function (x) .Primitive("sin")
-
-
Matrices 矩阵:二维矩形数据集
-
# Create a matrix. M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE) print(M) -
[,1] [,2] [,3] [1,] "a" "a" "b" [2,] "c" "b" "a"
-
-
Arrays 数组：具有任何数量的维度
-
# Create an array. a <- array(c('green','yellow'),dim = c(3,3,2)) print(a) -
, , 1 [,1] [,2] [,3] [1,] "green" "yellow" "green" [2,] "yellow" "green" "yellow" [3,] "green" "yellow" "green" , , 2 [,1] [,2] [,3] [1,] "yellow" "green" "yellow" [2,] "green" "yellow" "green" [3,] "yellow" "green" "yellow"
-
-
Factors 因子：将向量与向量中元素的不同值一起存储为标签，类似set
-
步骤：声明一个向量，在使用
factor()函数 -
# Create a vector. apple_colors <- c('green','green','yellow','red','red','red','green') # Create a factor object. factor_apple <- factor(apple_colors) # Print the factor. print(factor_apple) print(nlevels(factor_apple)) -
[1] green green yellow red red red green Levels: green red yellow # applying the nlevels function we can know the number of distinct values [1] 3
-
-
Data Frames 数据帧：表格数据对象。按列声明，每列可以是不同数据类型
-
使用 data.frame() 函数创建数据帧。
-
# Create the data frame. BMI <- data.frame( gender = c("Male", "Male","Female"), height = c(152, 171.5, 165), weight = c(81,93, 78), Age = c(42,38,26) ) print(BMI) -
gender height weight Age 1 Male 152.0 81 42 2 Male 171.5 93 38 3 Female 165.0 78 26
-
变量
-
命名
- 有字母，数字，点和下划线组成。
- 允许
.和_，只有.可以开头，.开头时不能跟数字，其他位置可以。
-
赋值:使用
=,->,<-进行赋值-
# 三者等价 var = c(1,0,2) var -> c(1,0,2) c(1,0,2) -> var
-
-
输出:
print(),cat()-
cat()函数将多个项目组合成连续打印输出。
-
print(var.1) cat ("var.1 is ", var.1 ," ") cat ("var.2 is ", var.2 ," ")
-
-
-
变量操作
-
查找变量
-
工作空间中当前可用的所有变量，我们使用
ls()函数.ls()函数也可以使用模式来匹配变量名。 -
# 输出当前环境中所有变量(点(.)开头的变量被隐藏) print(ls()) -
# 模式匹配，输出所有带有var的变量 print(ls(pattern = "var")) -
使用ls()函数的“all.names = TRUE”参数列出
-
# 输出当前环境中所有变量(包括点(.)开头的变量) print(ls(all.name = TRUE))
-
-
-
删除变量
-
删除某个变量
-
rm(var.3) print(var.3) # result [1] "var.3" Error in print(var.3) : object 'var.3' not found
-
-
删除所有变量
-
rm(list = ls()) print(ls()) # result character(0)
-
-
-
运算符
-
算术运算符：操作符对向量的每个元素起作用
+,-,*加减乘/: 两向量相除，结果带小数%%: 两个向量求余%/%: 两个向量相除取整^: 将第二向量作为第一向量的指数
-
关系运算符：操作符对向量的每个元素起作用
>,<,=,<=,>=,!=- 返回
TRUE或者FALSE
-
逻辑运算符：它只适用于逻辑，数字或复杂类型的向量。所有大于1的数字被认为是逻辑值TRUE。将第一向量的每个元素与第二向量的相应元素进行比较。 比较的结果是布尔值。
- 对向量每个元素操作
&: and|: or!: not
- 对向量第一个元素操作
&&: and||: ors
- 对向量每个元素操作
-
赋值运算符
- 左分配：赋值给左边
<-,<<-,=
- 右分配：赋值给右边
->,->>
- 左分配：赋值给左边
-
其他运算符：用于特定目的，而不是一般的数学或逻辑计算。
-
:它为向量按顺序创建一系列数字。左闭右闭-
v <- 2:8 print(v) # result 2 3 4 5 6 7 8
-
-
%in%用于标识元素是否属于向量。-
v1 <- 8 v2 <- 12 t <- 1:10 print(v1 %in% t) print(v2 %in% t) -
TRUE FALSE
-
-
%*%用于将矩阵与其转置相乘。-
M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE) t = M %*% t(M) print(t) # result [,1] [,2] [1,] 65 82 [2,] 82 117
-
-
决策 if
-
if
-
表达式
if(boolean_expression) { // statement(s) will execute if the boolean expression is true. } -
demo
x <- 30L if(is.integer(x)) { print("X is an Integer") } # result [1] "X is an Integer"
-
-
if…else if… … else…
-
表达式
if(boolean_expression) { // statement(s) will execute if the boolean expression is true. } else if( boolean_expression 3) { // Executes when the boolean expression 3 is true. } else { // statement(s) will execute if the boolean expression is false. } -
demo
x <- c("what","is","truth") if("Truth" %in% x) { print("Truth is found") } else { print("Truth is not found") } # result [1] "Truth is not found"
-
-
switch
-
表达式
switch(expression, case1, case2, case3....) -
demo
x <- switch( 3, "first", "second", "third", "fourth" ) print(x) # result [1] "third" -
demo-2
# runif() 函数用于生成从 0 到 1 区间范围内的服从正态分布的随机数 switch(1,2*3,sd(1:5),runif(3)) #返回（2*3,sd(1:5),runif(3)）list中的第一个成分 switch(2,2*3,sd(1:5),runif(3)) #返回第二个成分 switch(3,2*3,sd(1:5),runif(3)) #返回第三个成分 # result [1] 6 [1] 1.581139 [1] 0.31508117 0.04610938 0.19489747
-
包
获取包含R包的库位置：.libPaths()
获取已安装的所有软件包列表：library()
获取当前在R环境中加载的所有包：search()
循环
循环语句
-
repeat
-
repeat { commands if(condition) { break } } -
demo
v <- c("Hello","loop") cnt <- 2 repeat { print(v) cnt <- cnt+1 if(cnt > 5) { break } } # result [1] "Hello" "loop" [1] "Hello" "loop" [1] "Hello" "loop" [1] "Hello" "loop"
-
-
while
-
while (test_expression) { statement } -
demo
v <- c("Hello","while loop") cnt <- 2 while (cnt < 7) { print(v) cnt = cnt + 1 } # result [1] "Hello" "while loop" [1] "Hello" "while loop" [1] "Hello" "while loop" [1] "Hello" "while loop" [1] "Hello" "while loop"
-
-
for
-
for (变量 in 条件) { 循环体 } -
demo
v <- LETTERS[1:4] for ( i in v) { print(i) } # result [1] "A" [1] "B" [1] "C" [1] "D"
-
循环控制语句
- break：跳出当前循环
- next：跳过循环的当前迭代而不终止它时便可使用next，继续下一次迭代，相当于continue
数据重塑
数据重塑是关于改变数据被组织成行和列的方式
cbind()函数连接多个向量来创建数据帧rbind()函数合并两个数据帧。即保持列，增加了行merge()函数合并两个数据帧。 数据帧必须具有相同的列名称，在其上进行合并。
函数
function_name <- function(arg_1, arg_2, ...) {
Function body
}
返回值：
-
可以通过显示地调用return()，把一个值返回给主调函数。如果不是用这条语句，默认将会把最后执行的语句的值作为返回值。
-
函数的返回值可以说任何对象，也就可以返回复杂对象。如果你的函数有多个返回值，可以把它们存储在一个列表或其他容器变量中。
内置函数：
seq()，mean()，max()，sum(x) 和 paste(…) 等
函数参数：像python一样用
调用： function_name(arg_1, arg_2,…)
字符串
单双引号的使用：
-
单引号或双引号对中写入的任何值都被视为字符串
-
R语言存储的每个字符串都在双引号内，即使是使用单引号创建的依旧如此。
-
“xxxx‘xxxxxx”
-
‘xxxxx"xxxxxx’
字符串操作：
-
连接字符串 - paste() 函数
-
paste(..., sep = " ", collapse = NULL)- … 表示要组合的任意数量的自变量。
- sep 表示参数之间的任何分隔符。它是可选的。
- collapse 用于消除两个字符串之间的空格。 但不是一个字符串的两个字内的空间。
-
-
格式化数字和字符串 - format() 函数
-
format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))- x 是向量输入。
- digits 是显示的总位数。
- nsmall 是小数点右边的最小位数。
- scientific设置为 TRUE 以显示科学记数法。
- width 指示通过在开始处填充空白来显示的最小宽度。
- justify 是字符串向左，右或中心的显示。如：justify = “c”。
-
-
计算字符串中的字符数 - nchar() 函数
-
此函数计算字符串中包含空格的字符数。
-
nchar(x)- x 是向量输入。
-
-
更改大小写 - toupper()和tolower()函数
-
toupper(x) tolower(x)- x是向量输入。
-
-
提取字符串的一部分 - substring()函数
-
以char为单位
-
substring(x,first,last)- x 是字符向量输入。
- 首先是要提取的第一个字符的位置。
- last 是要提取的最后一个字符的位置。
-
向量
向量是最基本的R语言数据对象，有六种类型的原子向量。 它们是逻辑，整数，双精度，复杂，字符和原始。
-
创建向量
-
单元素向量
-
demo
# Atomic vector of type character. print("abc"); # Atomic vector of type double. print(12.5) # Atomic vector of type integer. print(63L) # Atomic vector of type logical. print(TRUE) # Atomic vector of type complex. print(2+3i) # Atomic vector of type raw. print(charToRaw('hello'))
-
-
多元素向量
-
demo
# If the final element specified does not belong to the sequence then it is discarded. v <- 3.8:11.4 print(v) # Create vector with elements from 5 to 9 incrementing by 0.4. print(seq(5, 9, by = 0.4)) # The logical and numeric values are converted to characters. s <- c('apple','red',5,TRUE) print(s) # result [1] 3.8 4.8 5.8 6.8 7.8 8.8 9.8 10.8 [1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0 [1] "apple" "red" "5" "TRUE"
-
-
-
访问向量元素
-
使用索引访问向量的元素。 t[]括号用于建立索引。 索引从位置1开始。
# Accessing vector elements using position. t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat") u <- t[c(2,3,6)] print(u) # Accessing vector elements using logical indexing. v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)] print(v) # Accessing vector elements using negative indexing. x <- t[c(-2,-5)] print(x) # Accessing vector elements using 0/1 indexing. y <- t[c(0,0,0,0,0,0,1)] print(y) # result [1] "Mon" "Tue" "Fri" [1] "Sun" "Fri" [1] "Sun" "Tue" "Wed" "Fri" "Sat" [1] "Sun"
-
-
向量操作
-
向量运算
- 见 运算符 部分
-
向量元素回收
-
对不等长的两个向量应用算术运算，则较短向量的元素被循环以完成操作。
v1 <- c(3,8,4,5,0,11) v2 <- c(4,11) # 做运算时，V2 becomes c(4,11,4,11,4,11)
-
-
向量元素排序
-
向量中的元素可以使用sort()函数排序
v <- c(3,8,4,5,0,11, -9, 304) sort.result <- sort(v) print(sort.result) revsort.result <- sort(v, decreasing = TRUE) print(revsort.result) # result # 数字型 [1] -9 0 3 4 5 8 11 304 [1] 304 11 8 5 4 3 0 -9 # 字符型 [1] "Blue" "Red" "violet" "yellow" [1] "yellow" "violet" "Red" "Blue"
-
-
列表
列表是R语言对象，使用list()函数创建的。
它包含不同类型的元素，如数字，字符串，向量和其中的另一个列表。 列表还可以包含矩阵或函数作为其元素。
-
创建列表
-
list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1) print(list_data)
-
-
命名列表元素
-
列表元素可以给出名称，并且可以使用这些名称访问它们
-
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")# Create a list containing a vector, a matrix and a list. list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2), list("green",12.3)) # Give names to the elements in the list. names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list") # Show the list. print(list_data) # result $`1st_Quarter` [1] "Jan" "Feb" "Mar" $A_Matrix [,1] [,2] [,3] [1,] 3 5 -2 [2,] 9 1 8 $A_Inner_list $A_Inner_list[[1]] [1] "green" $A_Inner_list[[2]] [1] 12.3
-
-
访问列表元素
- 列表的元素可以通过列表中元素的索引访问。
- 在命名列表的情况下，它也可以使用名称来访问。
-
操控列表元素
-
添加，删除和更新列表元素
-
只能在列表的末尾添加和删除元素
-
但我们可以更新任何元素
# Create a list containing a vector, a matrix and a list. list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2), list("green",12.3)) # Give names to the elements in the list. names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list") # Add element at the end of the list. list_data[4] <- "New element" print(list_data[4]) # Remove the last element. list_data[4] <- NULL # Print the 4th Element. print(list_data[4]) # Update the 3rd Element. list_data[3] <- "updated element" print(list_data[3]) # result [[1]] [1] "New element" $ NULL $`A Inner list` [1] "updated element" -
-
合并列表
-
将所有元素放在list()函数中，使用c()函数合并多个list为一个list
# Create two lists. list1 <- list(1,2,3) list2 <- list("Sun","Mon","Tue") # Merge the two lists. merged.list <- c(list1,list2) # Print the merged list. print(merged.list)
-
-
列表转向量
-
列表可以转换为向量，可以在将列表转换为向量之后应用对向量的所有算术运算
-
使用**unlist()**函数，将列表作为输入并生成向量。
-
# Create lists. list1 <- list(1:5) print(list1) list2 <-list(10:14) print(list2) # Convert the lists to vectors. v1 <- unlist(list1) v2 <- unlist(list2) print(v1) print(v2) # Now add the vectors result <- v1+v2 print(result) # result [[1]] [1] 1 2 3 4 5 [[1]] [1] 10 11 12 13 14 [1] 1 2 3 4 5 [1] 10 11 12 13 14 [1] 11 13 15 17 19
-
矩阵
矩阵是其中元素以二维矩形布局布置的R对象
-
语法
-
matrix(data, nrow, ncol, byrow, dimnames)- data是成为矩阵的数据元素的输入向量。
- nrow是要创建的行数。
- ncol是要创建的列数。
- byrow是一个逻辑线索。 如果为TRUE，则输入向量元素按行排列。
- dimname是分配给行和列的名称。
-
-
demo
-
# Define the column and row names. rownames = c("row1", "row2", "row3", "row4") colnames = c("col1", "col2", "col3") P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames)) print(P) # result col1 col2 col3 row1 3 4 5 row2 6 7 8 row3 9 10 11 row4 12 13 14
-
-
访问矩阵元素
-
使用元素的列和行索引来访问矩阵的元素
-
# Define the column and row names. rownames = c("row1", "row2", "row3", "row4") colnames = c("col1", "col2", "col3") # Create the matrix. P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames)) # Access the element at 3rd column and 1st row. print(P[1,3]) # Access the element at 2nd column and 4th row. print(P[4,2]) # Access only the 2nd row. print(P[2,]) # Access only the 3rd column. print(P[,3]) # result [1] 5 [1] 13 col1 col2 col3 6 7 8 row1 row2 row3 row4 5 8 11 14
-
-
矩阵计算
- 对于操作中涉及的矩阵，维度（行数和列数）应该相同。
- 加减乘除，都是对应元素位置做运算
- 乘除法的运算都是对应元素的乘除
数组
可以在两个以上维度中存储数据的R数据对象。
使用array()函数创建数组。 它使用向量作为输入，并使用dim参数中的值创建数组。
如果我们创建一个维度(2，3，4)的数组，则它创建4个矩形矩阵，每个矩阵具有2行和3列。 数组只能存储数据类型。
-
demo
-
# Create two vectors of different lengths. vector1 <- c(5,9,3) vector2 <- c(10,11,12,13,14,15) # Take these vectors as input to the array. result <- array(c(vector1,vector2),dim = c(3,3,2)) print(result) # result , , 1 [,1] [,2] [,3] [1,] 5 10 13 [2,] 9 11 14 [3,] 3 12 15 , , 2 [,1] [,2] [,3] [1,] 5 10 13 [2,] 9 11 14 [3,] 3 12 15 -
注意：这里是按列填充
-
-
命名行列
-
使用dimnames参数给数组中的行，列和矩阵命名
# Create two vectors of different lengths. vector1 <- c(5,9,3) vector2 <- c(10,11,12,13,14,15) column.names <- c("COL1","COL2","COL3") row.names <- c("ROW1","ROW2","ROW3") matrix.names <- c("Matrix1","Matrix2") # Take these vectors as input to the array. result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names, matrix.names)) print(result) # result , , Matrix1 COL1 COL2 COL3 ROW1 5 10 13 ROW2 9 11 14 ROW3 3 12 15 , , Matrix2 COL1 COL2 COL3 ROW1 5 10 13 ROW2 9 11 14 ROW3 3 12 1
-
-
访问数组元素：类似python的切片
-
# Print the third row of the second matrix of the array. print(result[3,,2]) # Print the element in the 1st row and 3rd column of the 1st matrix. print(result[1,3,1]) # Print the 2nd Matrix. print(result[,,2])
-
-
操作数组元素
- 对数组元素的操作通过访问矩阵的元素来执行
-
跨数组元素的计算
-
使用**apply()**函数在数组中的元素上进行计算
-
语法
apply(x, margin, fun)- x是一个数组。
- margin是所使用的数据集的名称。
- fun是要应用于数组元素的函数。
-
# Create two vectors of different lengths. vector1 <- c(5,9,3) vector2 <- c(10,11,12,13,14,15) # Take these vectors as input to the array. new.array <- array(c(vector1,vector2),dim = c(3,3,2)) print(new.array) # Use apply to calculate the sum of the rows across all the matrices. result <- apply(new.array, c(1), sum) print(result) # result , , 1 [,1] [,2] [,3] [1,] 5 10 13 [2,] 9 11 14 [3,] 3 12 15 , , 2 [,1] [,2] [,3] [1,] 5 10 13 [2,] 9 11 14 [3,] 3 12 15 [1] 56 68 60 # 解释： 参数c(1)不清楚 56 = (5 10 13)*2
-
因子（有点像set）
使用**factor()**函数通过将向量作为输入创建因子。
因子是用于对数据进行分类并将其存储为Levels的数据对象。
它们可以存储字符串和整数。
它们在具有有限数量的唯一值的列中很有用。
它们在统计建模的数据分析中很有用。
-
demo
-
基本用法(它的Level类似集合set的概念)
# Create a vector as input. data <- c("East","West","East","North","North","East","West","West","West","East","North") print(data) print(is.factor(data)) # Apply the factor function. factor_data <- factor(data) print(factor_data) print(is.factor(factor_data)) # result [1] "East" "West" "East" "North" "North" "East" "West" "West" "West" "East" "North" [1] FALSE [1] East West East North North East West West West East North Levels: East North West [1] TRUE -
数据帧（就是表格数据）的因子
-
对数据帧的文本数据列，R语言默认视为分类数据并在其上创建因子。
-
# Create the vectors for data frame. height <- c(132,151,162,139,166,147,122) weight <- c(48,49,66,53,67,52,40) gender <- c("male","male","female","female","male","female","male") # Create the data frame. input_data <- data.frame(height,weight,gender) print(input_data) # Test if the gender column is a factor. print(is.factor(input_data$gender)) # Print the gender column so see the levels. print(input_data$gender) # result height weight gender 1 132 48 male 2 151 49 male 3 162 66 female 4 139 53 female 5 166 67 male 6 147 52 female 7 122 40 male [1] TRUE [1] male male female female male female male Levels: female male # result height weight gender 1 132 48 male 2 151 49 male 3 162 66 female 4 139 53 female 5 166 67 male 6 147 52 female 7 122 40 male [1] TRUE [1] male male female female male female male Levels: female male
-
-
更改级别顺序
-
在factor()函数中，使用levels = c( )参数规定
data <- c("East","West","East","North","North","East","West","West","West","East","North") # Create the factors factor_data <- factor(data) print(factor_data) # Apply the factor function with required order of the level. new_order_data <- factor(factor_data,levels = c("East","West","North")) print(new_order_data) # result [1] East West East North North East West West West East North Levels: East North West [1] East West East North North East West West West East North Levels: East West North
-
-
生成因子级别
-
使用**gl()**函数生成因子级别。它需要两个整数作为输入，指示每个级别有多少级别和多少次。
-
语法
gl(n, k, labels)- n是给出级数的整数。
- k是给出复制数目的整数。
- labels是所得因子水平的标签向量。
-
demo
# 3级，每级复制4个，具体的元素见labels v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston")) print(v) # result Tampa Tampa Tampa Tampa Seattle Seattle Seattle Seattle Boston Boston Boston Boston Levels: Tampa Seattle Boston
-
-
数据帧
数据帧是表或二维阵列状结构，理解成表格就好了
-
特性
- 列名称应为非空。
- 行名称应该是唯一的。
- 存储在数据帧中的数据可以是数字，因子或字符类型。
- 每个列应包含相同数量的数据项。
-
创建数据帧
-
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Print the data frame. print(emp.data) # result emp_id emp_name salary start_date 1 1 Rick 623.30 2012-01-01 2 2 Dan 515.20 2013-09-23 3 3 Michelle 611.00 2014-11-15 4 4 Ryan 729.00 2014-05-11 5 5 Gary 843.25 2015-03-27
-
-
获取数据帧结构
-
使用str()函数可以看到数据帧的结构。
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Get the structure of the data frame. str(emp.data) # result 'data.frame': 5 obs. of 4 variables: $ emp_id : int 1 2 3 4 5 $ emp_name : chr "Rick" "Dan" "Michelle" "Ryan" ... $ salary : num 623 515 611 729 843 $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...
-
-
数据帧的数据摘要
-
应用**summary()**函数获取数据的统计摘要和性质
# Create the data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), stringsAsFactors = FALSE ) # Print the summary. print(summary(emp.data)) # result emp_id emp_name salary start_date Min. :1 Length:5 Min. :515.2 Min. :2012-01-01 1st Qu.:2 Class :character 1st Qu.:611.0 1st Qu.:2013-09-23 Median :3 Mode :character Median :623.3 Median :2014-05-11 Mean :3 Mean :664.4 Mean :2014-01-14 3rd Qu.:4 3rd Qu.:729.0 3rd Qu.:2014-11-15 Max. :5 Max. :843.2 Max. :2015-03-27
-
-
从数据帧提取数据
-
# 提取1，2行 result <- emp.data[1:2,] # 用第2和第4列提取第3和第5行 result <- emp.data[c(3,5),c(2,4)]
-
-
扩展数据帧
-
通过添加列和行来扩展数据帧。
-
使用新的列名称添加列
# Add the "dept" coulmn. emp.data$dept <- c("IT","Operations","IT","HR","Finance") v <- emp.data print(v) -
将更多行永久添加到现有数据帧,结构要一致，使用**rbind()**函数。
等同于添加多个结构一样的数据帧
# Create the first data frame. emp.data <- data.frame( emp_id = c (1:5), emp_name = c("Rick","Dan","Michelle","Ryan","Gary"), salary = c(623.3,515.2,611.0,729.0,843.25), start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")), dept = c("IT","Operations","IT","HR","Finance"), stringsAsFactors = FALSE ) # Create the second data frame emp.newdata <- data.frame( emp_id = c (6:8), emp_name = c("Rasmi","Pranab","Tusar"), salary = c(578.0,722.5,632.8), start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")), dept = c("IT","Operations","Fianance"), stringsAsFactors = FALSE ) # Bind the two data frames. emp.finaldata <- rbind(emp.data,emp.newdata) print(emp.finaldata) # result emp_id emp_name salary start_date dept 1 1 Rick 623.30 2012-01-01 IT 2 2 Dan 515.20 2013-09-23 Operations 3 3 Michelle 611.00 2014-11-15 IT 4 4 Ryan 729.00 2014-05-11 HR 5 5 Gary 843.25 2015-03-27 Finance 6 6 Rasmi 578.00 2013-05-21 IT 7 7 Pranab 722.50 2013-07-30 Operations 8 8 Tusar 632.80 2014-06-17 Fianance
-
187
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
