发表更新大数据技术 / 数据可视化1 小时读完 (大约11518个字)

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()

      • 手动安装：https://cran.r-project.org/web/packages/XML/index.html

      • 使用 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
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
> # 数值型(Numeric)
> varNumeric = 12.5
> varNumeric
[1] 12.5

> # 逻辑型(Logical)
> varLogical = TRUE
> varLogical
[1] TRUE

> # 整型(Integer)
> varInteger = 25L
> varInteger
[1] 25

> # 字符型(Character)
> varCharacter = "Hello World"
> varCharacter
[1] "Hello World"

> # 复合型(Complex)
> varComplex = 2 + 3i
> varComplex
[1] 2+3i

> # 原子型(Raw)
> varRaw = charToRaw('Hello')
> varRaw
[1] 48 65 6c 6c 6f

2.5 R 语言变量使用

  • 定义变量并赋值：使用 <-、=、->
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> var1 = 12.5		# 定义 var1, 并赋值为 12.5
> print(var1)		# 输出 var1
[1] 12.5

> var2 <- 13		# 定义 var2, 并赋值为 13(由右向左)
> print(var2)		# 输出 var2
[1] 13

> 14 -> var3		# 定义 var3, 并赋值为 14(由左向右)
> print(var3)		# 输出 var3
[1] 14

> var2 -> var3
> print(var3)
[1] 13

  • 变量的打印：print() 或 cat()

    print() 和 cat() 都可以向控制台输出文字，区别在于 print() 有返回值，其会返回输出的内容，无法使用转义字符，当使用转义字符时，会直接输出转义字符；而 cat() 没有返回值，可以使用转义字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
> varX = "Hello World"
> varY = "Hello World\n"

> printX <- print(varX)
[1] "Hello World"
> catX   <- cat(varX, "\n")	# 如果不添加转义字符会无法换行
Hello World 

> printY <- print(varY)
[1] "Hello World\n"			# 使用 print() 直接将转义字符进行了输出
> catY   <- cat(varY)
Hello World					# 使用 cat() 没有将转义字符直接输出, 而是转化成了响应的格式, 如"换行"

> print(printX)				# print() 有返回值
[1] "Hello World"
> print(catX)				# cat() 没有返回值
NULL
  • 变量的查看：ls()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
> ls()						# 输出所有变量
 [1] "catX"     "catY"     "cyl.f"    "printX"   "printY"   "score"    "tempdens" "var1"     "var2"     "var3"
[11] "varX"     "varY"    

> ls(pattern = "var") 		# 模式匹配部分变量, 包含 "var" 的
[1] "var1" "var2" "var3" "varX" "varY"

> ls(pattern = "*")			# 模式匹配部分变量, 使用通配符
 [1] "catX"     "catY"     "cyl.f"    "printX"   "printY"   "score"    "tempdens" "var1"     "var2"     "var3"    
[11] "varX"     "varY"    

> ls(pattern = "2")			# 模式匹配部分变量, 包含 "2" 的
[1] "var2"

> ls(all.names = TRUE)		# 
 [1] ".Random.seed" "catX"         "catY"         "cyl.f"        "printX"       "printY"       "score"       
 [8] "tempdens"     "var1"         "var2"         "var3"         "varX"         "varY"
  • 变量的删除：rm()
1
2
3
4
5
6
7
8
> rm("var1", "var2")				# 删除 "var1" 和 "var2"

> rm(list = ls(pattern = "var"))	# 删除 匹配到 "var" 的变量, list 是一个可以指定的参数

