Posted Updated RLanga minute read (About 181 words)

GGPLOT

GGPlot 绘图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
p <- ggplot(data=mtcars, aes(x=wt, y=mpg))

geom_bar(color, fill, alpha)
geom_histogram(color, fill, alpha, linetype, binwidth)
geom_boxplot(color, fill, alpha, notch, width)
geom_violin(color, fill, alpha, linetype)
geom_density(color, fill, alpha, linetype)

geom_rug(color, side)
geom_smooth(method, formula, color, fill, linetype, size)


geom_hline(color, alpha, linetype, size)
geom_gitter(color, size, alpha, shape)
geom_line(color, alpha, linetype, size)
geom_point(color, alpha, shape, size)
geom_vline(color, alpha, linetype, size)

geom_text()
  • color：点、线、填充区域着色
  • fill：对填充区域着色，如：条形、密度区域
  • alpha：颜色透明度，0~1逐渐不透明
  • linetype：图案线条
    • 1：实线
    • 2：虚线
    • 3：点
    • 4：点破折号
    • 5：长破折号
    • 6：双破折号
  • size：点尺寸、线宽度
  • shape：点形状
    • 1：开放的方形
Posted Updated RLang11 minutes read (About 1696 words)

R可视化

R图形参数

使用、保存图形

保存图形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
png(
	file= "Rplot%03d.png",
	width= 480,
	height= 480,
	units= "px",
		# 图片分辨率
	pointsize= 12,
		# 文字大小
	bg= "white",
	res= NA,
	family= "",
	restoreConsole= TRUE,
	type= c("windows", "cairo"),
	antialias
)
	# `par`语句生效必须放在`png`、`dev.off`中间
	# 这个语句会强制覆盖与`par`语句重合的部分参数，即使这个
		# 函数后调用

pdf(filename)
win.metafile(filename)
jpeg(filename)
bmp(filename)
tiff(filename)
xfig(filename)
postscript(filename)
	# 开启目标图形设备
dev.off()
	# 关闭目标图形设备
	# 绘图语句至于其中，包括`par`

dev.new()
	# 打开新的图形窗口，防止多次绘图覆盖
dev.next()
dev.prev()
dev.set()
	# 选择将图形发送到不同窗口

par

par函数设置对整个工作空间图像设置均有效

1
2
3
4
5
6
7
8
opar <- par()
	# 无参调用，生成含有当前图形参数设置的列表
opar <- par(no.readonly= TRUE)
	# 生成一个可以修改的当前图形参数列表
par(opar)
	# 恢复为`opar`中的参数设置
par(attr_name)
	# 获取某个属性设置值

符号、线条

1
2
3
4
5
6
7
8
9
10
par(
	pch= int,
		# 绘制点时使用的符号
	cex= num,
		# 符号大小，相对于默认大小缩放倍数
	lty= int,
		# 线条类型
	lwd= num,
		# 线条宽度，相对于默认线条宽度的倍数
)

颜色

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
par(
	col= str/c(str),
		# 绘图颜色，循环使用
	col.axis= str/c(str),
		# 坐标轴刻度文字颜色
	col.lab= str/c(str),
		# 坐标轴标签颜色
	col.main= str/c(str),
		# 标题颜色
	col.sub= str/c(str)
		# 副标题颜色
	fg= str/c(str),
		# 前景色
	bg= str/c(str),
		# 背景色
)

文本属性

1
2
3
4
5
6
7
8
9
10
11
12
par(
	cex= num,
		# 文本大小，相对默认
	cex.axis= num,
		# 坐标轴刻度文字的缩放倍数
	cex.lab= num,
		# 坐标轴标签缩放倍数
	cex.main= num,
		# 标题缩放倍数
	cex.sub= num,
		# 副标题缩放倍数
)

字体、字号、字样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
par(
	font= int,
		# 绘图使用字体样式
		# 1：常规、2：粗体、3：斜体、4：粗斜体
	font.axis= int,
		# 坐标轴刻度字体样式
	font.lab= int,
	font.main= int,
	font.sub= int,
	ps= num,
		# 字体磅值
		# 文本最终大小为`cex*ps`
	family= "serif"/"sans"/"mono"/str,
)

