ggplot2 cheatsheet.pdf
图形分层语法

图形语法(grammar of graphic, gg):将任何图形精确地描述为以下要素的组合,使绘图过程模块化
- 图形架构
- 数据集 (data)
- 从变量到坐标轴的映射 (mapping)
- 几何图层 (geom)
- 统计变换 (stat)
- 位置调整 (position)
- 比例尺 (scale)
- 坐标系模式 (coordinate system)
- 分面模式 (facet)
- 图形美化
- 绘图区外部的标签 (labs)
- 绘图区内部的文本标签和说明 (geom_label, geom_text)
- 参考线、箭头和方框
- 注释 (annotations)
- 图例 (guides)
- 主题 (theme)
- 颜色
按照上述模板,可以使用代码构建能够想象到的任何图形
qplot()
quickplot 语法糖 qplot(x = cty, y = hwy, data = mpg, geom = "point")
last_plot()
return the last plot
绑定数据集
ggplot(data=NULL, mapping=aes(), ...,environment=parent.frame())
ggplot()创建了一个坐标系,可以通过 geom_function 函数向其中添加需要的各种图层。
# aes()定义了如何将数据中的变量映射为图形属性
# 本例中,将mtcars中的wt变量映射为x轴,将mpg变量映射为y轴
p <- mtcars %>%
ggplot(aes(x = wt, y = mpg)) +
geom_point(pch = 17, color = "blue", size = 2) +
geom_smooth(
method = "lm",
se = FALSE,
color = "red",
linetype = 2
) +
labs(
title = "Automobile",
x = "Weight",
y = "Miles Per Gallon"
)
ggplotly(p) %>%
saveWidget("./Figures/Automobile.html",
selfcontained = F,
libdir = "lib"
)
p

几何图层
常用几何图层
下表列出了比较常见的几何函数,以及经常使用的选项。 
单变量
# 直方图
data(singer, package = "lattice")
p <- ggplot(singer, aes(x = height)) +
geom_histogram()
# geom_histgrom()函数在y变量没有指定时默认对x轴变量统计频数
ggplotly(p) %>%
saveWidget("./Figures/Histogram.html",
selfcontained = F,
libdir = "lib"
)
p

双变量
# 箱线图
p <- ggplot(singer, aes(x = voice.part, y = height)) +
geom_boxplot()
ggplotly(p) %>%
saveWidget("./Figures/Boxplot.html",
selfcontained = F,
libdir = "lib"
)
p

几何图层的参数

data(car::Salaries)
p <- ggplot(Salaries, aes(x = rank, y = salary)) +
geom_boxplot(
fill = "cornflowerblue", # fill为填充色,color为外框色
color = "black"
) +
geom_point(position = "jitter", color = "blue", alpha = .5) + # jitter将重叠数据打散,alpha表示透明度
geom_rug(side = "l", color = "black") # rug为轴须图,左侧,黑色
ggplotly(p) %>%
saveWidget("./Figures/Boxplot2.html",
selfcontained = F,
libdir = "lib"
)
p

拟合曲线
data(Salaries, package = "car")
# 默认拟合和线性拟合
p1 <- ggplot(data = Salaries, aes(x = yrs.since.phd, y = salary)) +
geom_point() +
geom_smooth()
p2 <- ggplot(data = Salaries, aes(x = yrs.since.phd, y = salary)) +
geom_point() +
geom_smooth(method = lm)
grid.arrange(p1, p2, ncol = 2)

# 按性别拟合二次多项式线性回归
p3 <- ggplot(
data = Salaries,
aes(
x = yrs.since.phd, y = salary,
linetype = sex, shape = sex, color = sex
)
) +
geom_smooth(method = lm, formula = y ~ poly(x, 2), se = FALSE, size = 1) +
geom_point(size = 1)
ggplotly(p3) %>%
saveWidget("./Figures/smooth.html",
selfcontained = F,
libdir = "lib"
)
p3

多个几何图层的叠加
当几何图层组合形成新类型的图时,ggplot2包的真正力量就会得到展现:实现多图层的叠加。
此时不宜转换为 plotly 对象,显示会出错。
data(singer, package = "lattice")
ggplot(singer, aes(x = voice.part, y = height)) +
geom_violin(fill = "lightblue") +
geom_boxplot(fill = "lightgreen", width = .2)

映射
ggplot() 和几何图层函数的 mapping 参数 aes()
用以定义从变量到图形属性(表示数据信息的可视化属性)的映射。
要注意,图形属性不仅包括数据点的大小、形状和颜色等,数据点的x轴位置和y轴位置本身也是图形属性。
全局与局部映射
如果将一组映射传递给ggplot()函数。这些映射会作为全局映射应用到图中的每个几何图层中;如果将映射放在几何图层函数中,则会成为局部映射,会扩展或覆盖全局映射,仅对该图层有效。这样一来,我们就可以在不同的图层中显示不同的图形属性。
# x和y的映射是全局的,两个几何图层共享之
p <- ggplot(data = mpg, mapping = aes(x = displ, y = hwy)) +
# color的映射是局部的,仅对这一句有效
geom_point(mapping = aes(color = class)) +
geom_smooth()
ggplotly(p) %>%
saveWidget("./Figures/smooth1.html",
selfcontained = F,
libdir = "lib"
)
p

全局与局部数据
甚至可以为不同的图层指定不同的数据。
p <- ggplot(data = mpg, mapping = aes(x = displ, y = hwy)) +
geom_point(mapping = aes(color = class)) +
# geom_smooth()中的局部数据参数覆盖了ggplot()中的全局数据参数
geom_smooth(data = filter(mpg, class == "subcompact"), se = FALSE)
ggplotly(p) %>%
saveWidget("./Figures/smooth2.html",
selfcontained = F,
libdir = "lib"
)
p