> rmlist = ls(pattern = "X")
> rmlist
[1] "catX"   "printX"
> rm(list = rmlist)

  • [⭐] 变量的数据类型判别和转换

    • 判别：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 语言中的单引号' ' 或 双引号" " 中写入的任何值都被视为字符串。在字符串构造中应用的规则：
      • 在字符串的开头和结尾的引号应该是两个双引号或两个单引号。它们不能被混合。
      • 双引号可以插入到以单引号开头和结尾的字符串中
      • 单引号可以插入以双引号开头和结尾的字符串。
      • 双引号不能插入以双引号开头和结尾的字符串。
      • 单引号不能插入以单引号开头和结尾的字符串。

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.0
    • rep() 是 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.0
    • t[index]：使用这种方式进行访问，index 默认从 1 开始。
    1
    2
    3
    4
    5
    > # 方式 1
    > t[1]
    [1] 10
    > t[2]
    [1] 10.4
    • t[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 10
    • t[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 
    10
    • t[-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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> # 列表的创建
> list_data = list("Hello", "World", c(1, 10), TRUE, 51.23, 119L)
> list_data
[[1]]
[1] "Hello"

[[2]]
[1] "World"

[[3]]
[1]  1 10

[[4]]
[1] TRUE

[[5]]
[1] 51.23

[[6]]
[1] 119
  • 列表元素的重命名(names 函数)
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
> # 列表的重命名
> list_data <- list(c("Hello", "World"), matrix(c(1, 2, 3, 4, 5, 6), nrow=2), list("Happy", 1314L))
> list_data
[[1]]
[1] "Hello" "World"

[[2]]
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

[[3]]
[[3]][[1]]
[1] "Happy"

[[3]][[2]]
[1] 1314

> names(list_data) <- c("HelloString", "MatrixElem", "ListElem")
> 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

  • 列表元素的访问——增删改查

    • 查
    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
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
> # 合并列表
> list1 <- list(1, 2, 3)
> list2 <- list("A", "B", "C")
> class(list1)
[1] "list"
> class(list2)
[1] "list"
> merged.list <- c(list1, list2)
> merged.list
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] "A"

[[5]]
[1] "B"

[[6]]
[1] "C"
> class(merged.list)
[1] "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
> # 列表转换为向量
> list1 <- list(1 :  5)
> list2 <- list(10: 14)
> list3 <- list("hello", matrix(c(1, 2, 3, 4), nrow=2), 3)
> list1
[[1]]
[1] 1 2 3 4 5

> list2
[[1]]
[1] 10 11 12 13 14

> list3
[[1]]
[1] "hello"

[[2]]
     [,1] [,2]
[1,]    1    3
[2,]    2    4

[[3]]
[1] 3

> v1 <- unlist(list1)
> v2 <- unlist(list2)
> v3 <- unlist(list3)
> class(v1)
[1] "integer"
> class(v2)
[1] "integer"
> class(v3)
[1] "character"
> v3
[1] "hello" "1"     "2"     "3"     "4"     "3"
2.8.3 矩阵 matrix
  • 概念：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
38
39
40
41
42
43
44
45
46
> # 矩阵的创建
> m1 = matrix(data=c(3: 14))
> m1
      [,1]
 [1,]    3
 [2,]    4
 [3,]    5
 [4,]    6
 [5,]    7
 [6,]    8
 [7,]    9
 [8,]   10
 [9,]   11
[10,]   12
[11,]   13
[12,]   14
> m2 = matrix(data=c(3: 14), nrow=4)
> m2
     [,1] [,2] [,3]
[1,]    3    7   11
[2,]    4    8   12
[3,]    5    9   13
[4,]    6   10   14
> m2 = matrix(data=c(3: 14), ncol=4)
> m2
     [,1] [,2] [,3] [,4]
[1,]    3    6    9   12
[2,]    4    7   10   13
[3,]    5    8   11   14
> m3 <- matrix(data=c(3, 14), nrow=4, byrow=TRUE)		# 默认为 TRUE
> m3
     [,1]
[1,]    3
[2,]   14
[3,]    3
[4,]   14

> rownames <- c("row1", "row2", "row3", "row4") 
> colnames <- c("col1", "col2", "col3")
> m4 <- matrix(data=c(3: 14), nrow=4, byrow=TRUE, dimnames=list(rownames, colnames))
> m4
     col1 col2 col3
row1    3    4    5
row2    6    7    8
row3    9   10   11
row4   12   13   14
  • 矩阵转置
1
2
3
4
5
6
7
> # 矩阵转置 t()
> # R 语言矩阵提供了 t() 函数, 可以实现矩阵的行列转换
> t(m4)
     row1 row2 row3 row4
col1    3    6    9   12
col2    4    7   10   13
col3    5    8   11   14
  • 矩阵元素访问
1
2
3
4
> m4[c("row1", "row4"), c("col1", "col3")]
     col1 col3
row1    3    5
row4   12   14
  • 矩阵相关操作
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
43
44
45
46
47
48
49
50
51
52
53
54
> # 矩阵元素操作
> # 矩阵计算
> m1 <- matrix(data=c(3: 14), nrow=4)
> m1
     [,1] [,2] [,3]
[1,]    3    7   11
[2,]    4    8   12
[3,]    5    9   13
[4,]    6   10   14
> m2 <- matrix(data=c(1: 12), nrow=4)
> m2
     [,1] [,2] [,3]
[1,]    1    5    9
[2,]    2    6   10
[3,]    3    7   11
[4,]    4    8   12
> m1 + m2
     [,1] [,2] [,3]
[1,]    4   12   20
[2,]    6   14   22
[3,]    8   16   24
[4,]   10   18   26

> # 矩阵转换 
> # 矩阵 -> 向量
> is.matrix(m1)
[1] TRUE
> class(m1)
[1] "matrix" "array" 
> v1 <- as.vector(m1)
> v1
 [1]  3  4  5  6  7  8  9 10 11 12 13 14
> class(v1)
[1] "integer"

> # 矩阵组合
> # cbind() 把其自变量横向拼成一个大矩阵, 横向组合, 行数一致
> # rbind() 把其自变量纵向拼成一个大矩阵, 纵向组合, 列数一致
> v1 = c(1, 2, 3, 4, 5)
> v2 = c(6, 7, 8, 9,10)
> y1 = cbind(v1, v2)
> y2 = rbind(v1, v2)
> y1
     v1 v2
[1,]  1  6
[2,]  2  7
[3,]  3  8
[4,]  4  9
[5,]  5 10
> y2
   [,1] [,2] [,3] [,4] [,5]
v1    1    2    3    4    5
v2    6    7    8    9   10
>
2.8.4 数组 array
  • 概念：数组也是 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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
> # 创建数组
> # 一维数组
> v1 <- c(5, 9, 1)
> a1 <- array(v1)
> a1
[1] 5 9 1
> is.array(a1)
[1] TRUE
> a <- array(10: 15, dim=9)
> a
[1] 10 11 12 13 14 15 10 11 12
> a <- array(10: 15, dim=c(2))
> a
[1] 10 11
> 
> # 二维数组
> a <- array(10: 15, dim=c(2, 3))   # 10, 11, 12, 13, 14, 15
> a
     [,1] [,2] [,3]
[1,]   10   12   14
[2,]   11   13   15
> is.array(a)
[1] TRUE
> 
> # 三维数组
> a <- array(10: 15, dim=c(2, 3, 2))
> a
, , 1
     [,1] [,2] [,3]
[1,]   10   12   14
[2,]   11   13   15

, , 2
     [,1] [,2] [,3]
[1,]   10   12   14
[2,]   11   13   15

> column.names <- c("COL1", "COL2", "COL3")
> row.names <- c("ROW1", "ROW2", "ROW3")
> matrix.names <- c("Matrix1", "Matrix2")
> 
> vector1 <- c(5, 9, 3)
> vector2 <- c(10, 11, 12, 13, 14, 15)
> a <- array(c(vector1, vector2), dim=c(3, 3, 2), dimnames = list(row.names, column.names, matrix.names))
> a
, , 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   15
  • 数组元素访问
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
> # 数组访问
> a[1]    # 一维数组的访问
[1] 5
> a[1: 6] # 一维数组的访问——向量访问
[1]  5  9  3 10 11 12
> 
> dim2_a <- array(c(vector1, vector2), dim=c(3, 3))
> dim2_a
     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15
> dim2_a[1: 1]       # 二维数组的访问, 访问的必须是二维数组
[1] 5
> dim2_a[1: 2, 1: 2] # 二维数组的访问——矩阵访问
     [,1] [,2]
[1,]    5   10
[2,]    9   11
> 
> a[3, 3, 1]    # 三维数组
[1] 15
2.8.5 数据框 data.frame

  • 概念：数据框 DataFrame 可以理解成我们常说的表格，数据框是 R 语言的数据结构，是特殊的二维列表。数据框每一列都有一个唯一的列名，长度都是相等的，同一列的数据类型需要一致，不同列的数据类型可以不一样。数据框的特点：

    • 列名称应为非空。
    • 行名称应该是唯一的。
    • 存储在数据框中的数据可以是数字，字符型等。
    • 每个列应包含相同数量的数据项。

  • 数据框的创建

1
2
3
4
5
6
7
8
9
10
11
12
13
> # 数据框
> # 创建数据框对象
> df1 <- data.frame(
+   # tag = value
+   姓名 = c("张三", "李四", "王五"),
+   工号 = c("001", "002", "003"),
+   月薪 = c(1000, 2000, 3000)
+ )
> df1
  姓名 工号 月薪
1 张三  001 1000
2 李四  002 2000
3 王五  003 3000
  • 查看数据框结构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> # 查看数据框结构(Structure)
> str(df1)
'data.frame':	3 obs. of  3 variables:
 $ 姓名: chr  "张三" "李四" "王五"
 $ 工号: chr  "001" "002" "003"
 $ 月薪: num  1000 2000 3000
> # 查看数据框描述性统计量
> summary(df1)
     姓名               工号                月薪     
 Length:3           Length:3           Min.   :1000  
 Class :character   Class :character   1st Qu.:1500  
 Mode  :character   Mode  :character   Median :2000  
                                       Mean   :2000  
                                       3rd Qu.:2500  
                                       Max.   :3000
  • 数据框访问、新增列
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
> # 提取数据框中的列
> df1$姓名
[1] "张三" "李四" "王五"
> df2 <- data.frame(df1$姓名, df1$月薪)
> df2
  df1.姓名 df1.月薪
1     张三     1000
2     李四     2000
3     王五     3000
> 
> # 提取数据框中的行
> # 提取前两行
> result <- df1[1:2, ]
> result
  姓名 工号 月薪
1 张三  001 1000
2 李四  002 2000
> 
> # 提取前两行, 前两列
> result <- df1[1:2, 1:3]
> result
  姓名 工号 月薪
1 张三  001 1000
2 李四  002 2000
> 
> # 提取第1、3行, 第1、2列的数据
> result <- df1[c(1, 3), c(1, 2)]
> result
  姓名 工号
1 张三  001
3 王五  003
> 
> # 新增列
> df1$部门 <- c("运营", "技术", "运营")
> df1
  姓名 工号 月薪 部门
1 张三  001 1000 运营
2 李四  002 2000 技术
3 王五  003 3000 运营
  • 数据框合并
1
2
# 数据框合并
# cbind()/rbind()
  • 数据框筛选
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
> # 数据框筛选
> student <- data.frame(
+   sno = c(1, 2, 3),
+   sname = c("zhangsan", "lisi", "wangwu"),
+   sage = c(10, 12, 14)
+ )
> student
  sno    sname sage
1   1 zhangsan   10
2   2     lisi   12
3   3   wangwu   14
> 
> student[1]      # 第一个字段
  sno
1   1
2   2
3   3
> student[1, 2]   # 第一行, 第二列
[1] "zhangsan"
> student$sage>12 # FALSE FALSE TRUE
[1] FALSE FALSE  TRUE
> 
> # [...] 里面一个参数取字段, 两个参数取行列
> student[student$sage>11]          # 执行判断, 得到结果 c(FALSE, TRUE, TRUE)
     sname sage
1 zhangsan   10
2     lisi   12
3   wangwu   14
> student[c(FALSE, TRUE, TRUE)]     # 使用 c(FALSE, TRUE, TRUE) 进行运算
     sname sage
1 zhangsan   10
2     lisi   12
3   wangwu   14
> student[student$sage>11, ]        # 选择年龄大于 11 的, 并取所有字段
  sno  sname sage
2   2   lisi   12
3   3 wangwu   14
> student[c(FALSE, TRUE, TRUE), ]   # 选择年龄大于 11 的行, 并取所有字段
  sno  sname sage
2   2   lisi   12
3   3 wangwu   14
> student[student$sage>11, 2]       # 选择年龄大于 11 的, 并取第 2 个字段
[1] "lisi"   "wangwu"
> student[student$sage>11, c(1, 2)] # 选择年龄大于 11 的, 并取第 1、2 个字段 
  sno  sname
2   2   lisi
3   3 wangwu
> 
> subset(student, select = c("sname", "sage"))                        # 可以理解为: SELECT sname, sage FROM student;
     sname sage
1 zhangsan   10
2     lisi   12
3   wangwu   14
> subset(student, select = c("sname", "sage"), sage>11 & sno == 2)    # 可以理解问: SELECT sname, sage FROM student WHERE sage>11 AND sno=2;
  sname sage
2  lisi   12
2.8.6 因子 factor
  • 概念：因子用于存储不同类别的数据类型，例如：人的性别有 男 和 女 两个类别，年龄来分可以有 未成年人 和 成年人 。
  • 因子创建
1
2
3
4
5
6
7
8
9
10
11
12
> # 因子创建
> # 例 1:男 2:女
> x <- c(1, 2, 1, 2, 2, 1, 3)
> factor(x)
[1] 1 2 1 2 2 1 3
Levels: 1 2 3
> factor(x, levels = c(1, 2))
[1] 1    2    1    2    2    1    <NA>
Levels: 1 2
> factor(x, levels = c(1, 2), labels = c("男", "女"))
[1] 男   女   男   女   女   男   <NA>
Levels: 男 女

2.9 R 语言判断、控制、循环

2.9.1 判断语句
  • if 语句
1
2
3
4
5
6
7
8
9
10
11
> # 控制语句
> x <- TRUE
> if (x) {
+   print("x 为真")
+ }
[1] "x 为真"
> 
> if (is.logical(x)) {
+   print("x 是逻辑型数据")
+ }
[1] "x 是逻辑型数据"
  • if...else... 语句 和 if...else if... 语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
> x <- 10L
> if (is.logical(x)) {
+   print("x 是逻辑型数据")
+ } else if(is.numeric(x)) {
+   print("x 是数值型数据")
+ } else {
+   print("x 不是逻辑型数据, 也不是数值型数据")
+ }
[1] "x 是数值型数据"
> 
> y <- c("a", "b", "c", "e")
> if("e" %in% y) {
+   print("y 中包含 `e`")
+ } else if ("a" %in% y) {
+   print("y 中包含 `a`")
+ } else {
+   print("不存在")
+ }
[1] "y 中包含 `e`"
  • switch 语句
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
> # switch语句
> # x <- switch (object,
> #   case = action
> # )
> 
> # expression(object) 是一个常量表达式, 可以是整数或字符串
> # 如果是整数, 则返回对应 case 的位置值, 如果整数不在范围内则返回 NULL
> x <- switch (1,
+   "a",
+   "b",
+   "c",
+   "d"
+ )
> x
[1] "a"
> 
> x <- switch (1,
+   "a" = "a1",
+   "b" = "b1",
+   "c" = "c1",
+   "d" = "d1"
+ )
> x
[1] "a1"
> 
> # expression 如果是字符串, 则对应的是 case 中变量名对应的值, 没有匹配则没有返回值
> x <- switch ("c",
+   "a" = 1,
+   "b" = 2,
+   "c" = "cn"
+ )
> 
> x
[1] "cn"
2.9.2 循环语句
  • repeat + if(...) { break }
1
2
3
4
5
6
7
8
9
10
11
12
13
> # 循环语句
> # repeat + if(...) { break }
> v <- c("Google", "Micrsoft", "OpenAI", "LinkIn")
> cnt <- 3
> repeat {
+   print(v[cnt])
+   cnt <- cnt + 1
+   if(cnt > 6) { break; }
+ }
[1] "OpenAI"
[1] "LinkIn"
[1] NA
[1] NA
  • while()
1
2
3
4
5
6
7
8
9
10
11
> 
> # while 循环
> v <- c("Google", "Micrsoft", "OpenAI", "LinkIn")
> cnt <- 3
> while(cnt <= 5) {
+   print(v[cnt])
+   cnt <- cnt + 1
+ }
[1] "OpenAI"
[1] "LinkIn"
[1] NA
  • for()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
> # for 循环
> letters
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"
> LETTERS
 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z"
> LETTERS[1: 6]
[1] "A" "B" "C" "D" "E" "F"
> for (i in LETTERS[1: 6]) {
+   print(i)
+ }
[1] "A"
[1] "B"
[1] "C"
[1] "D"
[1] "E"
[1] "F"
2.9.3 控制语句
  • break
1
2
3
4
5
6
7
8
9
10
> # break语句
> for (i in LETTERS[1: 6]) {
+   if (i == "D") {
+     break;
+   }
+   print(i)
+ }
[1] "A"
[1] "B"
[1] "C"
  • next
1
2
3
4
5
6
7
8
9
10
11
12
> # next语句
> for (i in LETTERS[1: 6]) {
+   if (i == "D") {
+     next;
+   }
+   print(i)
+ }
[1] "A"
[1] "B"
[1] "C"
[1] "E"
[1] "F"

2.10 R 语言函数

概念：函数是一组一起执行一个任务的语句。

2.10.1 内置函数：
  • print()
  • cat()
  • list()
  • array()
2.10.2 自定义函数

R 语言函数通常由以下几个部分组成：

  • 函数名
  • 参数
  • 函数体
  • 返回值

具体格式如下：

1
2
3
4
5
function_name <- function(arg_1, arg_2, ...) {
    # 函数体
    # 执行的代码块
    return(output)	# 返回值
}

下面由一些例子来演示：

只演示几种情况，其他情况（如有参函数、有默认参数值的函数都和其他语言类似）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> # R 语言函数
> new.function <- function() {
+   # 函数体
+   for(i in 1: 6){
+     print(i^2)
+   }
+ }
> 
> new.function()
[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36

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. 从键盘中输入数据
1
2
3
4
5
6
7
8
9
10
11
> # 从键盘读入数据, edit() 和 fix() 可以可视化的输入数据
> mydata <- data.frame(age=numeric(0), gender=character(0), weight=numeric(0))
> mydata
[1] age    gender weight
<0 行> (或0-长度的row.names)
> edit(mydata)
  age gender weight
1  12      2    120
2  13      2     NA
> 
> fix(mydata)
  1. 读写 .txt 格式文件
1
2
3
4
5
stutxt <- read.table("/path/to/file.txt", header=TRUE, sep=",")
stutxt
class(stutxt)

write.table(stutxt, "/path/to/write.txt", sep=",")
  1. 读写 .csv 格式文件
1
2
3
4
csvfile <- read.csv("/path/to/file.csv")
csvfile

write.csv(csvfile, "/path/to/write.csv")
  1. 读写 .xlsx 格式文件
1
2
3
4
5
6
7
8
9
10
11
12
install.packages("xlsx")
library()
search()
library("x1sx")

student <- read.xlsx("/path/to/file.xlsx", sheetIndex=1, encoding = "UTF-8")
student

city<-read.xlsx("/path/to/file.xlsx", sheetName = "city",encoding = "UTF-8")
city

write.xlsx(city, "/path/to/write.xlsx", sheetName = "city")
2.11.2 读写数据库

非重点，有需要可自行了解

2.12 R 语言基础绘图

2.12.1 R 语言绘制barplot() 条形图、堆叠条形图
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
####### 1. 绘制条形图 barplot()
# 1.1 height: 高度, 通过这个参数可以指定要画多少个柱子, 以及每个柱子的高度, 其值有两种——向量、矩阵
# 1.1.1 向量 vector, 此时会根据向量的长度确定图中有多少个柱子, 向量中的每个值就是高度
barplot(height = 1: 5)

# 1.1.2 矩阵 matrix, 此时用于画堆积柱状图
data <- cbind(a = 1: 4, b = 1: 4)
data
class(data)
barplot(height = data)

# 1.2 width: 宽度, 控制每个柱子的宽度, 默认值为 1, 值得注意的是, 这个参数的值是可以循环使用的
barplot(height = 1: 5)
barplot(height = 1: 5, width=1)
barplot(height = 1: 5, width=c(1, 1, 1, 1, 1))
barplot(height = 1: 5, width=1: 5)

data <- cbind(a = 1: 4, b = 1:4)
barplot(height = data)
barplot(height = data, width=1)
barplot(height = data, width=1:2)

# 1.3 space: 间隔, 指定每个柱子左边的空白区域的宽度, 这个值为一个百分比, 默认值为 0.2
barplot(height=1: 5, space=1)
barplot(height=1: 5, space=5: 1)
barplot(height=data, space=1)
barplot(height=data, space=1: 2)

# 1.4 names.arg: 每个柱子下面的标记, 当 height 为 vector 时, 默认的标记为向量的 names 属性
barplot(height=1:3, names.arg=c("a","b","c"))
v <- 1:3
names(v) <- c("c" ,"b" ,"a")
v
barplot(height=v)

# 1.5 horiz: 逻辑值, 默认为 FALSE, 当值为 TRUE 时, 将 X 轴和 Y 轴转置
barplot(height=1:3, horiz = FALSE)
barplot(height=1:3, horiz = TRUE)
data

barplot(height=data, horiz= FALSE)
barplot(height=data, horiz = TRUE)

# 1.6 col: 柱子的填充色, 默认为灰色
# 1.7 border: 柱子边框的颜色, 默认为 black, 当 border为 NA时, 表示没有边框
# 1.8 main: 设置图形标题
c <- colors()
c
c[2: 5]

barplot(1: 4, col=c[2:5], border = NA, main="图形标题")

barplot(1: 4, col=rainbow(4))
barplot(1: 4, col=c("red", "green", "antiquewhite", "white"))
barplot(data, col=rainbow(4))

# 1.9 & 1.10 density 设置柱子用线条填充, density 控制线条的密度，angle 控制线条的角度
par(mfrow=c(1, 3))
par

barplot(rep(1, 4), density = 1, angle = 30, main = "density = 1")
barplot(rep(1, 4), density = 2, angle = 90, main = "density = 2")
barplot(rep(1, 4), density = 3, angle = 180, main = "density = 3")

# 1.11 axes: 逻辑值, 控制是否显示轴线(如 y 轴线)
barplot(data, axes = F)
barplot(data, axes = T)

# 1.12 axisnames: 控制是否显示柱子的标签
barplot(data, axisnames = F)
barplot(data, axisnames = T)


# 1.13 beside: 当输入参数为矩阵时, 默认是堆积柱状图, beside 默认值为 FALSE;
# beside = FALSE 时, 条形图的高度是矩阵的数值, 矩形条是水平堆叠的
# beside = TRUE 时, 条形图的高度是矩阵的数值, 矩形条是并列的
data
barplot(data, beside = F)
barplot(data, beside = T)

# 1.14 legend.text: 图例的文字说明
# 只有当 height 参数的值是 matrix 时, 才起作用
# 默认显示的是 matrix 的 rownames 属性
# 其值有两种指定形式:
# 第一种: 逻辑值, 是否需要显示图例, 默认为FALSE
par(mfrow=c(1, 1))
data
rownames(data) <- c("A1", "A2", "A3", "A4")
data
barplot(data, legend.text = TRUE)

# 第二种, 指定图例中的文字内容
# 相当于修改了 matrix 的 rownames 属性
barplot(data, legend.text = c("D", "E", "F", "G"))
2.12.2 R 语言绘制 饼图、3D饼图绘制
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
43
44
45
46
47
48
49
50
51
52
53
54
55
####### 2. 绘制饼图
# 2.1 x: 数值向量, 表示每个扇形的面积
x <- c(21, 62, 10, 53)
pie(x)

# 2.2 labels: 字符型向量, 表示各扇形面积标签
x<-c(21, 62, 10, 53)
names(x) <- c("London", "New York", "singapore", "Mumbai")
x
pie(x)

x<-c(21, 62, 10, 53)
pie(x)
pie(x, labels = c("London", "New York", "singapore", "Mumbai"))

# 2.3 radius: 饼图的半径
x<-c(21, 62, 10, 53)
pie(x, labels = c("London", "New York", "singapore", "Mumbai"), radius = 1)

# 2.4 main: 饼图的标题
pie(x, labels = c("London", "New York", "singapore", "Mumbai"), radius =1, main="饼图")

# 2.5 clockwise: 一个逻辑值, 用来指定饼图各个切片是否按顺时针做出分割
pie(x, labels = c("London", "New York", "singapore", "Mumbai"), radius =1, main="饼图", clockwise = TRUE)

# 2.6 & 2.7
# angle: 设置底纹的斜率
# density: 底纹的密度, 默认值为NULL
pie(x, labels = c("London", "New York", "singapore", "Mumbai"), radius =1, main="饼图", clockwise = TRUE, density = 10, angle = 20)

# 2.8 col: 每个扇面的颜色, 相当于调色板
pie(x, labels = c("London", "New York", "singapore", "Mumbai"), 
    radius =1, main="饼图", clockwise = TRUE, 
    density = 10, angle = 20, col = rainbow(length(x)))

pie(x, labels = c("London", "New York", "singapore", "Mumbai"), 
    radius =1, main="饼图", clockwise = TRUE, 
    col = rainbow(length(x)))

# 2.9 设置百分数
piepercent <- round(x/sum(x) * 100, 1)
pie(x, piepercent, radius=0.5, main="饼图", clockwise= TRUE, col=rainbow(length(x)))

# 2.10 设置图例
legend("topright", c("London", "New York", "Singapore", "Mumbai"),
       fill = rainbow(length(x)), cex = 0.8)

legend("topright", c("London", "New York", "Singapore", "Mumbai"),
       fill = rainbow(length(x)), horiz = TRUE, cex = 0.5)

# 2.11 绘制 3D 饼图
install.packages("plotrix")
library("plotrix")
lbl <- c("London", "New York", "Singapore", "Mumbai")
pie3D(x, labels = lbl, explode = 0.1, main = "城市 3D 饼图")
2.12.3 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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
####### 3. 绘制散点图、折线图、散点矩阵图
# 3.1 绘制散点图 plot()
# x: 横坐标, x轴的数据集合
# y: 纵坐标, y轴的数据集合
# type: 绘图的类型, type="p" 为点(默认); 
#                   type="l" 在图形中数据显示为线;
#                   type="b" 在图形中数据显示为点和连接线;
#                   type="o" 在图形中数据点覆盖在线上;
#                   type="h" 在图形中数据显示为从点到x轴的垂直线; 
#                   type="s" 在图形中数据显示为阶梯图;
#                   type="n" 在图形中数据不显示
# main: 图表标题
# xlab/ylab: x轴/y轴的标签名称
# xlim/ylim: x轴/y轴的范围
# axes: 布尔值, 是否绘制两个坐标轴
# pch: 点的样式由 pch 的取值决定
# cex: 表示相对于默认大小缩放倍数的数值。默认大小为1, 1.5表示放大为默认值的1.5倍; 0.5表示做小为默认大小的0.5倍;

cars        # 加载车辆时速-刹车距离数据集
cars$speed  # 查看车辆时速
cars$dist   # 查看车辆刹车距离

plot(cars$speed, cars$dist)
plot(cars[, 1], cars[, 2])
plot(cars)

plot(cars, main="车辆时速-刹车距离散点图", xlab="车速", ylab="刹车距离",
     col="red", pch=4, cex=1)

with(classData, plot(height, weight))

# 3.2 绘制折线图 plot()
# type: 绘图的类型, type="p" 为点(默认); 
#                   type="l" 在图形中数据显示为线;
#                   type="b" 在图形中数据显示为点和连接线;
#                   type="o" 在图形中数据点覆盖在线上;
#                   type="h" 在图形中数据显示为从点到 x 轴的垂直线(直线条形图);
#                   type="s" 在图形中数据显示为阶梯图;
#                   type="c" 在图形中数据虚线图;
#                   type="n" 在图形中数据不显示
plot(cars$speed, cars$dist, type="l")
plot(cars$speed, cars$dist, type="b")
plot(cars$speed, cars$dist, type="o")

# plot 可以配合lines() 函数绘制出多条折线图
# lines() 函数必须与 plot() 函数配合才能使用, 先用 plot() 函数画出一个图形
# round(x, digits = 0) 舍入函数, x 为数值向量, digits表示有效位数, 可以为负数, 负数表示舍入十位(-1)、百位(-2)...等
x <- 1: 10
beijing <- round(rnorm(10, mean = 20, sd = 2), 2)
beijing
shanghai <- round(rnorm(10, mean = 23, sd = 3), 2)
shanghai
guangzhou <- round(rnorm(10, mean = 18, sd = 1), 2)
guangzhou

plot(x, beijing, type = "l", ylim = c(16, 30), lwd=2, main = "北上广近十天气温变化趋势图")
lines(x, shanghai, type = "b", col="blue", lwd=2)
lines(x, guangzhou, type = "l", col="red", lwd=2)

# 用 plot() 会单独绘制一张新图
plot(x, shanghai, type = "l", ylim = c(16, 30), lwd=2, main = "北上广近十天气温变化趋势图")
plot(x, guangzhou, type = "l", ylim = c(16, 30), lwd=2, main = "北上广近十天气温变化趋势图")

# 3.3 绘制散点矩阵图
mtcars     # 加载 mtcars 数据集, 数据来自1974年美国汽车趋势杂志, 包括32辆汽车(1973-74款) 的油耗和10个方面的汽车设计和性能
           # mpg(Miles Per Gallon): 油耗(每加仑英里(美国)), 功能更强大, 更重的汽车往往消耗更多的燃油
           # cyl(cylinders): 汽缸数, 功率更大的汽车通常具有更多的汽缸
           # disp(displacement, in cubic inches): 排量(立方英寸), 发动机气缸的总容积
           # hp(horsepower): 总马力：这是汽车产生的功率的量度
           # drat：driveshaft ratio:后轴比率：这描述了驱动轴的转动与车轮的转动如何对应。较高的值会降低燃油效率。
           # wt(weight): 重量(1000磅)
           # qsec(1/4 mile time; a measure of acceleration): 1/4英里时间：汽车的速度和加速度
           # vs(‘V’ or straight - engine shape): 发动机缸体, 表示车辆的发动机形状是"V" 形还是更常见的直形。
           # am(transmission; auto or manual): 变速箱, 这表示汽车的变速箱是自动(0)还是手动(1)。
           # gear(abbreviation of gears): 前进挡的数量, 跑车往往具有更多的挡位
           # carb(abbreviation of carburetors): 化油器数量, 与更强大的发动机相关

pairs(mtcars[, c("wt", "mpg", "disp", "cyl")])
pairs(vs~wt + mpg + disp + cyl, data=mtcars)
2.12.4 R 语言绘制直方图
1

2.12.5 R 语言绘制核密度图
1

2.12.6 R 语言绘制箱线图
1

2.12.7 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
####### 7. 小提琴图 
# vioplot 包中的 vioplot 函数用于绘制小提琴图, 小提琴图是核密度图与箱线图的结合
# install.packages("vioplot")
# install.packages("vioplot")
library("vioplot")

# `==` 意为比较等号两端是否相等
mpg4 <- mtcars$mpg[mtcars$cyl == 4]
mpg4
mpg6 <- mtcars$mpg[mtcars$cyl == 6]
mpg6
mpg8 <- mtcars$mpg[mtcars$cyl == 8]
mpg8

vioplot(mpg4, mpg6, mpg8, names=c("4-cyl", "6-cyl", "8-cyl"), col="gold")
title("四/六/八缸 车辆的油耗 (英里/加仑)", ylab="Miles Per Gallon", xlab="Num Of Cylinders")

# 图片的保存
pdf(file="fig-vioplot.pdf", height = 10, width = 10, family = "GB1")

vioplot(mpg~cyl, data=mtcars, xlab="气缸数", ylab="加仑每英里", main="里程数据", names=c("4-cyl", "6-cyl", "8-cyl"))
dev.off   # 关闭图像设备, 我们经常使用图像设备来创建和保存图形输出
          # 当我们完成图形绘制并且不再需要将图形输出到设备上时, 我们需要关闭图像设备以释放系统资源并确保图形正确保存
          # 在 R 中, 我们可以使用 dev.off() 函数来关闭当前活动的图像设备

2.13 R 绘图常用拓展库 ggplot2 绘图

简介：ggplot2是一款强大的图形可视化R包，其作图方式易于理解，且生成的图形精美，定制化程度也很高，是 R 语言中很流行的可视化工具之一。

ggplot2 包是 R 的一个作图用的扩展包，它实现了 图形的语法，将一个作图任务分成若干子任务，只需要完成各个子任务就可以完成作图。在绘制常用图形时，只需要两个步骤：

  1. 将图形所展现的数据输入到 ggplot() 函数中

  2. 调用某个 geom_xxx() 函数，指定图形类型，如散点图、面积图、曲线图、盒型图等。geom_xxx() 提供了各种基本图形，如geom_blank() 不绘制图形、geom_point() 每个观测为一个散点、geom_hline(), geom_vline(), geom_abline() 绘制线等。

ggplot2 的作图的一般步骤为：

  1. 准备数据：一般为数据框，且一般为长表，即每个观测时间占一行，每个观测变量占一列
  2. 输入数据：将数据输入到 ggplot() 函数中，并指定参与作图的每个变量分别映射到哪些图形特性
  3. 选择图形类型：选择一个合适的图形类型，函数名以 geom_ 开头，如 geom_point() 表示散点图。
  4. 设定标题和图例位置等，如 labs()，仍用加号连接。

模板如下：

1
2
3
4
5
6
7
8
p <- ggplot(data = <输入数据框>, 
            mapping = aes(<维度>=<变量名>, 
                          <维度>=<变量名>, 
                          <...>=<...>))
p + geom_<图形类型>(<...>) + 
	scala_<映射>_<类型>(<...>) +
	coord_<类型>(<...>) +
	labs(<...>)
2.13.1 ggplot2 绘制散点图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
####### ggplot2 绘图
# install.packages("ggplot2")     # 安装 ggplot2 绘图库
# install.packages("gapminder")   # 安装 gapminder 数据集

library("ggplot2")                # 绘图包
library("gapminder")              # 数据集包

gapminder

dev.new()                         # 打开绘图设备
p <- ggplot(data = gapminder,
            mapping = aes(
              x = gdpPercap,
              y = lifeExp))

p <- ggplot(data = gapminder,
            aes(gdpPercap, lifeExp))

p + geom_point()  # 散点图
p + geom_smooth() # 拟合曲线图
p + geom_point() + geom_smooth()
dev.off()		  # 关闭绘图设备
2.13.2 ggplot2 绘制面积图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 面积图
# 定义数据框 data.frame
df <- data.frame(
  year=c(1700, 1701, 1702, 1703, 1704, 
         1705, 1706, 1707, 1708, 1709,
         1710, 1711, 1712, 1713, 1714,
         1715, 1716),
  sunspots=c( 5.0, 11.0, 16.0, 23.0, 36.0,
             58.0, 29.0, 20.0, 10.0,  8.0,
              3.0,  0.0,  0.0,  2.0, 11.0,
             27.0, 47.0)
)

df

p <- ggplot(data = df, mapping = aes(year, sunspots))
p + geom_area(fill = "blue", alpha = 0.2, col = "red")
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：体积较小，精简版，包含最常用的图表和组件。

    • 从 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
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
43
44
45
46
<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>第一个 ECharts 程序</title>
        <!-- 1. 引入 ECharts.js 类库文件 -->
        <!-- <script type="text/javascript" src="js/echarts.js"></script> -->
        <script src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        
        <script>
            window.onload=function() {
                // 3. 实例化 ECharts 对象
                var dom = document.getElementById("main");
                var myChart = echarts.init(dom);
                
                // 4. 指定图表的配置项和数据
                var option = {
                    title: {
                        text: "ECharts 入门案例"
                    },
                    tooltip: { },
                    legend: {
                        data: ['销量']
                    },
                    xAxis: {
                        data: ['衬衫', '羊毛衫', '雪纺衫', '帽子', '高跟鞋', '袜子'] 
                    },
                    yAxis: { },
                    series: [{
                        name: '销量',
                        type: 'bar',
                        data: [5, 20, 26, 10, 20, 8]
                    }]
                };
                
                // 5. 使用刚指定的配置项和数据显示图表
                myChart.setOption(option);
            }
	    </script>
    </head>
    
    <body>
        <!-- 2. 准备一个放图表的容器 -->
        <div id="main" style="width: 900px; height: 400px"></div>
    </body>    
</html>

3.3 ECharts 绘图流程

  1. 新建一个 HTML 文件，并在网页头部 <head> ... </head> 部分引入在线的 ECharts 类库或者本地已经下载好的类库。
1
2
3
4
5
6
<head>
    <meta charset="utf-8" />
    <!-- 引入在线的 ECharts 类库或者本地已经下载好的类库 -->
    <!-- <script type="text/javascript" src="js/echarts.js"></script> -->
    <script src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
</head>
  1. 在网页创建一个容器，为 ECharts 准备一个具备大小（宽高）的 DOM （Document Object Model, 文件对象模型 ) 。
1
2
3
4
<body>
    <!-- 为 ECharts 准备一个具备大小(宽高)的 DOM -->
    <div id="main" style="width: 600px; height: 400px"></div>
</body>
  1. 当页面加载时，获取 DOM，并初始化 ECharts 对象
1
2
3
4
5
6
<script>
    window.onload=function() {
        var dom = document.getElementById("main");
        var myChart = echarts.init(dom);
    }
</script>
  1. 指定配置项信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<script>
    window.onload=function() {
        // 省略上一步的操作
        var options = {
            title: {
                text: "ECharts 入门案例"
            },
            tooltip: { },
            legend: {
                data: ['销量']
            },
            xAxis: {
                data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子']
            },
            yAxis: { },
            series: [
                {name:'销量', type: 'bar', data: [5, 20, 36, 10, 10, 20]}
            ]
        }
    }
</script>
  1. 用刚指定的配置项和数据显示图表
1
2
3
4
5
6
<script>
    window.onload=function() {
        // 省略上一步的操作...
        myChart.setOption(option);        
    }
</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
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
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <title>样式设置</title>
        <!-- <script type="text/javascript" src="js/echarts.min.js"></script> -->
        <script type="text/javascript" src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        <script type="text/javascript" src="http://cdn.staticfile.org/jquery/2.2.4/jquery.min.js"></script>
    </head>
    <body>
        <div id="main" class="main" style="height=900px; width:400px"></div>
        <script>
            window.onload=function() {
                var dom = document.getElementById("main");
                // 内置颜色主题
                // var myCharts = echarts.init(dom, "light");
                var myCharts = echarts.init(dom, "dark");
                var options = {
                    title: {
                        text: "ECharts 入门案例"
                    },
                    tooltip: { },
                    legend: {
                        data: ['销量']
                    },
                    xAxis: {
                        data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子']
                    },
                    yAxis: { },
                    series: [
                        {name:'销量', type: 'bar', data: [5, 20, 36, 10, 10, 20]}
                    ]
                }
                myCharts.setOption(options);
            }
        </script>
    </body>    
</html>

  • 自定义颜色主题

    • 通过 JavaScript 定义颜色主题
    1
    • 通过 Json + jQuery 定义颜色主题
    1
3.5.2 ECharts 调色盘
  • 全局调色盘
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
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <title>ECharts 全局调色盘</title>
        <!-- <script type="text/javascript" src="js/echarts.min.js"></script> -->
        <script type="text/javascript" src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        <script type="text/javascript" src="http://cdn.staticfile.org/jquery/2.2.4/jquery.min.js"></script>
    </head>
    <body>
        <div id="main" class="main" style="width: 900px; height: 400px"></div>
        <script>
        	window.onload=function() {
                var dom = document.getElementById('main');	// 获取到 DOM
                var myCharts = echarts.init(dom);			// 初始化 ECharts对象
                // 定义选项
                var options = {
                    // 颜色组件——全局调色盘
                    color: ["red", "blue", "yellow"],
                    xAxis: {
                        show: true,
                        position: "bottom",
                        type: 'category',
                        data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子']
                    },
                    yAxis: {
                        type: 'value',
                        max: 50
                    },
                    // 系列组件
                    series: [
                        { type: "bar", name: "销量1", data: [5, 20, 36, 10, 10, 20] },
                        { type: "line", name: "销量2", data: [4, 30, 26, 14, 8, 15] }
                    ]
                }
                myCharts.setOption(options);
            }
        </script>
    </body>
</html>
  • 系列调色盘
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
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <title>ECharts 系列调色盘</title>
        <!-- <script type="text/javascript" src="js/echarts.min.js"></script> -->
        <script type="text/javascript" src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        <script type="text/javascript" src="http://cdn.staticfile.org/jquery/2.2.4/jquery.min.js"></script>
    </head>
    <body>
        <div id="main" class="main" style="width: 900px; height: 400px"></div>
        <script>
        	window.onload=function() {
                var dom = document.getElementById('main');	// 获取到 DOM
                var myCharts = echarts.init(dom);			// 初始化 ECharts对象
                // 定义选项
                var options = {
                    // 颜色组件——全局调色盘
                    color: ["red", "blue", "yellow"],
                    xAxis: {
                        show: true,
                        position: "bottom",
                        type: 'category',
                        data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子']
                    },
                    yAxis: {
                        type: 'value',
                        max: 50
                    },
                    // 系列组件
                    series: [
                        { type: "bar", name: "销量1", data: [5, 20, 36, 10, 10, 20], color: ["red", "green"] },
                        { type: "line", name: "销量2", data: [4, 30, 26, 14, 8, 15] }
                    ]
                }
                myCharts.setOption(options);
            }
        </script>
    </body>
</html>
  • 系列调色盘与全局调色盘同时出现：
    • 当系列调色盘与全局调色盘同时出现时，图表使用系列调色盘中配置的颜色。
3.5.3 ECharts 直接样式设置

直接样式设置（itemStyle、lineStyle、areaStyle、label、…）

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <title>ECharts 全局调色盘</title>
        <!-- <script type="text/javascript" src="js/echarts.min.js"></script> -->
        <script type="text/javascript" src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        <script type="text/javascript" src="http://cdn.staticfile.org/jquery/2.2.4/jquery.min.js"></script>
    </head>
    <body>
        <div id="main" class="main" style="width:900px; height: 400px;"></div>
        <script>
        	window.onload=function() {
                var dom = document.getElementById("main");
                var myChart = echarts.init(dom);
                var options = {
                    xAxis: {
                        show: true,
                        position: 'bottom',
                        type: 'category',
                        data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子']
                    },
                    yAxis: {
                        type: 'value',
                        max: 50
                    },
                    series: [
                        {
                            type: 'scatter', 
                            name: '销量1', 
                            data: [5, 20, 36, 10, 10, 20], 
                            symbol: 'triangle', 
                            symbolSize:20, 
                            itemStyle: {
                                color: 'red',
                                borderWidth: 2,
                                borderColor: 'blue',
                            },
                            emphasis: {
                                itemStyle: {
                                    color: 'green'
                                },
                                label: {
                                    show: true,
                                    formmatter: "{a}\n{b}{c}", // 这是一个 label
                                    position: 'right'
                                }
                            }
                        },{
                            type: 'scatter',
                            name: '销量2',
                            data: [4, 30, 26, 14, 8, 15]
                        }
                    ],
                    title: {
                        show: true,
                        text: '主标题-点击访问百度',
                        link: 'https//www.baidu.com/',
                        target: 'blank',	// 或者 self 也可以
                        subtext: '副标题-点击访问个人网站',
                        sublink: 'http://hello-nilera.com/',
                        subtarget
                        textStyle: {
                            color: 'red',
                            fontSize: 30,
                            fontStyle: 'italic',
                            fontWeight: 'normal'
                        }
                    }
                }
                
                myChart.setOption(options);
            }
        </script>
    </body>
</html>
3.5.4 ECharts 视觉映射(Visual Map)
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <title>样式设置——视觉映射组件</title>
        <!-- <script type="text/javascript" src="js/echarts.min.js"></script> -->
        <script type="text/javascript" src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        <script type="text/javascript" src="http://cdn.staticfile.org/jquery/2.2.4/jquery.min.js"></script>
    </head>
    <body>
        <div id="main" class="main" style="width: 900px; height: 400px"></div>
        <script>
        	window.onload=function() {
                var dom = document.getElementById('main');
                var myChart = echarts.init(dom);
                var options = {
                    // 连续型视觉映射组件
                    /*
                    visualMap: [
                        {
                            type: 'continuous',
                            min: 0,
                            max: 40,
                            range: [4, 15],
                            calculable: true
                        }
                    ],
                    */
                    // 分段型视觉映射组件
                    visualMap: [{
                        type: 'piecewise',
                        min: 0,
                        max: 40
                    }],
                    title: {
                        text: 'ECharts 视觉映射组件'
                    },
                    tooltip: { },
                    legend: {
                        data: ['销量']
                    },
                    xAxis: {
                        data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子']
                    },
                    yAxis: { },
                    series: [
                        {
                            name: '销量 1',
                            type: 'bar',
                            data: [5, 20, 36, 10, 10, 20]
                        },{
                            name: '销量 2',
                            type: 'bar',
                            data: [8, 12, 30, 15, 18, 26]
                        }
                    ]
                }
                myChart.setOption(options);
            }        
        </script>
    </body>
</html>

3.6 ECharts 中的事件和行为

概念：在 Apache ECharts 的图表中用户的操作将会触发相应的事件。开发者可以监听这些事件，然后通过回调函数做相应的处理。

事件分类： 在 ECharts 中事件分为两种类型，一种是用户鼠标操作点击，或者 hover 图表的图形时触发的事件，还有一种是用户在使用可以交互的组件后触发的行为事件，例如在切换图例开关时触发的 legendselectchanged 事件（这里需要注意切换图例开关是不会触发事件的），数据区域缩放时触发的 datazoom 事件等等。

3.7 ECharts 实例

3.7.1 柱状图

绘制简单的柱状图，一些配置项：

  • xAxis/yAxis
    • type：category 类目轴；value 数值轴；time 时间；log 对数轴
    • data：设置类目的数据（数组）
  • series
    • type：设置系列的类型（设置绘制什么图表）
    • name：设置系列名称，会用在 tooltip 和 legend 中
    • data：系列中的数据内容数组，定义当前这个系列中每个柱子的高度
    • label：设置图形上的文本标签（把数值显示在每个柱子上)
    • itemStyle：设置图形样式
    • showBackground：设置是否显示背景色（默认不显示）
    • backgroundStyle：设置背景色
3.7.2 折线图、堆叠折线图
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
43
44
45
46
47
48
49
50
51
52
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <!-- <script type="text/javascript" src="js/echarts.min.js"></script> -->
        <script type="text/javascript" src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        <script type="text/javascript" src="http://cdn.staticfile.org/jquery/2.2.4/jquery.min.js"></script>
    </head>
    <body>
        <div id="main" class="main" style="width: 900px; height: 400px"></div>
        <script>
        	window.onload=function() {
                var dom = document.getElementById("main");
                var myCharts = echarts.init(dom);
                var options = {
                    xAxis: {
                        type: 'category',
                        data: ['周一', '周二', '周三', '周四', '周五']
                    },
                    yAxis: {
                        type: 'value'
                    },
                    series: [
                        { type: 'line', data: [10, 20, 30, 20, 10]}
                    ],
                    toolbox: {
                        feature: {
                            show: true,
                            dataZoom: { // 数据区域缩放
                                // 框选型数据区域缩放组件(dataZoomSelect): 提供一个选框进行区域缩放。
                                // 即 toolbox.feature.dataZoom
                                yAxisIndex: 'none'
                            },
                            dataView: {
                                readOnly: true
                            },
                            magicType: {
                                type: ['line', 'bar']
                            },
                            restore: { // 配置项还原
                            },
                            saveAsImage: {
                                type: 'jpg'
                            }
                        }
                    }
                }
                myCharts.setOption(options);
            }
        </script>
    </body>
</html>
3.7.3 面积图和堆叠面积图
3.7.4 雷达图
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
43
44
45
46
47
48
49
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
        <!-- <script type="text/javascript" src="js/echarts.min.js"></script> -->
        <script type="text/javascript" src="http://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
        <script type="text/javascript" src="http://cdn.staticfile.org/jquery/2.2.4/jquery.min.js"></script>
    </head>
    <body>
        <div id="main" class="main" style="width:900px; height: 400px"></div>
        <script>
            var dom = document.getElementById("main");
            var myCharts = echarts.init(dom);
            var options = {
                radar: {
                    indicator: [
                        { name: '身高' },
                        { name: '体重' },
                        { name: '年龄' },
                        { name: '跑步速度' }
                    ],
                },
                series: [
                    { 
                        type: 'radar', 
                        data: [
                            { name: '训练前', value: [178, 60, 20, 50] }, 
                            { name: '训练后', value: [178, 58, 20, 52] }, 
                            { name: '训练一年后', value: [180, 55, 21, 55]}
                        ] 
                    },
                ],
                tooltip: {
                    
                },
                toolbox: {
                    show:true,
                    feature:{
                        saveAsImage:{
                            show:true
                        }
                	}
                },
            }
            
            myCharts.setOption(options);
        </script>
    </body>
</html>
发表更新大数据技术 / ECharts5 分钟读完 (大约751个字)

IDEA 2022 搭建 Tomcat 环境

[TOC]

Tomcat 环境的搭建

参考教程

下载 Tomcat

Tomcat官网地址
Tomcat官网
在 Tomcat 官网中下载指定版本的 Tomcat，左侧 Download 处有相应版本，这里推荐 Tomcat 9 版本（因为Tomcat 10 在配置时会出现一定的问题）。
TomcatDownload
下载后解压到指定位置即可。

配置环境变量即可

配置 Tomcat 环境变量前一定要配置好 Java 的环境变量，尤其是JAVA_HOME，这里我一开始并没有配置 JAVA_HOME，我的环境变量是JAVA_HOME_180=xxx，这种方式Tomcat是找不到JAVA_HOME的，因此我又重新配置了JAVA_HOME。
我的 JAVA_HOME 环境变量为：

1
JAVA_HOME=D:\JDK\jdk1.8.0_231

下面是 Tomcat 的环境变量配置：
新建 CATALINA_HOME 环境变量：

1
CATALINA_HOME=D:\tomcat\apache-tomcat-9.0.89

修改Path，在 Path 后添加（新建）如下环境变量：

1
2
3
%CATALINA_HOME%\lib
%CATALINA_HOME%\bin
%CATALINA_HOME%\lib\servlet-api.jar

验证是否配置成功

在命令行中，执行命令：startup.bat，若正常打印相关配置变量、且 Tomcat 进程被阻塞，即证明环境搭建成功。访问localhost:8080，出现以下界面即证明成功搭建。
TomcatSuccess
使用 shutdown.bat 命令即可使阻塞的 Tomcat 进程被关闭，推荐使用这种方式关闭 Tomcat。

可能会出现的问题

  1. 协议处理程序初始化失败：参考教程
    这个问题有可能是由于8080端口被占用了，在Windows中可以使用如下命令查看端口的占用情况： 
    1
    netstat -aon|findstr "8080"
    如果确实被占用了，可以使用如下命令杀死端口号为 <PIDNUM> 的进程。 
    1
    taskkill -PID <PIDNUM> -F
  2. 闪退
    可能原因是：环境变量配置不正确，仔细检查环境变量的配置。
  3. 乱码
    问题描述：打开startup.bat后汉字乱码
    解决方法：在.\apache-tomcat-9.0.43\conf下打开logging.properties文件
    将java.util.logging.ConsoleHandler.encoding = UTF-8替换为java.util.logging.ConsoleHandler.encoding = GBK

社区版 IDEA 如何配置 Tomcat

CSDN 上大多数教程使用 Maven 创建 Tomcat 项目，但是这种方法实在是过于麻烦，社区版和专业版又有些不同，找不到很多东西。

如何配置 IDEA 2022 社区版中的 Tomcat

  1. 安装插件
    在 File → Settings → Plugin 中安装插件，搜索 Tomcat，安装插件。
    SmartTomcat
  2. 配置Tomcat路径
    安装插件后，在 File → Settings → Plugin → Tomcat Server
    添加配置如下：
    SmartTomcatConfig
  3. 完成
关注我

链接

分类

订阅更新

follow.it

最新文章

归档

标签

Annotation1
Axure RP 91
C++ 11 新标准2
CppDev7
Docker1
ECharts2
EasyX1
Fine-Tune(微调)1
GameDev1
Git1
HBase3
Hadoop3
JavaDev3
KAN1
Kaggle3
LLMs7
LM-Studio1
Linux3
Maven1
MyBatis-Plus1
PowerInfer1
PyTorch4
QT61
R1
RedHat1
SVN1
Scala1
Spark2
SpringBoot1
Stable Diffusion1
Tomcat1
VSCode1
ZooKeeper2
多线程编程1
大数据技术8
大模型1
开发工具4
数据结构5
机器学习4
深度学习12
算法5
网络编程1
计划1
语法点3
软件源1
闲聊1
项目1
×