DataVisualization_USE_R_ECHARTS
📺 数据可视化基础（使用R和ECharts）
本文会从 R 和 ECharts 两个方面来展开数据可视化技术的一些使用方法。
[TOC]
📊 1. 数据可视化概述
数据可视化概念
- 狭义概念：指的是数据用统计图表方式呈现
- 广义概念：是数据可视化、信息可视化以及科学可视化等等多个领域的统称
数据可视化分类
- 数据可视化
- 信息可视化
- 科学可视化
⭐*** 数据可视化作用***
- 数据表达：通过计算机图形图形技术来更加友好地展示数据信息，以方便人们理解和分析数据。
- 数据操作：以计算提供的界面、接口和协议等条件为基础完成人与数据的交互需求。
- 数据分析：通过计算机获得多维、多源、异构和海量数据所隐含信息的核心手段，它是数据存储、数据转换、数据计算和数据可视化的综合应用。
⭐ 数据可视化的工具
R、ECharts、D3…Python、pyecharts、Excel…- 第三方商业工具：
FineBI、FineReport…
学习数据可视化需要了解（具备）什么？
对色彩的感知：了解原色、间色、复色等，并且了解色彩的视觉感受（心理感受），当然也就是了解即可，色彩这种东西天赋更重要一些，知道三原色是啥就行。
- 原色：红、黄、蓝。
- 间色：可存在多个间色，当原色之间
1:1匹配时则为：橙、绿、紫。 - 复色：可存在多个复色（一定包含三原色），两个间色或一种原色和其对应的间色（黄 + 紫、蓝 + 橙）相混合得到复色。
- 色彩感受：轻重感、冷暖感、前后感、收缩感 …
数据可视化的基本流程
- 数据采集
- 数据处理
- 可视化映射
- 用户感知
数据可视化的一些设计技巧
设计原则：注重用户的视觉体验
设计技巧：
① （颜色）建立视觉层次，用醒目的颜色突出数据，淡化其他元素
② （内容）高亮显示重点内容
③ （跨度）提升不同区域的色阶跨度
④ （场景）借助场景来表现数据指标
⑤ （转换）将抽象的不易理解的数字转换为容易被人感知的图表
⑥ （简洁）尽量让图表简洁
数据可视化的图表类型
在统计图表中每一种类型的图表中都可包含不同的数据可视化图形，如：柱状图、饼图、气泡图、热力图、趋势图、直方图、雷达图、色块图、漏斗图、和弦图、仪表盘、面积图、折线图、密度图 以及 K线图等。
🎫 2. R - R语言快速入门
参考文献：数据科学中的 R 语言 (bookdown.org)
2.1 R 语言概述
R语言是为数学研究工作者设计的一种数学编程语言，主要用于统计分析、绘图、数据挖掘数据可视化。
目前主流的数据分析语言有 R、Python、Matlab 等。
R |
Python |
Matlab |
|
|---|---|---|---|
| 语言学习难易程度 | 入门难度低 | 入门难度一般 | 入门难度一般 |
| 使用场景 | 数据分析、数据挖掘、机器学习、数据可视化等。 | 数据分析、机器学习、矩阵运算、科学数据可视化、数字图像处理、Web应用、网络爬虫、系统运维等。 | 矩阵计算、数值分析、科学数据可视化、机器学习、符号计算、数字图像处理、数字信号处理、仿真模拟等。 |
| 第三方支持 | 拥有大量的 Packages，能够调用 C、C++、Fortran、Java等其他程序语言。 |
拥有大量的第三方库，能够简便地调用C、C++、Fortran、Java等其他程序语言。 |
拥有大量专业的工具箱，在新版本中加入了对C、C++，Java的支持。 |
| 流行领域 | 工业界 ≈ 学术界 | 工业界 ＞ 学术界 | 工业界 ≤ 学术界 |
| 软件成本 | 开源免费 | 开源免费 | 商业收费 |
2.2 R 语言中包的概念和使用
软件包和软件库
软件包：
R中的包是R函数、数据、预编译代码以一种定义完善的格式组成的集合。软件库：软件库指的是一个包含了若干个包的目录。你可以拥有一个系统级别的软件库，也可以为每个用户单独设立一个软件库。
R自带了一系列默认包（包括base、datasets、utils、grDevices、graphics、stats以及methods），它们提供了种类繁多的默认函数和数据集。base：包含基础的R函数database：自带的数据包，里面的数据结构包括矩阵、向量、数据框等utils：工具函数包grDevices：基础绘图工具包，提供调整图形颜色和字体的功能，可用于配色graphics：基础绘图工具包stats：统计函数的扩展包methods：R对象和其他编程工具定义方法和类比的扩展包
包的相关操作
- 查看包的安装路径：
.libPaths()
1
2> .libPaths()
[1] "D:/R/R-4.3.3/library"- 查看已安装的包：
library() - 查看编译环境下已载入的包的列表：
search()
1
2
3> search()
[1] ".GlobalEnv" "tools:rstudio" "package:stats" "package:graphics" "package:grDevices"
[6] "package:utils" "package:datasets" "package:methods" "Autoloads" "package:base"下载包：
通过 CRAN (The Comprehensive R Archive Network) 下载。CRAN 是 R 语言的综合档案网络。用户可以从 CRAN 上下载并安装各种第三方包来扩展 R 语言的功能。
① 指定包名进行安装：
install.packages("PackageName")② 使用图形界面安装：
install.packages()使用
RStudio安装
包的卸载：
remove.packages("PackageName")包的载入：
library("PackageName")
1
2
3
4
5> library("XML")
> search() # 可以看到 "package:XML" 已经被加载进来了
[1] ".GlobalEnv" "package:XML" "tools:rstudio" "package:stats" "package:graphics"
[6] "package:grDevices" "package:utils" "package:datasets" "package:methods" "Autoloads"
[11] "package:base"- 包的取消载入：
detach("package:PackageName", unload = True)
1
2
3
4> detach("package:XML", unload = TRUE)
> search()
[1] ".GlobalEnv" "tools:rstudio" "package:stats" "package:graphics" "package:grDevices"
[6] "package:utils" "package:datasets" "package:methods" "Autoloads" "package:base"- 查看包的安装路径：
2.3 R 语言的工作空间的概念和使用
- 概念：工作空间(Work Space) 就是当前 R 的工作环境，它储存着所有用户定义的对象（向量、矩阵、函数、数据框、列表）。在一个 R 会话结束时，用户可以将当前工作空间保存到一个镜像中，并在下次启动 R 时自动载入它。
- 设置工作目录：
setwd()或使用RStudio可视化窗口进行设置（Session → Set Working Directory） - 获取工作目录：
getwd()
2.4 R 语言的六大原子数据类型
- 数字型(Numeric)
- 逻辑型(Logical)
- 整型(Integer)
- 字符型(Character)
- 复合型(Complex)
- 原子型(Raw)
对于不同原子数据类型可以按照如下方式定义：
1 | > # 数值型(Numeric) |
2.5 R 语言变量使用
- 定义变量并赋值：使用
<-、=、->
1 | > var1 = 12.5 # 定义 var1, 并赋值为 12.5 |
变量的打印：
print()或cat()print()和cat()都可以向控制台输出文字，区别在于print()有返回值，其会返回输出的内容，无法使用转义字符，当使用转义字符时，会直接输出转义字符；而cat()没有返回值，可以使用转义字符。
1 | > varX = "Hello World" |
- 变量的查看：
ls()
1 | > ls() # 输出所有变量 |
- 变量的删除：
rm()
1 | > rm("var1", "var2") # 删除 "var1" 和 "var2" |
[⭐] 变量的数据类型判别和转换
- 判别：
is.XXX()，返回True/False
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> # 数值型(Numeric)
> varNumeric = 12.5
> varNumeric
[1] 12.5
> is.numeric(varNumeric)
[1] TRUE
> is.logical(varNumeric)
[1] FALSE
> is.integer(varNumeric)
[1] FALSE
> is.character(varNumeric)
[1] FALSE
> is.complex(varNumeric)
[1] FALSE
> is.raw(varNumeric)
[1] FALSE
> # 逻辑型(Logical)
> varLogical = TRUE
> varLogical
[1] TRUE
> is.numeric(varLogical)
[1] FALSE
> is.logical(varLogical)
[1] TRUE
> is.integer(varLogical)
[1] FALSE
> is.character(varLogical)
[1] FALSE
> is.complex(varLogical)
[1] FALSE
> is.raw(varLogical)
[1] FALSE- 转换：
as.XXX()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16> # 变量类型转换
> varNumToChar <- as.character(varNumeric)
> varNumToChar
[1] "12.5"
> is.numeric(varNumToChar)
[1] FALSE
> is.logical(varNumToChar)
[1] FALSE
> is.integer(varNumToChar)
[1] FALSE
> is.character(varNumToChar)
[1] TRUE <-------------------- 可以看到已经转换成了字符型
> is.complex(varNumToChar)
[1] FALSE
> is.raw(varNumToChar)
[1] FALSE- 判别：
[⭐] 变量的数据类型查看
mode()：查看数据元素类型typeof()：查看数据元素类型，基本等同于mode()，比mode()更为详细class()：查看数据结构，vector、matrix、array、dataframe、list
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
38
39
40
41
42> # 查看变量类型
> mode(varNumeric)
[1] "numeric"
> typeof(varNumeric)
[1] "double"
> class(varNumeric)
[1] "numeric"
> mode(varLogical)
[1] "logical"
> typeof(varLogical)
[1] "logical"
> class(varLogical)
[1] "logical"
> mode(varInteger)
[1] "numeric"
> typeof(varInteger)
[1] "integer"
> class(varInteger)
[1] "integer"
> mode(varCharacter)
[1] "character"
> typeof(varCharacter)
[1] "character"
> class(varCharacter)
[1] "character"
> mode(varComplex)
[1] "complex"
> typeof(varComplex)
[1] "complex"
> class(varComplex)
[1] "complex"
> mode(varRaw)
[1] "raw"
> typeof(varRaw)
[1] "raw"
> class(varRaw)
[1] "raw"[⭐] 字符串的应用
- R语言中的文本，或者原子数据类型中
Character。在 R 语言中的单引号' '或 双引号" "中写入的任何值都被视为字符串。在字符串构造中应用的规则：- 在字符串的开头和结尾的引号应该是两个双引号或两个单引号。它们不能被混合。
- 双引号可以插入到以单引号开头和结尾的字符串中
- 单引号可以插入以双引号开头和结尾的字符串。
- 双引号不能插入以双引号开头和结尾的字符串。
- 单引号不能插入以单引号开头和结尾的字符串。
- R语言中的文本，或者原子数据类型中
2.7 R 语言的运算符的概念和使用
运算符的概念
算数运算符
+加、-减、*乘、/除%%整除取余%/%整除
1
2
3
4
5
6
7
8
9
10
11> # 相除
> 6 / 4
[1] 1.5
> # %% 整除取余
> 6 %% 4
[1] 2
> # %/% 整除
> 6 %/% 4
[1] 1关系运算符
<小于、>大于、=等于<=小于等于、>=大于等于!=不等于
逻辑运算符
&|&&||
&&和||为值逻辑，&和|为位逻辑
说人话就是，&&和||是讲两个操作目的值做逻辑运算，无论操作对象是向量还是标量，返回值都是一个逻辑值，（NOW）&&和||运算符只接受长度为 1 的逻辑值作为参数；而&和|是讲两个对象按位比较，其返回值的长度与对象是标量还是向量有关。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19> # 逻辑运算符
> v <- c(3, 1, TRUE, 2+3i)
> t <- c(4, 1, FALSE, 2+3i)
> print(v&t)
[1] TRUE TRUE FALSE TRUE
> v <- c(3, 0, TRUE, 2+2i)
> t <- c(1, 3, TRUE, 2+3i)
> print(v && t)
Error in v && t : 'length = 4' in coercion to 'logical(1)'
> TRUE && TRUE
[1] TRUE
> TRUE && FALSE
[1] FALSE
> FALSE && TRUE
[1] FALSE
> FALSE && FALSE
[1] FALSE赋值运算符
<-=-><<-->>
<−或=或<<−运算符： 称为左赋值。1
2
3
4
5
6
7
8
9
10
11
12
13
14> # 赋值运算符
> # 左赋值
> v1 <- c(3,1,TRUE,2+3i)
> v2 <<- c(3,1,TRUE,2+3i)
> v3 = c(3,1,TRUE,2+3i)
> print(v1)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v2)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v3)
[1] 3+0i 1+0i 1+0i 2+3i->或->>运算符：称为右赋值。1
2
3
4
5
6
7
8
9> # 右赋值
> c(3,1,TRUE,2+3i) -> v1
> c(3,1,TRUE,2+3i) ->> v2
> print(v1)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v2)
[1] 3+0i 1+0i 1+0i 2+3i其他运算符
:为向量创建数字序列。
1
2
3> v <- 2:8
> print(v)
[1] 2 3 4 5 6 7 8%in%用于确定元素是否属于向量。
1
2
3
4
5
6
7> v1 <- 8
> v2 <- 12
> t <- 1:10
> print(v1 %in% t) # 8 是否再 1~10 中
[1] TRUE
> print(v2 %in% t) # 12 是否再 1~10 中
[1] FALSE%*%用于求两个向量的内积，也称为点乘
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> M = matrix( c(2,6,5,1,10,4), nrow = 2, ncol = 3, byrow = TRUE)
# M
2, 6, 5
1, 10, 4
# t(M)
2, 1
6, 10
5, 4
# M %*% t(M)
2*2 + 6*6 + 5*5, 1*2 + 10* 6 + 4*5
2*1 + 10*6 + 4*5, 1*1 + 10*10 + 4*4
> t = M %*% t(M)
> print(t)
[,1] [,2]
[1,] 65 82
[2,] 82 117
> #===================================================================#
> M = matrix(c(2, 6, 5, 1, 10, 4), nrow = 2,ncol = 3, byrow = TRUE)
> N = matrix(c(1, 2, 3, 4, 5, 6), nrow = 3, ncol = 2, byrow = TRUE)
> t = M %*% N
> print(t)
[,1] [,2]
[1,] 45 58
[2,] 51 66
2.8 R 语言的六大数据对象
R 语言有六种基本的数据结构（数据对象）：向量vector、列表list、矩阵matrix、数组array、数据框data.frame 和 因子factor 类型。
2.8.1 向量 vector
概念：向量是最基本的 R 语言数据对象，向量的元素支持六种原子数据类型，即逻辑，整数，双精度，复合，字符和原型。
特征：一个向量的所有元素都必须属于相同的类型。如果不是，R将强制执行类型转换。
创建向量：
c()、seq()、rep()c()这里的c就是 combine 或 concatenate 的意思，它要求元素之间用英文的逗号分隔，且元素的数据类型是统一的，比如都是数值。c()函数把一组数据聚合到了一起，就构成了一个向量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19> # 创建向量
> # 使用 c()
> low <- c(1, 2, 3)
> high <- c(4, 5, 6)
> sequence <- c(low, high)
> sequence
[1] 1 2 3 4 5 6
> # 给变量命名
> x <- c('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)
> x
a b c d
5 6 7 8
> x <- c(5, 6, 7, 8)
> names(x) <- c('a', 'b', 'c', 'd')
> x
a b c d
5 6 7 8如果向量元素很多，用手工一个个去输入，那就成了体力活，不现实。在特定情况下，有几种偷懒方法:
seq()函数可以生成等差数列，from参数指定数列的起始值，to参数指定数列的终止值，by参数指定数值的间距。
1
2
3
4> # 使用 seq()
> s1 <- seq(from = 0, to = 10, by = 0.5)
> s1
[1] 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0 9.5 10.0rep()是 repeat（重复）的意思，可以用于产生重复出现的数字序列：x用于重复的向量，times参数可以指定要生成的个数，each参数可以指定每个元素重复的次数。
1
2
3
4
5
6
7
8
9
10
11> s2 <- rep(x = c(0, 1), times = 3)
> s2
[1] 0 1 0 1 0 1
> s3 <- rep(x = c(0, 1), each = 3)
> s3
[1] 0 0 0 1 1 1
> s4 <- rep(x = c(0, 1), time = 3, each = 3)
> s4
[1] 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1向量元素访问
1
2
3
4
5> # 定义一个向量
> t <- seq(from = 10, to = 20, by = 0.4)
> t
[1] 10.0 10.4 10.8 11.2 11.6 12.0 12.4 12.8 13.2 13.6 14.0 14.4 14.8 15.2 15.6 16.0 16.4 16.8 17.2 17.6 18.0 18.4 18.8
[24] 19.2 19.6 20.0t[index]：使用这种方式进行访问，index默认从 1 开始。
1
2
3
4
5> # 方式 1
> t[1]
[1] 10
> t[2]
[1] 10.4t[Logic Index]：TRUE表示读取，FALSE为不读取。
1
2
3
4
5
6
7> # 方式 2
> t[c(TRUE, TRUE, FALSE, TRUE)]
[1] 10.0 10.4 11.2 11.6 12.0 12.8 13.2 13.6 14.4 14.8 15.2 16.0 16.4 16.8 17.6 18.0 18.4 19.2 19.6 20.0
> t[c(1, 0, 2, 0, 3, 0, 1)]
[1] 10.0 10.4 10.8 10.0
> t[c(6, 0, 0, 0, 1, 0, 1)]
[1] 12 10 10t[name]：通过name进行访问。
1
2
3
4
5
6
7
8
9
10> # 方式 3
> names(t) <- c("v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10")
> t
v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA>
10.0 10.4 10.8 11.2 11.6 12.0 12.4 12.8 13.2 13.6 14.0 14.4 14.8 15.2 15.6 16.0 16.4 16.8 17.2 17.6 18.0 18.4 18.8
<NA> <NA> <NA>
19.2 19.6 20.0
> t["v1"]
v1
10t[-index]：索引为负数，则会删除该位置的元素。
1
2
3
4
5
6
7
8
9
10
11
12
13
14> # 方式 4
> t
v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA>
10.0 10.4 10.8 11.2 11.6 12.0 12.4 12.8 13.2 13.6 14.0 14.4 14.8 15.2 15.6 16.0 16.4 16.8 17.2 17.6 18.0 18.4 18.8
<NA> <NA> <NA>
19.2 19.6 20.0
> t[-1]
v2 v3 v4 v5 v6 v7 v8 v9 v10 <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA>
10.4 10.8 11.2 11.6 12.0 12.4 12.8 13.2 13.6 14.0 14.4 14.8 15.2 15.6 16.0 16.4 16.8 17.2 17.6 18.0 18.4 18.8 19.2
<NA> <NA>
19.6 20.0
> t[c(-2: -4)]
v1 v5 v6 v7 v8 v9 v10 <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA>
10.0 11.6 12.0 12.4 12.8 13.2 13.6 14.0 14.4 14.8 15.2 15.6 16.0 16.4 16.8 17.2 17.6 18.0 18.4 18.8 19.2 19.6 20.0向量元素运算
- 长度相同的向量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17> # 长度不同的向量
> v3 = c(10, 20)
> v4 = c(10, 20, 10, 20, 10, 20)
> add.result = v1 + v3
> add.result = v1 + v4
> # 向量的运算
> # 长度相同的向量
> v1 = c(1, 2, 3, 4, 5, 6)
> v2 = c(6, 7, 8, 9, 10, 11)
> add.result = v1 + v2
> sub.result = v1 - v2
> add.result
[1] 7 9 11 13 15 17
> sub.result
[1] -5 -5 -5 -5 -5 -5长度不同的向量
如果长度不同，较短的向量会循环补充到与较长的向量长度相同，在进行运算。但是前提是：长的向量的长度必须为短的向量的整数倍。
1
2
3
4
5
6
7
8
9> # 长度不同的向量
> v3 = c(10, 20)
> v4 = c(10, 20, 10, 20, 10, 20)
> add.result = v1 + v3
> add.result
[1] 11 22 13 24 15 26
> add.result = v1 + v4
> add.result
[1] 11 22 13 24 15 26
2.8.2 列表 list
- 概念：列表是 R 语言的对象集合，可以用来保存不同类型的数据，可以是数字、字符串、向量、另一个列表等，当然还可以包含矩阵和函数。R语言创建列表使用
list()函数。 - 列表的创建
1 | > # 列表的创建 |
- 列表元素的重命名(
names函数)
1 | > # 列表的重命名 |
列表元素的访问——增删改查
- 查
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
38
39
40
41> # (查)
> # 根据索引访问
> list_data[0]
named list()
> list_data[3]
$ListElem
$ListElem[[1]]
[1] "Happy"
$ListElem[[2]]
[1] 1314
> # 根据元素名称访问
> list_data$HelloString
[1] "Hello" "World"
> list_data$ListElem
[[1]]
[1] "Happy"
[[2]]
[1] 1314
> list_data[4]<-"Hello"
> list_data
$HelloString
[1] "Hello" "World"
$MatrixElem
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
$ListElem
$ListElem[[1]]
[1] "Happy"
$ListElem[[2]]
[1] 1314
[[4]]
[1] "Hello"- 增
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21> # (增)
> list_data[4]<-"Hello"
> list_data
$HelloString
[1] "Hello" "World"
$MatrixElem
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
$ListElem
$ListElem[[1]]
[1] "Happy"
$ListElem[[2]]
[1] 1314
[[4]]
[1] "Hello"- 改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20> # (改)
> list_data[4] <- 12
> list_data
$HelloString
[1] "Hello" "World"
$MatrixElem
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
$ListElem
$ListElem[[1]]
[1] "Happy"
$ListElem[[2]]
[1] 1314
[[4]]
[1] 12- 删
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17> # (删)
> list_data[4] <- NULL
> list_data
$HelloString
[1] "Hello" "World"
$MatrixElem
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
$ListElem
$ListElem[[1]]
[1] "Happy"
$ListElem[[2]]
[1] 1314列表的合并：使用
c可以将多个列表合并为一个列表
1 | > # 合并列表 |
- 列表和向量之间的转换
1 | > # 列表转换为向量 |
2.8.3 矩阵 matrix
- 概念：
R语言为线性代数的研究提供了矩阵类型，这种数据结构很类似于其它语言中的二维数组。 - 矩阵的创建
1 | > # 矩阵的创建 |
- 矩阵转置
1 | > # 矩阵转置 t() |
- 矩阵元素访问
1 | > m4[c("row1", "row4"), c("col1", "col3")] |
- 矩阵相关操作
1 | > # 矩阵元素操作 |
2.8.4 数组 array
- 概念：数组也是
R语言的对象，R语言可以创建一维或多维数组。 - 数组的创建
1 | > # 创建数组 |
- 数组元素访问
1 | > # 数组访问 |
2.8.5 数据框 data.frame
概念：数据框
DataFrame可以理解成我们常说的表格，数据框是R语言的数据结构，是特殊的二维列表。数据框每一列都有一个唯一的列名，长度都是相等的，同一列的数据类型需要一致，不同列的数据类型可以不一样。数据框的特点：- 列名称应为非空。
- 行名称应该是唯一的。
- 存储在数据框中的数据可以是数字，字符型等。
- 每个列应包含相同数量的数据项。
数据框的创建
1 | > # 数据框 |
- 查看数据框结构
1 | > # 查看数据框结构(Structure) |
- 数据框访问、新增列
1 | > # 提取数据框中的列 |
- 数据框合并
1 | # 数据框合并 |
- 数据框筛选
1 | > # 数据框筛选 |
2.8.6 因子 factor
- 概念：因子用于存储不同类别的数据类型，例如：人的性别有 男 和 女 两个类别，年龄来分可以有 未成年人 和 成年人 。
- 因子创建
1 | > # 因子创建 |
2.9 R 语言判断、控制、循环
2.9.1 判断语句
if语句
1 | > # 控制语句 |
if...else...语句 和if...else if...语句
1 | > x <- 10L |
switch语句
1 | > # switch语句 |
2.9.2 循环语句
repeat + if(...) { break }
1 | > # 循环语句 |
while()
1 | > |
for()
1 | > # for 循环 |
2.9.3 控制语句
break
1 | > # break语句 |
next
1 | > # next语句 |
2.10 R 语言函数
概念：函数是一组一起执行一个任务的语句。
2.10.1 内置函数：
print()cat()list()array()
2.10.2 自定义函数
R 语言函数通常由以下几个部分组成：
- 函数名
- 参数
- 函数体
- 返回值
具体格式如下：
1 | function_name <- function(arg_1, arg_2, ...) { |
下面由一些例子来演示：
只演示几种情况，其他情况（如有参函数、有默认参数值的函数都和其他语言类似）。
1 | > # R 语言函数 |
2.11 R语言读写数据文件、数据库
2.11.1 读写数据文件
| 读写类型 | 读写方法 | 备注 |
|---|---|---|
| 从键盘输入数据 | edit() |
使用方法见下方代码 |
读写 .txt 格式文件 |
读 read.table 写 write.table |
- |
读写 .csv 格式文件 |
读 read.csv()写 write.csv() |
- |
读写 .xlsx 格式文件 |
读 read.xlsx()写 write.xlsx() |
使用之前需要下载并加载 R语言的 xlsx 包 |
- 从键盘中输入数据
1 | > # 从键盘读入数据, edit() 和 fix() 可以可视化的输入数据 |
- 读写
.txt格式文件
1 | stutxt <- read.table("/path/to/file.txt", header=TRUE, sep=",") |
- 读写
.csv格式文件
1 | csvfile <- read.csv("/path/to/file.csv") |
- 读写
.xlsx格式文件
1 | install.packages("xlsx") |
2.11.2 读写数据库
非重点，有需要可自行了解
2.12 R 语言基础绘图
2.12.1 R 语言绘制barplot() 条形图、堆叠条形图
1 | ####### 1. 绘制条形图 barplot() |
2.12.2 R 语言绘制 饼图、3D饼图绘制
1 | ####### 2. 绘制饼图 |
2.12.3 R 语言散点图、折线图、散点矩阵图
1 | ####### 3. 绘制散点图、折线图、散点矩阵图 |
2.12.4 R 语言绘制直方图
1 |
2.12.5 R 语言绘制核密度图
1 |
2.12.6 R 语言绘制箱线图
1 |
2.12.7 R 语言小提琴图
1 | ####### 7. 小提琴图 |
2.13 R 绘图常用拓展库 ggplot2 绘图
简介：ggplot2是一款强大的图形可视化R包，其作图方式易于理解，且生成的图形精美，定制化程度也很高，是 R 语言中很流行的可视化工具之一。
ggplot2 包是 R 的一个作图用的扩展包，它实现了 图形的语法，将一个作图任务分成若干子任务，只需要完成各个子任务就可以完成作图。在绘制常用图形时，只需要两个步骤：
将图形所展现的数据输入到
ggplot()函数中调用某个
geom_xxx()函数，指定图形类型，如散点图、面积图、曲线图、盒型图等。geom_xxx()提供了各种基本图形，如geom_blank()不绘制图形、geom_point()每个观测为一个散点、geom_hline(), geom_vline(), geom_abline()绘制线等。
ggplot2 的作图的一般步骤为：
- 准备数据：一般为数据框，且一般为长表，即每个观测时间占一行，每个观测变量占一列
- 输入数据：将数据输入到
ggplot()函数中，并指定参与作图的每个变量分别映射到哪些图形特性 - 选择图形类型：选择一个合适的图形类型，函数名以
geom_开头，如geom_point()表示散点图。 - 设定标题和图例位置等，如
labs()，仍用加号连接。
模板如下：
1 | p <- ggplot(data = <输入数据框>, |
2.13.1 ggplot2 绘制散点图
1 | ####### ggplot2 绘图 |
2.13.2 ggplot2 绘制面积图
1 | # 面积图 |
2.13.3 ggplot2 绘制堆叠面积图
1 |
🎫 3. ECharts - ECharts的简单使用
3.1 ECharts 简介
- ECharts 概念：一个基于 JavaScript 的开源可视化图表库（别人写好了
.js，我直接使用），可以流畅的运行在 PC 和移动设备上，兼容当前绝大部分浏览器（IE 9/10/11，Chrome，Firefox，Safari 等），底层依赖矢量图形库 *ZRender*，提供直观，交互丰富，可高度个性化定制的数据可视化图表。 - 官网：ECharts
- 特性：ECharts Feature
- 获取
Apache ECharts通过
GitHub获取- Apache/ECharts 项目的 release 页面可以找到各个版本的链接。点击下载页面下方
Assets中的Source code，解压后即为包含完整 ECharts 功能的文件。 echarts-5.4.0/echarts-5.4.0/dist/echarts.common.js与echarts-5.4.0/echarts-5.4.0/dist/echarts.common.min.js：体积适中，常用版，支持常见的图表和组件echarts-5.4.0/echarts-5.4.0/dist/echarts.js与echarts-5.4.0/echarts-5.4.0/dist/echarts.min.js：体积最大，完整版，包含所有支持的图表和组件。echarts-5.4.0/echarts-5.4.0/dist/echarts.simple.js与echarts-5.4.0/echarts-5.4.0/dist/echarts.simple.min.js：体积较小，精简版，包含最常用的图表和组件。
- Apache/ECharts 项目的 release 页面可以找到各个版本的链接。点击下载页面下方
从
npm获取npm install echarts
从
CDN获取<script src="https://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
在线定制
3.2 第一个 ECharts 程序
1 |
|
3.3 ECharts 绘图流程
- 新建一个 HTML 文件，并在网页头部
<head> ... </head>部分引入在线的ECharts类库或者本地已经下载好的类库。
1 | <head> |
- 在网页创建一个容器，为
ECharts准备一个具备大小（宽高）的DOM（Document Object Model, 文件对象模型 ) 。
1 | <body> |
- 当页面加载时，获取
DOM，并初始化ECharts对象
1 | <script> |
- 指定配置项信息
1 | <script> |
- 用刚指定的配置项和数据显示图表
1 | <script> |
3.4 ECharts 常用配置项详解
完成简单柱状图的绘制需要包含的组件包括：
xAxis：X 轴组件yAxis：Y 轴组件series：系列组件（我更喜欢称其序列组件）
完善图形补充组件：
title：标题组件legend：图例组件tooltip：提示框组件toolbox：工具栏配置项datazoom：数据区域缩放
3.5 ECharts 样式设置
3.5.1 ECharts 颜色主题(Theme)
- 内置颜色主题（
dark、light）
1 |
|
自定义颜色主题
- 通过
JavaScript定义颜色主题
1
- 通过
Json + jQuery定义颜色主题
1
- 通过
3.5.2 ECharts 调色盘
- 全局调色盘
1 |
|
- 系列调色盘
1 |
|
- 系列调色盘与全局调色盘同时出现：
- 当系列调色盘与全局调色盘同时出现时，图表使用系列调色盘中配置的颜色。
3.5.3 ECharts 直接样式设置
直接样式设置（itemStyle、lineStyle、areaStyle、label、…）
1 |
|
3.5.4 ECharts 视觉映射(Visual Map)
1 |
|
3.6 ECharts 中的事件和行为
概念：在 Apache ECharts 的图表中用户的操作将会触发相应的事件。开发者可以监听这些事件，然后通过回调函数做相应的处理。
事件分类： 在 ECharts 中事件分为两种类型，一种是用户鼠标操作点击，或者 hover 图表的图形时触发的事件，还有一种是用户在使用可以交互的组件后触发的行为事件，例如在切换图例开关时触发的 legendselectchanged 事件（这里需要注意切换图例开关是不会触发事件的），数据区域缩放时触发的 datazoom 事件等等。
3.7 ECharts 实例
3.7.1 柱状图
绘制简单的柱状图，一些配置项：
xAxis/yAxistype：category类目轴；value数值轴；time时间；log对数轴data：设置类目的数据（数组）
seriestype：设置系列的类型（设置绘制什么图表）name：设置系列名称，会用在tooltip和legend中data：系列中的数据内容数组，定义当前这个系列中每个柱子的高度label：设置图形上的文本标签（把数值显示在每个柱子上)itemStyle：设置图形样式showBackground：设置是否显示背景色（默认不显示）backgroundStyle：设置背景色
3.7.2 折线图、堆叠折线图
1 |
|
3.7.3 面积图和堆叠面积图
3.7.4 雷达图
1 |
|