映射与分组
几何图层函数的mapping参数/aes()函数是一个分配分组变量的自然的地方。最基本的分组语法是将分组变量映射为图形的group属性,即aes(group = variable)
,也可以将分组变量映射为其他更具视觉效果的图形属性(图中对象的可视化属性)。
在函数aes()中将图形属性名称和变量名称关联起来后,ggplot2会自动为每个变量值分配唯一的图形属性水平,这个过程称为scale变换。ggplot2还会添加一个图例,以表示图形属性水平和变量值之间的对应关系。
data(Salaries, package = "car")
# 在aes()中用rank分组,将rank映射为图形的fill(填充色)属性
p <- ggplot(data = Salaries, aes(x = salary, fill = rank)) +
geom_density(alpha = .3)
ggplotly(p) %>%
saveWidget("./Figures/group1.html",
selfcontained = F,
libdir = "lib"
)
p

# 根据sex和rank分组,共分为6组
p <- ggplot(
Salaries,
aes(
x = yrs.since.phd, y = salary,
color = rank, shape = sex
)
) +
geom_point()
ggplotly(p) %>%
saveWidget("./Figures/group2.html",
selfcontained = F,
libdir = "lib"
)
p

统计变换:ggplot2的绘图原理
很多图形绘制的是数据集的原数据,比如散点图;另外一些图形则可以绘制那些计算出的新数据,比如条形图。
ggplot(data = diamonds) +
geom_bar(mapping = aes(x = cut))

绘图时用来计算新数据的算法称为stat(statistical transformation,统计变换)。通过查看stat参数的默认值,你可以知道几何图层函数使用了哪种统计变换。
geom_bar(
mapping = NULL, data = NULL,
stat = "count", position = "stack", ...,
width = NULL, binwidth = NULL, na.rm = FALSE, show.legend = NA, inherit.aes = TRUE
)
geom_bar
中stat参数的默认值是count,这说明geom_bar()
使用stat_count()
函数进行统计变换(stat_count()
在文档中与geom_bar()
位于同一页)。想要找出由统计变换计算出的变量,可以查看帮助文件中的 Computed variables 节,它告诉我们stat_count()
会计算出两个新变量:count和prop
通常来说,几何图层函数和统计变换函数可以互换使用。可以这样做的原因是,每个几何图层函数都有一个默认统计变换,每个统计变换函数都有一个默认几何图层。例如,可以使用stat_count()
替换geom_bar()
来重新生成前面那张图。
ggplot(data = diamonds) +
stat_count(mapping = aes(x = cut))

显式使用统计变换函数的3个原因如下。
覆盖默认的统计变换
demo <- tribble(
~a, ~b,
"bar_1", 20,
"bar_2", 30,
"bar_3", 40
)
# 将geom_bar()函数的统计变换从默认的'count'改为'identity',这样就可以将条形的高度映射为y轴变量的初始值。
ggplot(data = demo) +
geom_bar(mapping = aes(x = a, y = b), stat = "identity")

覆盖从统计变换生成的变量到图形属性的默认映射
# 显示一张表示比例(而不是计数)的条形图。
ggplot(data = diamonds) +
geom_bar(mapping = aes(x = cut, y = ..prop.., group = 1))

在代码中强调统计变换
可以使用stat_summary()函数将人们的注意力吸引到你计算出的那些摘要统计量上。stat_summary()函数为x的每个唯一值计算y值的摘要统计。
ggplot(data = diamonds) +
stat_summary(mapping = aes(x = cut, y = depth), fun.ymin = min, fun.ymax = max, fun.y = median)

ggplot2提供了20多个统计变换以供你使用。每个统计变换都是一个函数,因此你可以按照通用方式获得帮助,例如?stat_bin。如果想要查看全部的统计变换,可以使用ggplot2速查表。
位置调整
identity |
不调整位置 |
dodge |
并列放置,如簇状条形图 |
stack |
堆叠放置 |
fill |
堆叠且显示比例 |
jitter |
加入随机扰动防止图形重合 |
# position='identity',将每个对象直接显示在图中,原地不动,不调整位置。
ggplot(diamonds, aes(x = cut, fill = clarity)) + # 没有映射y轴,geom_bar()默认计数
geom_bar(position = "identity")

ggplot(diamonds, aes(x = cut, color = clarity)) +
geom_bar(fill = NA, position = "identity")

# position="fill",堆叠显示比例(计数后求比例)
ggplot(diamonds) +
geom_bar(aes(cut, fill = clarity), position = "fill")

# position="dodge",并列显示
ggplot(diamonds) +
geom_bar(aes(cut, fill = clarity), position = "dodge")

# position="stack",堆叠显示
ggplot(diamonds) +
geom_bar(aes(cut, fill = clarity), position = "stack")

# position="jitter",添加随机扰动,防止散点重叠
ggplot(data = mpg) +
geom_point(aes(displ, hwy))

ggplot(data = mpg) +
geom_point(aes(displ, hwy), position = "jitter")

# 或用函数geom_jitter()实现
ggplot(data = mpg, aes(x = displ, y = hwy)) +
geom_point() +
geom_jitter()

Scale 比例尺
scale 的命名模式和用途
输入以下代码时:
ggplot(mpg, aes(displ, hwy)) +
geom_point(aes(color = class))
ggplot2 会自动在后台为代码添加默认 scale
ggplot(mpg, aes(displ, hwy)) +
geom_point(aes(color = class)) +
scale_x_continuous() +
scale_y_continuous() +
scale_color_discrete()
scale 的命名模式:scale_图形属性_类型。scale 的常用类型有连续型、离散型、日期时间型或日期型。
基于以下两种原因,需要使用非默认 scale:
- 你或许要对默认 scale 的一些参数进行调整。例如,当想要修改坐标轴刻度或图例中的项目标签时,就需要进行这些调整。
- 你或许想要整体替换默认 scale,从而使用一种完全不同的算法。因为你对数据更加了解,所以使用与默认方式不同的 scale 通常能达到更好的效果。
scale*()
函数族
最常用
scale_*_continuous()
scale_*_discrete()
scale_*_identity()
scale_*_manual()
日期时间
scale_*_date()
scale_*_datetime()
scale*()
的参数
limits
接收一个向量,取其两端作为一个范围。仅当数据的坐标在这个范围内时,才会在图中显示。
本质上相当于对数据进行了筛选,取了子集,此外的数据会变成 NA
df <- data.frame(x = 1:3, y = 1:3)
base <- ggplot(df, aes(x, y)) +
geom_point(size = 4)
base