图形、边界尺寸

1
2
3
4
5
6
7
8
9
10
11
12
par(
	pin= c(width, height),
		# 图片尺寸，单位英寸
	mai= c(bot, left, top, right),
		# 边界大小，单位英寸
	mar= c(bot, left, top, right),
		# 边界大小，单位英分（1/12英寸）
		# 默认值`c(5, 4, 4, 2)+ 0.1`
	mgp= c(axis_labels, tick_title, tick),
		# 坐标轴标签、刻度标签、刻度线位置
		# 图形边缘为0，单位为行
)

文本、自定坐标、图例

title

title函数可以为图形添加标题、坐标轴标签

1
2
3
4
5
6
7
8
9
10
11
12
title(
	main= str,
	sub= str,
	xlab= str,
	ylab= str,

	col.main= str,
		# 也可以指定文本大小、字体、旋转角度、颜色
	col.sub= str,
	col.lab= str,
	cex.lab= str
)

axis

创建自定义坐标轴

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
axis(
	side= int,
		# 坐标轴位置
		# 1-4：下、左、上、右
	at= c(int),
		# 需要绘制刻度线的位置
	labels= c(str),	
		# 刻度线对应labels
		# 默认为`at`中值
	pos= num,
		# 坐标轴线绘制位置坐标，即与另一坐标轴交点
	lty= num,
		# 线条类型
	col= str,
		# 线条、刻度颜色
	las= 0/2,
		# 标签平行、垂直坐标轴
	tck= num,
		# 刻度线长度，相对于绘图区域大小分数表示
		# 负值表示在图形外侧
		# `0`表示禁用刻度线
		# `1`表示绘制网格线
		# 默认`-0.01`
)
minor.tick

次要刻度线

1
2
3
4
5
6
7
8
library(Hmisc)
minor.tick(
	nx= int,
		# x轴次要刻度**区间**数
	ny= int,
	tick.ratio= num
		# 次要刻度线相较主要刻度线比例
)

abline

添加参考线

1
2
3
4
5
6
7
abline(
	h= c(int),
		# 水平参考线位置（多根）
	v= c(int),
	lty= int,
	col= str,
)

legend

添加图例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
legend(
	location= c(x, y)/
		# 指定`x, y`坐标
		"bottom"/"bottomleft"/"left"/"topleft"/
		"top"/"topright"/"right"/"bottoright"/"center"/
		# 使用关键字指定图例位置
		locator(1),
		# 鼠标交互式指定
	inset= num,
		# `location`使用关键字指定位置，设置图例向图形内侧移动
		# 移动`num`绘图区域比例
	title= str,
		# 图例标题字符串
	legend= c(str),
		# 图例labels字符串向量
	col= c(col_str),
	pch= c(pch_int),
		# 若图例标识符号不同的点
	lwd= c(lwd_int),
	lty= c(lty_int),
		# 若图例标识宽度、样式不同的线
	fill= c(col_str),
		# 若图例标识颜色填充的盒型
)

mtext、text

  • mtext：向图形四个边界之一添加文本
  • text：向绘图区域内部添加文本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
text(
	location,
		# 同`legend`
	"text to place",
	pos= int,
		# 文本相对于`location`方向
		# 1-4：下、左、上、右
	offset= num,
		# 文本相对`location`偏移量
	cex= num,
	col= c(col_str),
	font= num,
)

mtext(
	"text to place",
	side= int,
		# 放置文本的边
		# 1-4：下、左、上、右
	line= num,
		# 向内、外移动文本
		# 越大文本越向外移动
	adj= int,
		# 1：文本坐下对齐
		# 2：文本右上对齐
	cex= num,
	col= c(col_str),
	font= num,
)

图形组合

par