base + scale_x_continuous(limits = c(1.5, 2.5))

base + scale_x_continuous(limits = c(0, 4))

由于更改坐标轴范围是非常常见的,因此 ggplot2 提供了语法糖:xlim()
, ylim()
, lims()


base + lims(x = c(0,4),y = c(4,0))

坐标轴范围一般比指定的稍大一点,以确保数据不会出现在图的边缘。scale*()
中的expand=c(0,0)
参数可以使得坐标轴范围恰好等于指定边界。
breaks
接收一个向量作为集合,规定显示轴须和标签的刻度
如果不希望显示任何轴须,可以规定 breaks=NULL
minor_breaks
ggplot 默认的图形中含有网格线,除了显示轴须处会生成网格线,两个轴须之间也会生成一条次要网格线。
minor_breaks
参数可以规定生成次要网格线的位置。如果不希望显示次要网格线,可以规定 minor_breaks=NULL
labels
labels
设置要显示的文本标签
# breaks最常见用途是替换默认的刻度
data(Salaries, package = "car")
ggplot(data = Salaries, aes(x = rank, y = salary, fill = sex)) +
geom_boxplot() +
scale_x_discrete(
breaks = c("AsstProf", "AssocProf", "Prof"),
labels = c(
"Assistant\nProfessor",
"Associate\nProfessor",
"Full\nProfessor"
)
) +
scale_y_continuous(
breaks = c(50000, 100000, 150000, 200000),
labels = c("$50K", "$100K", "$150K", "$200K")
) +
labs(title = "Faculty Salary by Rank and Sex", x = "", y = "")

还可以将labels设置为 NULL,这样可以不显示刻度标签,对于地图或不适合展示数值的图表来说,这种方式是非常有用的。
ggplot(mpg, aes(displ, hwy)) +
geom_point() +
scale_x_continuous(breaks = NULL, labels = NULL) +
scale_y_continuous(breaks = NULL, labels = NULL)

date_breaks
和date_labels
日期型和日期时间型 scale 的两个参数
date_labels
接受一个格式说明,说明的形式与 parse_datetime() 函数中的相同
date_breaks
(示例中没有出现)接收类似“2 weeks”或“1 month”这样的字符串,每隔这么长时间标识一个刻度
# 使用 breaks 的另一种情况:数据点相对较少,又想要强调观测的确切位置
# 例如,以下图形展示了每位美国总统任期的开始时间和结束时间:
presidential %>%
mutate(id = 33 + row_number()) %>%
ggplot(aes(start, id)) +
geom_point() +
geom_segment(aes(xend = end, yend = id)) + # geom_segment()绘制箭头
scale_x_date(
name = NULL,
breaks = presidential$start,
date_labels = "'%y"
)

trans
对 scale 进行函数变换,可选值均为字符串,常用的包括 exp, log, log10, logit, pow10, probit, reciprocal, sqrt 等。
其中最常用的一些,有专门的 scale 函数(语法糖),如 scale_x_log10()
, scale_x_sqrt()
, scale_x_reverse()
ggplot(diamonds, aes(carat, price)) +
geom_bin2d()

ggplot(diamonds, aes(carat, price)) +
geom_bin2d() +
scale_x_log10() +
scale_y_log10()

color and fill scale
将变量映射为颜色时,默认以一种非常均匀的方式在色环上选择颜色;如果不喜欢,可以设置颜色 scale 进行替换
discrete scale
可以设置为某套调色板,用RColorBrewer::display.brewer.all()
可查看所有的调色板
scale_color_brewer()
和scale_color_grey()
对应 color 属性
scale_fill_brewer()
和scale_fill_grey()
对应 fill 属性
# 常用的一种配色方式是使用ColorBrewer标度。
# 以下的两幅图非常相似
# 但右边图中(Set1调色板)的红色和绿色的对比更加强烈
# 即使患有红绿色盲症的人也可以区别出来
p1 <- ggplot(mpg, aes(displ, hwy)) +
geom_point(aes(color = drv))
p2 <- ggplot(mpg, aes(displ, hwy)) +
geom_point(aes(color = drv)) +
scale_color_brewer(palette = "Set1")
grid.arrange(p1, p2, ncol = 2)

# 如果只有很少几种颜色,可以再添加一种形状映射
# 虽然有些冗余,但这样可以确保图表在黑白方式下也可以为人所理解
ggplot(mpg, aes(displ, hwy)) +
geom_point(aes(color = drv, shape = drv)) +
scale_color_brewer(palette = "Set1")

continuous scale
连续渐变色,有几种函数(单色、双色、三色):
如果想区分位于平均值以上和以下的点,可以使用scale_color_gradient2()
函数。
另一个可以选用的函数是由viridis包提供的scale_color_viridis()
,它是对ColorBrewer分类标度的一种连续模拟。以下是来自于 viridis 使用指南中的一个示例:
df <- tibble(
x = rnorm(10000),
y = rnorm(10000)
)
p1 <- ggplot(df, aes(x, y)) +
geom_hex() +
coord_fixed()
p2 <- ggplot(df, aes(x, y)) +
geom_hex() +
viridis::scale_fill_viridis() +
coord_fixed()
grid.arrange(p1, p2, ncol = 2)

手动指定颜色
通过scale_color_manual()
,可以自己指定颜色
presidential %>%
mutate(id = 33 + row_number()) %>%
ggplot(aes(start, id, color = party)) +
geom_point() +
geom_segment(aes(xend = end, yend = id)) +
scale_colour_manual(values = c(Republican = "red", Democratic = "blue"))

坐标系
交换 x、y 轴 coord_flip()
当想要绘制水平箱线图时,这非常有用。它也非常适合变量长标签的使用,否则在x轴上不重叠地安排好它们是非常困难的。
ggplot(mpg, mapping = aes(x = class, y = hwy)) +
geom_boxplot()

ggplot(mpg, mapping = aes(x = class, y = hwy)) +
geom_boxplot() +
coord_flip()

为地图设置合适的纵横比 coord_quickmap()
nz <- map_data("nz")
ggplot(nz, aes(long, lat, group = group)) +
geom_polygon(fill = "white", color = "black")

ggplot(nz, aes(long, lat, group = group)) +
geom_polygon(fill = "white", color = "black") +
coord_quickmap()

极坐标系 coord_polar()
bar <- ggplot(data = diamonds) +
geom_bar(aes(x = cut, fill = cut),
show.legend = FALSE, width = 1
) +
theme(aspect.ratio = 1) +
labs(x = NULL, y = NULL)
bar + coord_flip()


coord_cartesian()
:设置坐标轴显示的范围
三种方法:
# 比较两种方法
mpg %>%
filter(displ >= 5, displ <= 7, hwy >= 10, hwy <= 30) %>%
ggplot(aes(displ, hwy)) +
geom_point(aes(color = class)) +
geom_smooth() # 数据取子集使拟合曲线的置信区间变得很宽

ggplot(mpg, mapping = aes(displ, hwy)) +
geom_point(aes(color = class)) +
geom_smooth() +
coord_cartesian(xlim = c(5, 7), ylim = c(10, 30))

# 在两张图形中使用相同的scale
suv <- mpg %>% filter(class == "suv")
compact <- mpg %>% filter(class == "compact")
range_displ <- range(mpg$displ)
range_hwy <- range(mpg$hwy)
# color使用全集的scale,保证颜色的一致性
col_scale <- scale_color_discrete(limits = unique(mpg$drv))
ggplot(suv, aes(displ, hwy, color = drv)) +
geom_point() +
col_scale +
coord_cartesian(xlim = range_displ, ylim = range_hwy)

ggplot(compact, aes(displ, hwy, color = drv)) +
geom_point() +
col_scale +
coord_cartesian(xlim = range_displ, ylim = range_hwy)

分面模式
分面模式(faceting)把几幅图拼接在一起,特别适合比较分类变量。
# 刻面图
data(singer, package = "lattice")
ggplot(data = singer, aes(x = height)) +
geom_histogram() +
facet_wrap(~voice.part, ncol = 4) # voice.part变量共有8个值,因列数为4,行数自动为2。先行后列排列

# 分组+刻面图+散点图
p <- ggplot(
Salaries,
aes(x = yrs.since.phd, y = salary, color = rank, shape = rank)
) +
geom_point() +
facet_grid(. ~ sex)
p

p <- ggplot(
Salaries,
aes(x = yrs.since.phd, y = salary, color = rank, shape = rank)
) +
geom_point() +
facet_grid(sex ~ .)
p

# 分组+刻面+密度图
data(singer, package = "lattice")
p <- ggplot(data = singer, aes(x = height, fill = voice.part)) +
geom_density() +
facet_grid(voice.part ~ .)
ggplotly(p) %>%
saveWidget("./Figures/facet-density.html",
selfcontained = F,
libdir = "lib"
)
p

---
title: "ggplot2-1"
subtitle: '内容架构'
author: "Humoon"
date: "`r Sys.Date()`"
output:
  html_document:
    code_download: yes
    css: ../css/style.css
    fig_caption: yes
    theme: united
    highlight: haddock
    number_sections: no
    toc: yes
    toc_depth: 4
    toc_float:
      collapsed: yes
      smooth_scroll: yes
documentclass: ctexart
classoption: hyperref,
---

```{r setup, include = FALSE}
source("../Rmarkdown-template/Rmarkdown_config.R")

## global options ===================================
knitr::opts_chunk$set(
  width = config$width,
  fig.width = config$fig.width,
  fig.asp = config$fig.asp,
  out.width = config$out.width,
  fig.align = config$fig.align,
  fig.path = config$fig.path,
  fig.show = config$fig.show,
  warn = config$warn,
  warning = config$warning,
  message = config$message,
  echo = config$echo, 
  eval = config$eval, 
  tidy = config$tidy, 
  comment = config$comment, 
  collapse = config$collapse, 
  cache = config$cache,
  cache.comments = config$cache.comments,
  autodep = config$autodep
)

## use necessary packages ==============================
library(tidyverse)
library(data.table)
library(magrittr)
library(plotly)
library(htmlwidgets)

pacman::p_load(
  lubridate,
  ggthemes,
  gridExtra, # 拼接 ggplot2 图像的包
  showtext,
  car, 
  readxl, 
  reshape2, 
  RColorBrewer
)

## plotting =============================================

# 包含图的代码块需要fig.showtext = TRUE选项
showtext_auto(enable = TRUE)
```

<a href="../pdf/cheatsheet-ggplot.pdf">*ggplot2 cheatsheet.pdf*</a>

<object data="../pdf/cheatsheet-ggplot.pdf" type="application/pdf" width="100%" height="100%"></object>

## 图形分层语法

<img src="http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-graphic-grammar.png" alt="20220323-graphic-grammar" style="zoom: 50%;" />

图形语法（grammar of graphic, gg）：将任何图形精确地描述为以下要素的组合，使绘图过程模块化