1
2
3
4
5
6
7
8
9
10
11
12
13
14
par(
	mfrow= c(nrows, ncols)
)
	# 设置按行填充的图形矩阵
par(
	mfcol= c(nrows, ncols)
)
	# 设置按列填充的图形矩阵
	# 然后按照的绘图顺序依次填充矩阵

par(
	fig= c(x1, x2, y1, y2)
)
	# 接下来图形在`fig`指定范围内绘制

layout

1
2
3
4
5
6
7
8
9
10
layout(
	mat= matrix(int),
		# `mat`中元素值`n`表示第n个绘制的图形
		# 其在矩阵中所处的位置即其填充的位置
	widths= c(num),
		# 各列宽度值向量
		# 相对图形比例可以直接数值表示
		# 绝对数值可以通过函数`lcm`指定
	heights= c(num),
		# 各行高度值向量

R原始图表

条形图

1
2
3
4
5
6
7
8
barplot(
	H,
	xlab,
	ylab,
	main,
	names.arg,
	col
)

一般条形图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
H <- c(7, 12, 28, 3, 41)
M <- c("Mar", "Apr", "May", "Jun", "Jul")

png(file = "barchart.png")
	# 设置图表文件名
barplot(
	H,
		# 各组数据大小
	names.arg = M,
		# 各组labels
	xlab = "Month",
		# x轴名
	ylab = "Revenue",
		# y轴名
	col = "blue",
		# 条形填充颜色
	main = "Revenue Chart",
		# 标题
	border = "red"
		# 条形边框颜色
)
	# 绘制图表
dev.off()
	# 保存图表

组合、堆积条形图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
colors <- c("green", "orange", "brown")
months <- c("Mar", "Apr", "May", "Jun", "Jul")
regions <- c("East", "West", "North")

values <- matrix(
	c(2,9,3,11,9,4,8,7,3,12,5,2,8,10,11),
	nrow = 3,
	ncol = 5,
	byrow = TRUE)
png(file = "barchart_stacked.png")
barplot(
	values,
	main = "total revenue",
	names.arg = months,
	xlab = "month",
	ylab = "revenue",
	col = colors)

legend(
	"topleft",
	regions,
	cex = 1.3,
	fill = colors)

dev.off()

饼图

1
2
3
4
5
6
7
8
pie(
	x,
	labels,
	radius,
	main,
	col,
	clockwise
)

一般饼图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")
piepercents <- round(100 * x / sum(x), 1)
	# `round`取小数位数

png(file = "city.png")
pie(
	x,
	labels = piepercents,
	main = "city pie chart",
	col = rainbow(length(x))
)

legend(
	"topright",
	labels,
		# 饼图注解设为百分比，所以这里设置各组别labels
	cex = 0.8,
	fill = rainbow(length(x))
)

dev.off()

3D饼图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
library(plotrix)
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

png(file = "3d_pie_charts.jpg")

pie3D(
	x,
	labels,
	explode = 0.1
	main = "pie charts of countries"
)

dev.off()

直方图

1
2
3
4
5
6
7
8
9
10
11
hist(
	v,
	main,
	xlab,
	xlim,
	ylim,
	breaks,
		# 每个直方的宽度
	col,
	border
)

一般直方图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
v <- c(9,13,21,8,36,22,12,41,31,33,19)

png(file = "histogram.png")

hist(
	v,
	xlab = "weight",
	col = "green",
	border = "blue"
	xlim = c(0, 40),
	ylim = c(0, 5),
	breaks = 5
)

dev.off()
Posted Updated RLang21 minutes read (About 3158 words)

R语法

生存

配置

注释

  • R语言的注释和其他脚本语言类似，使用#注释行，但是R没有 多行注释语法
  • 可以使用if(FALSE)语句进行“注释”
    1
    2
    3
    if(FALSE) {
    	"comments"
    }

工作路径

1
2
3
4
getwd()
	# 返回当前工作路径，默认`~/Documents`
setwd(/path/to/dir)
	# 设置当前工作路径

变量

  • R中有效的变量名称由字母、数字、点、下划线组成，变量名以 字母、后不跟数字的点开头
  • R中变量为动态类型，可多次更改变量数据类型
  • 变量无法被声明，在首次赋值时生成

赋值

1
2
3
4
5
6
7
8
9
10
var.1 = c(0, 1, 2, 3)
	# 不常用
var.2 <- c("learn", "R")
	# 常用方法
var .3 <<- c(3, 1, TRUE, 2+3i)
	# 特殊赋值符，可以扩展变作用域为“整个”工作空间
	
c(TRUE, 1) -> var.4
	# 右赋值符
c(TRUE, 2+3i) ->> var.5

搜索

ls函数可以搜索当前工作空间中所有可用变量

1
2
3
4
5
6
ls(
	pattern = "var_pattern",
	all.name = FALSE/TRUE
)
	# `pattern`：使用模式匹配变量名
	# `all.name`：开头变量默认隐藏，可通过设置参数展示

删除

rm函数可以删除变量

1
2
3
4
rm(var.3)

rm(list = ls())
	# 删除所有变量

数据导入

edit

1
2
3
4
5
6
7
8
9
10
11
mydata <- data.frame(
	age = numeric(0),
	gender = character(0),
	weight = numeric(0)
)
	# `numeric(0)`类似的赋值语句创建指定模式但不含数据变量
mydata <- edit(mydata)
	# `edit`会调用允许手动输入数据的文本编辑其
	# `edit`在副本上操作，需要重新给变量
fix(mydata)
	# `mydata <- edit(mydata)`等价写法，直接在原对象上操作

read.table

1
2
3
4
5
6
7
8
9
10
11
12
13
DF <- read.table(
	file(/path/to/file),
	header = TRUE/FALSE,
	sep = " \t\n\r"/",",
	row.names = c(),
	col.names = c("V1", "V2", ...)/c(str),
	na.strings = NULL/c(str)),
	colClasses = NULL/c("numeric", "character", "NULL"),
	quote = "'""/str,
	skip = 0/int,
	stringAsFactors = TRUE/FALSE,
	test = str
)

  • 说明：从带分隔符的文本文件中导入数据

  • 参数

    • header：第一行是否包含变量名
    • sep：分隔符，默认数个空格、tab、回车、换行
    • row.names：指定行标记符
    • col.names：指定DF对象列名
    • na.strings：表示缺失值的字符串向量，其包含字符串 读取时转为NA
    • colClasses：设置DF对象每列数据模式
      • “NULL”表示跳过
      • 长度小于列数时开始循环
      • 读取大型文本可以提高速度
    • quote：字符串划定界限，默认"'
    • StringAsFactor：标记字符向量是否转换为factor
      • colClasses优先级更高
      • 设为FALSE可以提升读取速度
    • text：读取、处理的字符串，而不是file