- 图形架构
  - 数据集 (data)
  - 从变量到坐标轴的映射 (mapping)
  - 几何图层 (geom)
  - 统计变换 (stat)
  - 位置调整 (position)
  - 比例尺 (scale)
  - 坐标系模式 (coordinate system)
  - 分面模式 (facet)
- 图形美化
  - 绘图区外部的标签 (labs)
  - 绘图区内部的文本标签和说明 (geom_label, geom_text)
  - 参考线、箭头和方框
  - 注释 (annotations)
  - 图例 (guides)
  - 主题 (theme)
  - 颜色


按照上述模板，可以使用代码构建能够想象到的任何图形

### qplot()

quickplot 语法糖 `qplot(x = cty, y = hwy, data = mpg, geom = "point")`

### last_plot()

return the last plot


## 绑定数据集

`ggplot(data=NULL, mapping=aes(), ...,environment=parent.frame())` 

ggplot()创建了一个坐标系，可以通过 geom_function 函数向其中添加需要的各种图层。
```{r}
# aes()定义了如何将数据中的变量映射为图形属性
# 本例中，将mtcars中的wt变量映射为x轴，将mpg变量映射为y轴
p <- mtcars %>%
  ggplot(aes(x = wt, y = mpg)) +
  geom_point(pch = 17, color = "blue", size = 2) +
  geom_smooth(
    method = "lm",
    se = FALSE,
    color = "red",
    linetype = 2
  ) +
  labs(
    title = "Automobile",
    x = "Weight",
    y = "Miles Per Gallon"
  )

ggplotly(p) %>%
  saveWidget("./Figures/Automobile.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```

## 几何图层

### 常用几何图层

下表列出了比较常见的几何函数，以及经常使用的选项。
![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-几何图层函数.png)

#### 基本图形

![graphical-primitives](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/202106/graphical-primitives.png)

#### 辅助线

![line-segments](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/202106/line-segments.png)

#### 单变量

![one-variable](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/202106/one-variable.png)

```{r}
# 直方图
data(singer, package = "lattice")

p <- ggplot(singer, aes(x = height)) +
  geom_histogram()
# geom_histgrom()函数在y变量没有指定时默认对x轴变量统计频数

ggplotly(p) %>%
  saveWidget("./Figures/Histogram.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```

#### 双变量

![two-variables](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/202106/two-variables.png)

```{r}
# 箱线图
p <- ggplot(singer, aes(x = voice.part, y = height)) +
  geom_boxplot()

ggplotly(p) %>%
  saveWidget("./Figures/Boxplot.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```

#### 三变量

![three-variables](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/202106/three-variables.png)

### 几何图层的参数

![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-几何函数的选项_1.png)
![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-几何函数的选项_2.png)

```{r}
data(car::Salaries)
p <- ggplot(Salaries, aes(x = rank, y = salary)) +
  geom_boxplot(
    fill = "cornflowerblue", # fill为填充色，color为外框色
    color = "black"
  ) +
  geom_point(position = "jitter", color = "blue", alpha = .5) + # jitter将重叠数据打散，alpha表示透明度
  geom_rug(side = "l", color = "black") # rug为轴须图，左侧，黑色

ggplotly(p) %>%
  saveWidget("./Figures/Boxplot2.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```


### 拟合曲线

![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-geom_smooth.png)

```{r, fig.show='asis'}
data(Salaries, package = "car")

# 默认拟合和线性拟合
p1 <- ggplot(data = Salaries, aes(x = yrs.since.phd, y = salary)) +
  geom_point() +
  geom_smooth()
p2 <- ggplot(data = Salaries, aes(x = yrs.since.phd, y = salary)) +
  geom_point() +
  geom_smooth(method = lm)
grid.arrange(p1, p2, ncol = 2)

# 按性别拟合二次多项式线性回归
p3 <- ggplot(
  data = Salaries,
  aes(
    x = yrs.since.phd, y = salary,
    linetype = sex, shape = sex, color = sex
  )
) +
  geom_smooth(method = lm, formula = y ~ poly(x, 2), se = FALSE, size = 1) +
  geom_point(size = 1)

ggplotly(p3) %>%
  saveWidget("./Figures/smooth.html",
    selfcontained = F,
    libdir = "lib"
  )

p3
```

### 多个几何图层的叠加

**当几何图层组合形成新类型的图时，ggplot2包的真正力量就会得到展现：实现多图层的叠加。**

此时不宜转换为 plotly 对象，显示会出错。

```{r}
data(singer, package = "lattice")
ggplot(singer, aes(x = voice.part, y = height)) +
  geom_violin(fill = "lightblue") +
  geom_boxplot(fill = "lightgreen", width = .2)
```

## 映射

ggplot() 和几何图层函数的 mapping 参数 `aes()` 用以定义从变量到图形属性（表示数据信息的可视化属性）的映射。

要注意，图形属性不仅包括数据点的大小、形状和颜色等，数据点的x轴位置和y轴位置本身也是图形属性。

### 全局与局部映射

如果将一组映射传递给ggplot()函数。这些映射会作为全局映射应用到图中的每个几何图层中；如果将映射放在几何图层函数中，则会成为局部映射，会扩展或覆盖全局映射，仅对该图层有效。这样一来，我们就可以在不同的图层中显示不同的图形属性。

```{r}
# x和y的映射是全局的，两个几何图层共享之
p <- ggplot(data = mpg, mapping = aes(x = displ, y = hwy)) +
  # color的映射是局部的，仅对这一句有效
  geom_point(mapping = aes(color = class)) +
  geom_smooth()

ggplotly(p) %>%
  saveWidget("./Figures/smooth1.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```

### 全局与局部数据

甚至可以为不同的图层指定不同的数据。
```{r}
p <- ggplot(data = mpg, mapping = aes(x = displ, y = hwy)) +
  geom_point(mapping = aes(color = class)) +
  # geom_smooth()中的局部数据参数覆盖了ggplot()中的全局数据参数
  geom_smooth(data = filter(mpg, class == "subcompact"), se = FALSE)

ggplotly(p) %>%
  saveWidget("./Figures/smooth2.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```