常用函数

1
2
3
4
5
6
7
8
9
print()
	# 浏览对象取值
str()
	# 查看对象结构
ls()
	# 管理对象
remove()
rm()
	# 删除指定对象

数据模式（类型）

  • 数据模式是指R存储数据的方式
  • 即从存储角度对R数据对象划分
  • class函数就是返回数据模式（类型）

Logical

只需要1byte存储

  • TRUE/T
  • FALSE/F

Integer

占用2-4byte

  • 2L、0L

Numeric

可进一步分

  • float占用4byte
  • double占用8byte

R中数值型数据默认为double

  • 12.3、4

Complex

  • comlplex：3+2i

Character

R中'、"对中的任何值视为字符串

  • '、"必须在开头、结尾成对存在
  • '、"结尾的字符串中，只能插入对方

paste

连接多个字符串

1
2
3
4
5
6
7
Chars = paste(
	...,
		# 要组合的任意数量变量
	sep = " ",
		# 分隔符
	collapse = NULL)
		# 消除两个字符串之间空格

format

将数字、字符串格式为特定样式

1
2
3
4
5
6
7
8
9
10
11
12
13
Chars = format(
	x([num, chars],
		# 向量
	digits(int),
		# 显示的总位数
	nsmall(int),
		# 小数点右边最小位数
	scientific=FALSE/TRUE,
		# `TRUE`则显示科学计数法
	width(int),
		# 在开始处填充空白来显示的最小宽度
	justify = c("left", "right", "centre", "none"))
		# 字符串显示位置

nchar

计算包括空格在内的字符串长度

1
2
3
int = nchar(
	x(chars)
)

toupper、tolower

改变字符串大小写

1
2
3
4
5
6
chars = toupper(
	x(chars)
)
chars = tolower(
	x(chars)
)

substring

获取字符串子串

1
2
3
4
5
6
chars = substring(
	x(chars),
	first(int),
	last(int)
)
	# 包括头尾
  • R对象是指可以赋值给变量的任何事物，包括常量、数据结构、 函数
  • 对象都拥有某种模式，描述对象如何存储
  • 对象拥有某个“类”，向print这样的泛型函数表明如何处理 此对象

Raw

  • raw：v <- charToRaw("Hello")（byte类型）

结构角度划分R对象

Vector

用于存储数值型、字符型、逻辑型数据的一维数组

  • 单个向量中的出数据必须拥有相同的类型、模式（数值型、字符 型、逻辑型）
  • R中没有标量，标量以单元素向量形式出现
1
2
3
4
5
6
7
8
9
10
apple <- c("red", "green", "yellow") 
apple[1]
	# 访问单个元素，从1开始
apple[1: 3]
	# 切片，闭区间
apple[7] = "seven"
	# 将值赋给某个向量、矩阵、数组或列表中一个不存在的元素时
		# R将自动扩展其以容纳新值，中间部分设为`NA`

is.vector(apple)

创建向量

1
2
3
4
5
6
7
8
9
10
11
12
rep(start: end, each=repeat_time)
	# 元素重复
rep(start: end, times=repeat_time)
	# 向量重复

seq(from=start, to=end, by=step)
	# 指定步长
seq(from=start, to=end, length=len)
	# 指定个数

vector(length=len)
	# 元素为`FALSE`

访问向量元素

1
2
3
4
5
6
7
a[1]
a[1:2]
a[c(1,3)]
a[c(T, F, T)]

a[-c(1:2)]
	# 负号不能用于逻辑向量

Matrix

二维数组：组织具有相同存储类型的一组变量

  • 每个元素都拥有相同的模式（数值型、字符型、逻辑型）

创建矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
mtx <- matrix(
	vector,
	nrow(int)
	ncol(int),
	byrow = FALSE/TRUE,
	dimnames = list(
		c(row_names),
		c(col_names)
	)
)

is.matrix()

cbind()
	# 将多个已有向量（列）合并为矩阵

矩阵信息

1
2
3
4
5
6
dim(mtx)
	# 显示矩阵行、列
colnames(mtx)
colnames(mtx[, col_start: col_end])
rownames(mtx)
ronnames(mtx[row_start: row_end, ])

访问矩阵元素

1
2


Array

类似于矩阵，但是维度可以大于2

  • 其中元素也只能拥有一种模式
1
2
3
4
5
arr <- array(
	vector,
	dimensions(c(int)),
	dimnames = c(dim_names)
)

Data.Frame

数据帧是表、二维数组类似结构

  • 不同的列可以包含不同的模式
  • 每列包含一个变量的值，每行包含来自每列的一组值
  • 数据帧的数据可是数字、因子、字符串类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
df <- data.frame(
	col1(c()),
	col2(c()),
	...,
	row.names = coln
)
	# `row.names`：指定实例标识符，即index

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("2017-01-01", "2017-09-23",
		"2017-11-15", "2017-05-11", "2018-03-27")),
	stringsAsFactors = FALSE
)
	# 创建DF