### 映射与分组

几何图层函数的mapping参数/aes()函数是一个分配分组变量的自然的地方。最基本的分组语法是将分组变量映射为图形的group属性，即`aes(group = variable)`，也可以将分组变量映射为其他更具视觉效果的图形属性(图中对象的可视化属性)。

在函数aes()中将图形属性名称和变量名称关联起来后，ggplot2会自动为每个变量值分配唯一的图形属性水平，这个过程称为scale变换。ggplot2还会添加一个图例，以表示图形属性水平和变量值之间的对应关系。

```{r}
data(Salaries, package = "car")

# 在aes()中用rank分组，将rank映射为图形的fill（填充色）属性
p <- ggplot(data = Salaries, aes(x = salary, fill = rank)) +
  geom_density(alpha = .3)

ggplotly(p) %>%
  saveWidget("./Figures/group1.html",
    selfcontained = F,
    libdir = "lib"
  )

p

# 根据sex和rank分组，共分为6组
p <- ggplot(
  Salaries,
  aes(
    x = yrs.since.phd, y = salary,
    color = rank, shape = sex
  )
) +
  geom_point()

ggplotly(p) %>%
  saveWidget("./Figures/group2.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```


## 统计变换：ggplot2的绘图原理

很多图形绘制的是数据集的原数据，比如散点图；另外一些图形则可以绘制那些计算出的新数据，比如条形图。

```{r}
ggplot(data = diamonds) +
  geom_bar(mapping = aes(x = cut))
```


**绘图时用来计算新数据的算法称为stat（statistical transformation，统计变换）。**通过查看stat参数的默认值，你可以知道几何图层函数使用了哪种统计变换。

```{}
geom_bar(
  mapping = NULL, data = NULL, 
  stat = "count", position = "stack", ..., 
  width = NULL, binwidth = NULL, na.rm = FALSE, show.legend = NA, inherit.aes = TRUE
)
```

`geom_bar`中stat参数的默认值是count，这说明`geom_bar()`使用`stat_count()`函数进行统计变换（`stat_count()`在文档中与`geom_bar()`位于同一页）。想要找出由统计变换计算出的变量，可以查看帮助文件中的 Computed variables 节，它告诉我们`stat_count()`会计算出两个新变量：count和prop

通常来说，几何图层函数和统计变换函数可以互换使用。可以这样做的原因是，每个几何图层函数都有一个默认统计变换，每个统计变换函数都有一个默认几何图层。例如，可以使用`stat_count()`替换`geom_bar()`来重新生成前面那张图。

```{r}
ggplot(data = diamonds) +
  stat_count(mapping = aes(x = cut))
```

显式使用统计变换函数的3个原因如下。

### 覆盖默认的统计变换
```{r}
demo <- tribble(
  ~a, ~b,
  "bar_1", 20,
  "bar_2", 30,
  "bar_3", 40
)

# 将geom_bar()函数的统计变换从默认的'count'改为'identity'，这样就可以将条形的高度映射为y轴变量的初始值。
ggplot(data = demo) +
  geom_bar(mapping = aes(x = a, y = b), stat = "identity")
```

### 覆盖从统计变换生成的变量到图形属性的默认映射
```{r}
# 显示一张表示比例（而不是计数）的条形图。
ggplot(data = diamonds) +
  geom_bar(mapping = aes(x = cut, y = ..prop.., group = 1))
```

### 在代码中强调统计变换
可以使用stat_summary()函数将人们的注意力吸引到你计算出的那些摘要统计量上。stat_summary()函数为x的每个唯一值计算y值的摘要统计。
```{r}
ggplot(data = diamonds) +
  stat_summary(mapping = aes(x = cut, y = depth), fun.ymin = min, fun.ymax = max, fun.y = median)
```

ggplot2提供了20多个统计变换以供你使用。每个统计变换都是一个函数，因此你可以按照通用方式获得帮助，例如?stat_bin。如果想要查看全部的统计变换，可以使用ggplot2速查表。

## 位置调整

position参数|含义
-------|-----
identity|不调整位置
dodge|并列放置，如簇状条形图
stack|堆叠放置
fill|堆叠且显示比例
jitter|加入随机扰动防止图形重合


```{r}
# position='identity',将每个对象直接显示在图中，原地不动，不调整位置。
ggplot(diamonds, aes(x = cut, fill = clarity)) + # 没有映射y轴，geom_bar()默认计数
  geom_bar(position = "identity")

ggplot(diamonds, aes(x = cut, color = clarity)) +
  geom_bar(fill = NA, position = "identity")
```

```{r}
# position="fill"，堆叠显示比例(计数后求比例)
ggplot(diamonds) +
  geom_bar(aes(cut, fill = clarity), position = "fill")
```

```{r}
# position="dodge"，并列显示
ggplot(diamonds) +
  geom_bar(aes(cut, fill = clarity), position = "dodge")
```

```{r}
# position="stack"，堆叠显示
ggplot(diamonds) +
  geom_bar(aes(cut, fill = clarity), position = "stack")
```

```{r, fig.show='asis'}
# position="jitter"，添加随机扰动，防止散点重叠
ggplot(data = mpg) +
  geom_point(aes(displ, hwy))

ggplot(data = mpg) +
  geom_point(aes(displ, hwy), position = "jitter")

# 或用函数geom_jitter()实现
ggplot(data = mpg, aes(x = displ, y = hwy)) +
  geom_point() +
  geom_jitter()
```

## Scale 比例尺

![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-scale.png)

### scale 的命名模式和用途

输入以下代码时：
```{r, eval=FALSE}
ggplot(mpg, aes(displ, hwy)) +
  geom_point(aes(color = class))
```

ggplot2 会自动在后台为代码添加默认 scale

```{r, eval=FALSE}
ggplot(mpg, aes(displ, hwy)) +
  geom_point(aes(color = class)) +
  scale_x_continuous() +
  scale_y_continuous() +
  scale_color_discrete()
```

scale 的命名模式：scale_图形属性_类型。scale 的常用类型有连续型、离散型、日期时间型或日期型。

基于以下两种原因，需要使用非默认 scale：

1. 你或许要对默认 scale 的一些参数进行调整。例如，当想要修改坐标轴刻度或图例中的项目标签时，就需要进行这些调整。
2. 你或许想要整体替换默认 scale，从而使用一种完全不同的算法。因为你对数据更加了解，所以使用与默认方式不同的 scale 通常能达到更好的效果。

### `scale*()`函数族

#### 最常用

- `scale_*_continuous()`
- `scale_*_discrete()`
- `scale_*_identity()`
- `scale_*_manual()`

#### 日期时间

- `scale_*_date()`
- `scale_*_datetime()`

### `scale*()`的参数

#### `name`

定义坐标轴名称，取值为`NULL`时不显示

#### `limits`

接收一个向量，取其两端作为一个范围。仅当数据的坐标在这个范围内时，才会在图中显示。

**本质上相当于对数据进行了筛选，取了子集**，此外的数据会变成 NA

```{r}
df <- data.frame(x = 1:3, y = 1:3)
base <- ggplot(df, aes(x, y)) +
  geom_point(size = 4)
base
base + scale_x_continuous(limits = c(1.5, 2.5))
base + scale_x_continuous(limits = c(0, 4))
```

由于更改坐标轴范围是非常常见的，因此 ggplot2 提供了语法糖：`xlim()`, `ylim()`, `lims()`

```{r}
base + xlim(0,4)
base + xlim(4,0)
base + lims(x = c(0,4),y = c(4,0))
```

坐标轴范围一般比指定的稍大一点，以确保数据不会出现在图的边缘。`scale*()`中的`expand=c(0,0)`参数可以使得坐标轴范围恰好等于指定边界。

#### `breaks`

接收一个向量作为集合，规定显示轴须和标签的刻度

如果不希望显示任何轴须，可以规定 `breaks=NULL`

#### `minor_breaks`

ggplot 默认的图形中含有网格线，除了显示轴须处会生成网格线，两个轴须之间也会生成一条次要网格线。

`minor_breaks`参数可以规定生成次要网格线的位置。如果不希望显示次要网格线，可以规定 `minor_breaks=NULL`

#### `labels`

`labels` 设置要显示的文本标签

```{r}
# breaks最常见用途是替换默认的刻度
data(Salaries, package = "car")
ggplot(data = Salaries, aes(x = rank, y = salary, fill = sex)) +
  geom_boxplot() +
  scale_x_discrete(
    breaks = c("AsstProf", "AssocProf", "Prof"),
    labels = c(
      "Assistant\nProfessor",
      "Associate\nProfessor",
      "Full\nProfessor"
    )
  ) +
  scale_y_continuous(
    breaks = c(50000, 100000, 150000, 200000),
    labels = c("$50K", "$100K", "$150K", "$200K")
  ) +
  labs(title = "Faculty Salary by Rank and Sex", x = "", y = "")
```

还可以将labels设置为 NULL，这样可以不显示刻度标签，对于地图或不适合展示数值的图表来说，这种方式是非常有用的。

```{r}
ggplot(mpg, aes(displ, hwy)) +
  geom_point() +
  scale_x_continuous(breaks = NULL, labels = NULL) +
  scale_y_continuous(breaks = NULL, labels = NULL)
```

#### `date_breaks`和`date_labels`

日期型和日期时间型 scale 的两个参数 

- `date_labels` 接受一个格式说明，说明的形式与 parse_datetime() 函数中的相同   
- `date_breaks`（示例中没有出现）接收类似“2 weeks”或“1 month”这样的字符串，每隔这么长时间标识一个刻度

```{r}
# 使用 breaks 的另一种情况：数据点相对较少，又想要强调观测的确切位置
# 例如，以下图形展示了每位美国总统任期的开始时间和结束时间：
presidential %>%
  mutate(id = 33 + row_number()) %>%
  ggplot(aes(start, id)) +
  geom_point() +
  geom_segment(aes(xend = end, yend = id)) + # geom_segment()绘制箭头
  scale_x_date(
    name = NULL,
    breaks = presidential$start,
    date_labels = "'%y"
  )
```

#### `trans`

对 scale 进行函数变换，可选值均为字符串，常用的包括 exp, log, log10, logit, pow10, probit, reciprocal, sqrt 等。

其中最常用的一些，有专门的 scale 函数（语法糖），如 `scale_x_log10()`, `scale_x_sqrt()`, `scale_x_reverse()`

```{r}
ggplot(diamonds, aes(carat, price)) +
  geom_bin2d()

ggplot(diamonds, aes(carat, price)) +
  geom_bin2d() +
  scale_x_log10() +
  scale_y_log10()
```

### shape and size scale

![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-shape-size-scale.png)

### color and fill scale

将变量映射为颜色时，默认以一种非常均匀的方式在色环上选择颜色；如果不喜欢，可以设置颜色 scale 进行替换

#### discrete scale

可以设置为某套调色板，用`RColorBrewer::display.brewer.all()`可查看所有的调色板

![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-color-scale-discrete.png)

`scale_color_brewer()`和`scale_color_grey()`对应 color 属性

`scale_fill_brewer()`和`scale_fill_grey()`对应 fill 属性

```{r}
# 常用的一种配色方式是使用ColorBrewer标度。
# 以下的两幅图非常相似
# 但右边图中（Set1调色板）的红色和绿色的对比更加强烈
# 即使患有红绿色盲症的人也可以区别出来
p1 <- ggplot(mpg, aes(displ, hwy)) +
  geom_point(aes(color = drv))

p2 <- ggplot(mpg, aes(displ, hwy)) +
  geom_point(aes(color = drv)) +
  scale_color_brewer(palette = "Set1")

grid.arrange(p1, p2, ncol = 2)
```