统计性质

1
2
3
4
5
str(emp.data)
	# 可以获得DF结构

summary(emp.data)
	# 获得DF的统计摘要、性质

筛、删、减

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
emp.data.cols <- data.frame(
	emp.data$emp_name,
	emp.data$salary)
	# 列名称获取DF中特定列

emp.data.rows <- emp.data([1:2, ]
	# 行切片获取特定行

emp.data.rows_2 <- emp.data[c(3, 5), c(2, 4)]
	# 行、列list获取特定行、列

emp.data$dept <- c("IT", "Operations", "IT", "HR", "Finance")
	# 新列名添加新列

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
)
emp.finaldata <- rbind(emp.data, emp.newdata)
	# `rbind`将新DF同原DFconcat，达到添加新行

拼、接

rbind

结合两个DF对象行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
city <- c("Tampa", "Seattle", "Hartford", "Denver")
state <- c("FL", "WA", "CT", "CO")
zipcode <- c(33602, 98104, 06161, 80294)

address <- cbind(city, state, zipcode)
	# `cbind`连接多个向量创建DF

new.address <- data.frame(
	city = c("Lowry", "Charlotte"),
	state = c("CO", "FL"),
	zipcode = C("80230", "33949"),
	stringAsFactors = FALSE
)
	# 使用`data.fram`创建DF