```{r}
# 如果只有很少几种颜色，可以再添加一种形状映射
# 虽然有些冗余，但这样可以确保图表在黑白方式下也可以为人所理解
ggplot(mpg, aes(displ, hwy)) +
  geom_point(aes(color = drv, shape = drv)) +
  scale_color_brewer(palette = "Set1")
```

#### continuous scale

连续渐变色，有几种函数（单色、双色、三色）：

![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-color-scale-continuous.png)

如果想区分位于平均值以上和以下的点，可以使用`scale_color_gradient2()`函数。

另一个可以选用的函数是由viridis包提供的`scale_color_viridis()`，它是对ColorBrewer分类标度的一种连续模拟。以下是来自于 viridis 使用指南中的一个示例：


```{r}
df <- tibble(
  x = rnorm(10000),
  y = rnorm(10000)
)

p1 <- ggplot(df, aes(x, y)) +
  geom_hex() +
  coord_fixed()

p2 <- ggplot(df, aes(x, y)) +
  geom_hex() +
  viridis::scale_fill_viridis() +
  coord_fixed()

grid.arrange(p1, p2, ncol = 2)
```

#### 手动指定颜色

通过`scale_color_manual()`，可以自己指定颜色

```{r}
presidential %>%
  mutate(id = 33 + row_number()) %>%
  ggplot(aes(start, id, color = party)) +
  geom_point() +
  geom_segment(aes(xend = end, yend = id)) +
  scale_colour_manual(values = c(Republican = "red", Democratic = "blue"))
```


## 坐标系

### 交换 x、y 轴 `coord_flip()`
当想要绘制水平箱线图时，这非常有用。它也非常适合变量长标签的使用，否则在x轴上不重叠地安排好它们是非常困难的。
```{r, fig.show='asis'}
ggplot(mpg, mapping = aes(x = class, y = hwy)) +
  geom_boxplot()

ggplot(mpg, mapping = aes(x = class, y = hwy)) +
  geom_boxplot() +
  coord_flip()
```

### 为地图设置合适的纵横比 `coord_quickmap()` 

```{r, fig.show='asis'}
nz <- map_data("nz")
ggplot(nz, aes(long, lat, group = group)) +
  geom_polygon(fill = "white", color = "black")
ggplot(nz, aes(long, lat, group = group)) +
  geom_polygon(fill = "white", color = "black") +
  coord_quickmap()
```

### 极坐标系 coord_polar() 
```{r, fig.show='asis'}
bar <- ggplot(data = diamonds) +
  geom_bar(aes(x = cut, fill = cut),
    show.legend = FALSE, width = 1
  ) +
  theme(aspect.ratio = 1) +
  labs(x = NULL, y = NULL)

bar + coord_flip()
bar + coord_polar()
```

### `coord_cartesian()`：设置坐标轴显示的范围

三种方法：

* 调整绘图所用数据（取子集）

* 设置 scale 范围（缩小 scale 范围的效果基本等同于对数据取子集，scale 范围之外的数据会变成 NA）

* **在coord_cartesian()函数中设置 xlim 和 ylim 参数值（推荐）**，这是真正的缩放**显示**范围

```{r}
# 比较两种方法
mpg %>%
  filter(displ >= 5, displ <= 7, hwy >= 10, hwy <= 30) %>%
  ggplot(aes(displ, hwy)) +
  geom_point(aes(color = class)) +
  geom_smooth() # 数据取子集使拟合曲线的置信区间变得很宽

ggplot(mpg, mapping = aes(displ, hwy)) +
  geom_point(aes(color = class)) +
  geom_smooth() +
  coord_cartesian(xlim = c(5, 7), ylim = c(10, 30))
```


```{r}
# 在两张图形中使用相同的scale
suv <- mpg %>% filter(class == "suv")
compact <- mpg %>% filter(class == "compact")

range_displ <- range(mpg$displ)
range_hwy <- range(mpg$hwy)
# color使用全集的scale，保证颜色的一致性
col_scale <- scale_color_discrete(limits = unique(mpg$drv))

ggplot(suv, aes(displ, hwy, color = drv)) +
  geom_point() +
  col_scale +
  coord_cartesian(xlim = range_displ, ylim = range_hwy)

ggplot(compact, aes(displ, hwy, color = drv)) +
  geom_point() +
  col_scale +
  coord_cartesian(xlim = range_displ, ylim = range_hwy)
```

## 分面模式

分面模式(faceting)把几幅图拼接在一起，特别适合比较分类变量。

![a placeholder of a picture](http://humoon-image-hosting-service.oss-cn-beijing.aliyuncs.com/img/typora/2022/20220323-刻面图函数.png)

```{r}
# 刻面图
data(singer, package = "lattice")

ggplot(data = singer, aes(x = height)) +
  geom_histogram() +
  facet_wrap(~voice.part, ncol = 4) # voice.part变量共有8个值，因列数为4，行数自动为2。先行后列排列
```

```{r}
# 分组+刻面图+散点图
p <- ggplot(
  Salaries,
  aes(x = yrs.since.phd, y = salary, color = rank, shape = rank)
) +
  geom_point() +
  facet_grid(. ~ sex)
p

p <- ggplot(
  Salaries,
  aes(x = yrs.since.phd, y = salary, color = rank, shape = rank)
) +
  geom_point() +
  facet_grid(sex ~ .)
p

# 分组+刻面+密度图
data(singer, package = "lattice")
p <- ggplot(data = singer, aes(x = height, fill = voice.part)) +
  geom_density() +
  facet_grid(voice.part ~ .)

ggplotly(p) %>%
  saveWidget("./Figures/facet-density.html",
    selfcontained = F,
    libdir = "lib"
  )

p
```