all.address <- rbind(
	address,
	new.address
)
	# `rbind`结合两个DF的行
merge

根据两DF列进行merge

1
2
3
4
5
6
7
8
9
10
lirary(MASS)
	# 加载数据集

merged.Pima <- merge(
	x = Pima.te,
	y = Pima.tr,
	by.x = c("bp", "bmi"),
	by.y = c("bp", "bmi")
)
	# 根据DF某（些）列merge
melt、cast
1
2
3
4
5
6
7
8
9
10
11
12
13
library(MASS)
library(reshape2)
melton.ships <- melt(
	ships,
	id = c("type", "year")
)
	# `melt`将剩余列转换为`variable`、`value`标识

recasted.ship <- cast(
	molten.ship,
	type+year~variable,sum
)
	# 和`melt`相反，以某些列为“轴”合并

绑定

attach、detach
1
2
3
4
5
6
7
8
9
10
11
12
13
attach(emp.data)
	# `attach`可以将数据框加入R的搜索路径
	# 之后R遇到变量名之后，将检查搜索路径的数据框
	# 注意，如果之前环境中已经有df对象列同名变量，那么原始
		# 对象优先，不会被覆盖

	emp.data.cols.copy <- data.frame(
		emp_name,
		salary
	)
		# 否则需要之前一样使用`$`
detach(emp.data)
	# 将数据框从搜索路径移除
with
1
2
3
4
5
6
7
8
9
10
with(emp.data, {
	emp.data.cols.copy <<- data.frame(
		emp_name,
		salary
	)
})
	# `{}`中的语句都针对`emp.data`执行，如果只有一条语句，
		# 花括号可以省略
	# `with`语句内`<-`赋值仅在其作用于内生效，需要使用`<<-`
		# 特殊赋值符保存至“全局”变量中

Factor

分类变量、有序变量在R中称为因子，其决定了数据的分析方式、 如何进行视觉呈现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fctr <- factor(
	vector(c(factors)),
	ordered = FALSE/TRUE,
	levels = c(ordered_unique_factors),
	labels = c(factor_labels)

	# `ordered`：默认不是有序变量
	# `levels`：指定factors的“排序”，确定映射的整数值，
		# 对于分类变量也可以设置
		# 没有在`levels`中显式指定的factor视为缺失
	# `labels`：设置各factor labels，输出则按照labels输出
		# 注意`labels`顺序必须和`levels`一致
		# 对数值型factor尤其有用
)
  • factor以整形向量的形式存储类别值
    • 整数取值范围为1~k，k为定性（分类、有序）变量中 唯一值个数
  • 同时一个由字符串（原始值）组成的内部向量将映射到这些整数
    • 分类变量：字符串映射的整数值由字母序决定
    • 有序变量：按字母序映射可能与逻辑顺序不一致，可以使用 参数levels指定顺序

List

一些对象、成分的有序集合

  • 允许整合若干（可能无关）的对象到单个对象下
  • 很多R函数结果运行结果以列表形式返回，由调用者决定使用 其中何种成分
1
2
3
4
5
6
7
8
9
10
11
12
13

l <- list(
	[name1 =]object1,
	[name2 =]object2,
	...
)
	# 可以给列表中的对象命名
	# 命名成分`l$name1`也可以正常运行


list1 <- list(c(2, 5, 3), 21, 3, sin)
print(list1)
print(class(list1))

运算符

算术运算符

算术操作符作用与向量的每个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
v <- c(2, 5.5, 6)
t <- c(8, 3, 4)
print(v + t)
	# 算术操作符作用与向量的每个元素
print(v - t)
print(v * t)
print(v/t)
print(v %% t)
	# 向量求余
print(v %/% t)
	# 求商
print(v ^ t)
	# 指数运算

关系运算符

比较两个向量的相应元素，返回布尔值向量

1
2
3
4
5
6
7
8
9
v <- c(2, 5.5, 6, 9)
t <- c(8, 2.5, 14, 9)
print (v > t)
	# 比较两个向量的相应元素，返回布尔值向量
print (v < t)
print (v == t)
print (v != t)
print (v <= t)
print (v >= t)

逻辑运算符

只适用于逻辑、数字、复杂类型向量，所有大于1的数字被认为是 逻辑值TRUE

1
2
3
4
5
6
7
8
9
10
v <- c(3, 1, TRUE, 2+3i)
t <- c(4, 1, False, 2+3i)
print(v & t)
	# 比较两个向量相应元素，返回布尔值向量
print(v | t)
print(!v)

print(v && t)
	# 只考虑向量的第一个元素，输出单个bool值元素向量
print(v || t)

其他运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
t <- 2: 8
	# 为向量按顺序创建一系列数字

v1 <- 8
v2 <- 12
print (v1 %in% t)
print (v2 %in% t)
	# 标识元素是否属于向量

M = matrix(c(2, 6, 5, 1, 10, 4),
	nrow = 2,
	ncol = 3,
	byrow = TRUE)
t = M %*% t(M)
	# 矩阵相乘

R语句

条件

1
2
3
if
else
switch

循环

1
2
3
4
5
repeat
while
for
break
next

函数

1
2
3
4
5
func_name <- function(
	arg_1,
	arg_2,...){

}

R内置函数

1
2
3
print(seq(32, 44))
print(mean(25: 82))
print(sum(41: 68))

自定义参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
new.function_1 <- fucntion(){
	# 无参数函数
	for(i in 1: 5){
		print(i ^ 2)
	}
}
new.function_1()

new.function_2 <- function(a, b, c){
	# 有参数函数
	result <- a * b + c
	print(result)
}
new.function_2(5, 3, 11)
	# 按参数顺序调用函数
new.function_2(
	a = 11,
	b = 5,
	c = 3)
	# 按参数名称调用

new.function_3 <- function(a=3, b=6){
	# 含有默认参数函数
	result <- a * b
	print(result)
}
new.function_3
	# 无参数（使用默认参数）
new.function_3(9, 5)

函数功能延迟计算

1
2
3
4
5
6
7
new.function <- function(a, b){
	print(a ^ 2)
	print(a)
	print(b)
}
new.function(6)
	# 调用函数能部分执行成功，直到`print(b)`

包

R语言包是R函数、编译代码、样本数据的集合

  • 存储在R环境中名为library的目录下
  • 默认情况下，只有R安装时提供默认包可用，已安装的其他包 必须显式加载
1
2
3
4
5
6
7
8
.libPaths()
	# 获取包含R包的库位置

library()
	# 获取已安装所有软件包列表

search()
	# 获取当前R环境中加载的所有包

安装包

加载包

1
2
3
library("pkg_name",
	lib.loc=/path/to/library)
	# `lib.loc`参数默认应该就是`.libPaths`，一般不用设置

Categories

Follow

Recents

Advertisement

follow.it

×