下面是python五大可视化库的对比

Seaborn就是个Matplotlib的封装，功能比较有限；Pyecharts虽然动效做的好看，但是控件无法定制；Bokeh控件玩法多样，但输在做3D和动画要装插件；相较之下Plotly在功能上完胜。

numpy

https://www.runoob.com/numpy/numpy-tutorial.html

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab

Ndarray 对象

N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

NumPy 基本类型

NumPy 的数组中比较重要 ndarray 对象属性有：

NumPy 创建数组

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

numpy.empty

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

numpy.empty(shape, dtype = float, order = 'C')

参数说明：

下面是一个创建空数组的实例：

实例

import numpy as np 
x = np.empty([3,2], dtype = int) 
print (x)

输出结果为：

[[ 6917529027641081856  5764616291768666155]
 [ 6917529027641081859 -5764598754299804209]
 [          4497473538      844429428932120]]

注意 − 数组元素为随机值，因为它们未初始化。

numpy.zeros

创建指定大小的数组，数组元素以 0 来填充：

numpy.zeros(shape, dtype = float, order = 'C')

参数说明：

实例

import numpy as np
 
# 默认为浮点数
x = np.zeros(5) 
print(x)
 
# 设置类型为整数
y = np.zeros((5,), dtype = int) 
print(y)
 
# 自定义类型
z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
print(z)

输出结果为：

[0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[(0, 0) (0, 0)]
 [(0, 0) (0, 0)]]

numpy.ones

创建指定形状的数组，数组元素以 1 来填充：

numpy.ones(shape, dtype = None, order = 'C')

参数说明：

实例

import numpy as np
 
# 默认为浮点数
x = np.ones(5) 
print(x)
 
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)

输出结果为：

[1. 1. 1. 1. 1.]
[[1 1]
 [1 1]]

numpy.zeros_like

numpy.zeros_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充。

numpy.zeros 和 numpy.zeros_like 都是用于创建一个指定形状的数组，其中所有元素都是 0。

它们之间的区别在于：numpy.zeros 可以直接指定要创建的数组的形状，而 numpy.zeros_like 则是创建一个与给定数组具有相同形状的数组。

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)

参数说明：

创建一个与 arr 形状相同的，所有元素都为 0 的数组：

实例

import numpy as np
 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
# 创建一个与 arr 形状相同的，所有元素都为 0 的数组
zeros_arr = np.zeros_like(arr)
print(zeros_arr)

输出结果为：

[[0 0 0]
 [0 0 0]
 [0 0 0]]

numpy.ones_like

numpy.ones_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 1 来填充。

numpy.ones 和 numpy.ones_like 都是用于创建一个指定形状的数组，其中所有元素都是 1。

它们之间的区别在于：numpy.ones 可以直接指定要创建的数组的形状，而 numpy.ones_like 则是创建一个与给定数组具有相同形状的数组。

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

参数说明：

创建一个与 arr 形状相同的，所有元素都为 1 的数组：

实例

import numpy as np
 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
# 创建一个与 arr 形状相同的，所有元素都为 1 的数组
ones_arr = np.ones_like(arr)
print(ones_arr)

输出结果为：

[[1 1 1]
 [1 1 1]
 [1 1 1]]

从数值范围创建数组

这一章节我们将学习如何从数值范围创建数组。

numpy.arange

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：

numpy.arange(start, stop, step, dtype)

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明：

numpy.linspace

numpy.linspace 函数用于创建一个==一维数组==，数组是一个==等差数列==构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明：

以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。

实例

import numpy as np
a = np.linspace(1,10,10)
print(a)

输出结果为：

[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

设置元素全部是1的等差数列：

实例

import numpy as np
a = np.linspace(1,1,10)
print(a)

输出结果为：

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

将 endpoint 设为 false，不包含终止值：

实例

import numpy as np
 
a = np.linspace(10, 20,  5, endpoint =  False)  
print(a)

输出结果为：

[10. 12. 14. 16. 18.]

如果将 endpoint 设为 true，则会包含 20。

以下实例设置间距。

实例

import numpy as np
a =np.linspace(1,10,10,retstep= True)

print(a)
# 拓展例子
b =np.linspace(1,10,10).reshape([10,1])
print(b)

输出结果为：

(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
[[ 1.]
 [ 2.]
 [ 3.]
 [ 4.]
 [ 5.]
 [ 6.]
 [ 7.]
 [ 8.]
 [ 9.]
 [10.]]

numpy.logspace

numpy.logspace 函数用于创建一个于==等比数列==。格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

base 参数意思是取对数的时候 log 的下标。

实例

import numpy as np
# 默认底数是 10
a = np.logspace(1.0,  2.0, num =  10)  
print (a)

输出结果为：

[ 10.           12.91549665     16.68100537      21.5443469  27.82559402      
  35.93813664   46.41588834     59.94842503      77.42636827    100.    ]

将对数的底数设置为 2 :

实例

import numpy as np
a = np.logspace(0,9,10,base=2)
print (a)

输出如下：

[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

NumPy 切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

实例

import numpy as np
 
a = np.arange(10)
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])

输出结果为：

[2  4  6]

以上实例中，我们首先通过 arange() 函数创建 ndarray 对象。 然后，分别设置起始，终止和步长的参数为 2，7 和 2。

我们也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：

实例

import numpy as np
 
a = np.arange(10)  
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)

输出结果为：

[2  4  6]

冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

实例

import numpy as np
 
a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
b = a[5] 
print(b)

输出结果为：

5

实例

import numpy as np a = np.arange(10) print(a[2:])

输出结果为：

[2  3  4  5  6  7  8  9]

实例

import numpy as np a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9] print(a[2:5])

输出结果为：

[2  3  4]

多维数组同样适用上述索引提取方法：

实例

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])

输出结果为：

[[1 2 3]
 [3 4 5]
 [4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
 [4 5 6]]

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

实例

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素

输出结果为：

[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

数学运算

np.sqrt: 平方根。

sqrt_result = np.sqrt(a)

np.power(a, 2)幂运算

np.exp: 指数函数。 指数函数

exp_result = np.exp(a)

np.log: 自然对数。

log_result = np.log(a)

np.log10: 常用对数（底数为10）
log10_result = np.log10(a)
# 输出: array([0.        , 0.30103   , 0.47712125])

np.sin: 正弦函数。

sin_result = np.sin(a)

np.cos: 余弦函数。

cos_result = np.cos(a)

np.tan(a)正切函数

• np.add: 加法运算。

  a = np.array([1, 2, 3])
  b = np.array([4, 5, 6])
  add_result = np.add(a, b)
  # 输出: array([5, 7, 9])

• np.subtract: 减法运算。

  subtract_result = np.subtract(a, b)
  # 输出: array([-3, -3, -3])

• np.multiply: 逐元素乘法。

  multiply_result = np.multiply(a, b)
  # 输出: array([ 4, 10, 18])

• np.divide: 逐元素除法。

  divide_result = np.divide(a, b)
  # 输出: array([0.25, 0.4 , 0.5 ])

随机数

• np.random.rand: 生成 [0, 1) 之间的均匀分布的随机数。

  rand_result = np.random.rand(3)
  # 输出: array([0.5488135 , 0.71518937, 0.60276338]) (示例值)

• np.random.randn: 生成标准正态分布的随机数。

  randn_result = np.random.randn(3)
  # 输出: array([ 1.76405235,  0.40015721,  0.97873798]) (示例值)

• np.random.randint: 生成指定范围内的随机整数。

  randint_result = np.random.randint(1, 10, 3)
  # 输出: array([3, 7, 2]) (示例值)

• np.random.choice: 从给定数组中随机选择。

  choice_result = np.random.choice([1, 2, 3, 4, 5], 3)
  # 输出: array([4, 1, 3]) (示例值)

matplotlib

https://paul.pub/matplotlib-basics/

https://www.runoob.com/matplotlib/matplotlib-tutorial.html

入门

最简单的绘图：

import matplotlib.pyplot as plt
import numpy as np

data = np.arange(100, 201)
plt.plot(data)
plt.show()

plot此处接受了一个数组作为参数，对应的是y轴，x轴我们未指定，默认为传入的数组的元素数量。除了xy轴，还可以传入第三个参数指定数据线的形状，如-r

Pyplot 是 Matplotlib 的子库，提供了和 MATLAB 类似的绘图 API。

• plot()：用于绘制线图和散点图
• scatter()：用于绘制散点图
• bar()：用于绘制垂直条形图和水平条形图
• hist()：用于绘制直方图
• pie()：用于绘制饼图
• imshow()：用于绘制图像
• subplots()：用于创建子图

plot使用

画单条线
plot([x], y, [fmt], *, data=None, **kwargs)

画多条线
plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)

多图形

figure

可以简单的理解为一个figure就是一个图形窗口。matplotlib.pyplot会有一个默认的figure，我们也可以通过plt.figure()创建更多个窗口，初始状态这两个窗口是完全重合的

import matplotlib.pyplot as plt
import numpy as np

data = np.arange(100, 201)
plt.plot(data)

data2 = np.arange(200, 301)
plt.figure()
plt.plot(data2)

plt.show()

subplot

在同一个窗口显示多个图形用多个subplot

import matplotlib.pyplot as plt
import numpy as np

data = np.arange(100, 201)
plt.subplot(2, 1, 1)
plt.plot(data)

data2 = np.arange(200, 301)
plt.subplot(2, 1, 2)
plt.plot(data2)

plt.show()

subplot函数的前两个参数指定了subplot数量，即：它们是以矩阵的形式来分割当前图形，两个整数分别指定了矩阵的行数和列数。而第三个参数是指矩阵中的索引。

subplot还可以将三个整数（10之内的）合并一个整数。例如：2, 1, 1可以写成211，2, 1, 2可以写成212。

subplots

subplot() 方法在绘图时需要指定位置，subplots() 方法可以一次生成多个，在调用时只需要调用生成对象的 ax 即可。

subplots() 方法语法格式如下：

matplotlib.pyplot.subplots(nrows=1, ncols=1, *, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None, **fig_kw)

参数说明：

• nrows：默认为 1，设置图表的==行数==。
• ncols：默认为 1，设置图表的==列数==。
• ==sharex、sharey==：设置 x、y 轴是否共享属性，默认为 false，可设置为 ’none’、‘all’、‘row’ 或 ‘col’。 False 或 none 每个子图的 x 轴或 y 轴都是独立的，True 或 ‘all’：所有子图共享 x 轴或 y 轴，‘row’ 设置每个子图行共享一个 x 轴或 y 轴，‘col’：设置每个子图列共享一个 x 轴或 y 轴。
• figsize 参数设置整个图形的大小
• squeeze：布尔值，默认为 True，表示额外的维度从返回的 Axes(轴)对象中挤出，对于 N1 或 1N 个子图，返回一个 1 维数组，对于 N*M，N>1 和 M>1 返回一个 2 维数组。如果设置为 False，则不进行挤压操作，返回一个元素为 Axes 实例的2维数组，即使它最终是1x1。
• ==subplot_kw==：可选，字典类型。把字典的关键字传递给 add_subplot() 来创建每个子图。
• gridspec_kw：可选，字典类型。把字典的关键字传递给 GridSpec 构造函数创建子图放在网格里(grid)。
• fig_kw：把详细的关键字参数传给 figure() 函数。

可以使用 plt.subplots_adjust() 来调整子图之间的间距和布局。

plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9, wspace=0.4, hspace=0.4)

fig和 axs

fig 和 axs 是 matplotlib.pyplot.subplots 函数返回的两个对象。

fig 是 Figure 对象的实例，表示整个绘图的顶层容器或画布。它包含了所有的子图。Figure 对象可以用来控制整个图形的布局、大小和保存等操作。

常见的 Figure 属性和方法：

• fig.add_subplot(nrows, ncols, index)：向图形==添加子图==。

• fig.suptitle(title)：设置整个图形的总标题。

• fig.tight_layout()：自动调整子图参数，以使子图适应图形区域。

• fig.subplots_adjust(left, bottom, right, top, wspace, hspace)：手动调整子图之间的间距和位置。

• fig.savefig('filename.png')：将图形保存为文件。

axs 是一个包含多个 Axes 对象的二维数组（或者列表），每个 Axes 对象代表一个子图。Axes 对象是实际绘制数据的区域，它包含了坐标轴、刻度、线条、标签等。

常见的 Axes 属性和方法：

• ax.plot(x, y)：在子图上绘制线条或数据。
• ax.set_title(title)：设置子图的标题。
• ax.set_xlabel(label) 和 ax.set_ylabel(label)：设置子图的 x 轴和 y 轴标签。
• ax.set_xlim(left, right) 和 ax.set_ylim(bottom, top)：设置子图的 x 轴和 y 轴范围。
• ax.grid(True)：显示网格线。

示例

import matplotlib.pyplot as plt
import numpy as np

# 创建一些测试数据 -- 图1
x = np.linspace(0, 2*np.pi, 400)
y = np.sin(x**2)

# 创建一个画像和子图 -- 图2
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('Simple plot')

# 创建两个子图 -- 图3
f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
ax1.plot(x, y)
ax1.set_title('Sharing Y axis')
ax2.scatter(x, y)

# 创建四个子图 -- 图4
fig, axs = plt.subplots(2, 2, subplot_kw=dict(projection="polar"))
axs[0, 0].plot(x, y)
axs[1, 1].scatter(x, y)

# 共享 x 轴
plt.subplots(2, 2, sharex='col')

# 共享 y 轴
plt.subplots(2, 2, sharey='row')

# 共享 x 轴和 y 轴
plt.subplots(2, 2, sharex='all', sharey='all')

# 这个也是共享 x 轴和 y 轴
plt.subplots(2, 2, sharex=True, sharey=True)

# 创建标识为 10 的图，已经存在的则删除
fig, ax = plt.subplots(num=10, clear=True)

plt.show()

绘图标记

fmt 参数

fmt 参数定义了基本格式，如标记、线条样式和颜色。

fmt = '[marker][line][color]'

标记字符：’.’ 点标记，’,’ 像素标记(极小点)，‘o’ 实心圈标记，‘v’ 倒三角标记，’^’ 上三角标记，’>’ 右三角标记，’<’ 左三角标记…等等。

线型参数：’‐’ 实线，’‐‐’ 长虚线，’‐.’ 点划线，’:‘短虚线。

颜色字符：‘b’ 蓝色，’m’ 洋红色，‘g’ 绿色，‘y’ 黄色，‘r’ 红色，‘k’ 黑色，‘w’ 白色，‘c’ 青绿色，’#008000’ RGB 颜色符串。多条曲线不指定颜色时，会自动选择不同颜色。

如果我们要绘制坐标 (1, 3) 到 (8, 10) 的线，我们就需要传递两个数组 [1, 8] 和 [3, 10] 给 plot 函数：

ps：:.就是这种

marker参数

import matplotlib.pyplot as plt
import numpy as np

ypoints = np.array([1,3,4,5,8,9,6,1,3,4,5,2,4])

plt.plot(ypoints, marker = 'o')
plt.show()

marker 可以定义的符号如下：

标记	符号	描述
“.”		点
“,”		像素点
“o”		实心圆
“v”		下三角
“^”		上三角
“<”		左三角
“>”		右三角
“1”		下三叉
“2”		上三叉
“3”		左三叉
“4”		右三叉
“8”		八角形
“s”		正方形
“p”		五边形
“P”		加号（填充）
“*”		星号
“h”		六边形 1
“H”		六边形 2
“+”		加号
“x”		乘号 x
“X”		乘号 x (填充)
“D”		菱形
“d”		瘦菱形
“|”		竖线
“_”		横线
0 (TICKLEFT)		左横线
1 (TICKRIGHT)		右横线
2 (TICKUP)		上竖线
3 (TICKDOWN)		下竖线
4 (CARETLEFT)		左箭头
5 (CARETRIGHT)		右箭头
6 (CARETUP)		上箭头
7 (CARETDOWN)		下箭头
8 (CARETLEFTBASE)		左箭头 (中间点为基准)
9 (CARETRIGHTBASE)		右箭头 (中间点为基准)
10 (CARETUPBASE)		上箭头 (中间点为基准)
11 (CARETDOWNBASE)		下箭头 (中间点为基准)
“None”, " " or ""		没有任何标记
‘$…$’		渲染指定的字符。例如 “$f$” 以字母 f 为标记。

辅助元素

label 图例

xlabel() ylabel() 坐标轴标签

xlim() ylim()刻度范围

xtricks() ytricks() 刻度标签

title() 标题

legend() 图例

grid() 网格

annotate() 注释

绘图线

绘图过程如果我们自定义线的样式，包括线的类型、颜色和大小等。

线的类型

线的类型可以使用 linestyle 参数来定义，简写为 ls。

import matplotlib.pyplot as plt
import numpy as np

ypoints = np.array([6, 2, 13, 10])

plt.plot(ypoints, linestyle = 'dotted')
plt.show()

线的颜色

线的颜色可以使用 color 参数来定义，简写为 c。

颜色类型：

import matplotlib.pyplot as plt
import numpy as np

ypoints = np.array([6, 2, 13, 10])

plt.plot(ypoints, color = 'r')
plt.show()

轴标签和标题

使用 xlabel() 和 ylabel() 方法来设置 x 轴和 y 轴的标签。

使用 title() 方法来设置标题。

实例

import numpy as np
import matplotlib.pyplot as plt

x = np.array([1, 2, 3, 4])
y = np.array([1, 4, 9, 16])
plt.plot(x, y)

plt.xlabel("x - label")
plt.ylabel("y - label")

plt.show()

网格线

我们可以使用 pyplot 中的 grid() 方法来设置图表中的网格线。

grid() 方法语法格式如下：

matplotlib.pyplot.grid(b=None, which='major', axis='both', )

参数说明：

• b：可选，默认为 None，可以设置布尔值，true 为显示网格线，false 为不显示，如果设置 **kwargs 参数，则值为 true。
• which：可选，可选值有 ‘major’、‘minor’ 和 ‘both’，默认为 ‘major’，表示应用更改的网格线。
• axis：可选，设置显示哪个方向的网格线，可以是取 ‘both’（默认），‘x’ 或 ‘y’，分别表示两个方向，x 轴方向或 y 轴方向。
• **kwargs：可选，设置网格样式，可以是 ==color=‘r’, linestyle=’-’ 和 linewidth=2，分别表示网格线的颜色，样式和宽度==。

import numpy as np
import matplotlib.pyplot as plt

x = np.array([1, 2, 3, 4])
y = np.array([1, 4, 9, 16])


plt.title("RUNOOB grid() Test")
plt.xlabel("x - label")
plt.ylabel("y - label")

plt.plot(x, y)

plt.grid()

plt.show()

常用图形

线性图 plot

import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [3, 6, 9], '-r')
plt.plot([1, 2, 3], [2, 4, 9], ':g')

plt.show()

散点图 scatter

scatter函数用来绘制散点图

1. 这幅图包含了三组数据，每组数据都包含了20个随机坐标的位置
2. 参数c表示点的颜色，s是点的大小，alpha是透明度

import matplotlib.pyplot as plt
import numpy as np

N = 20

plt.scatter(np.random.rand(N) * 100,
            np.random.rand(N) * 100,
            c='r', s=100, alpha=0.5)

plt.scatter(np.random.rand(N) * 100,
            np.random.rand(N) * 100,
            c='g', s=200, alpha=0.5)

plt.scatter(np.random.rand(N) * 100,
            np.random.rand(N) * 100,
            c='b', s=300, alpha=0.5)

plt.show()

饼状图 pie

pie函数用来绘制饼状图

1. data是一组包含7个数据的随机数值
2. 图中的标签通过labels来指定
3. autopct指定了数值的精度格式
4. plt.axis('equal')设置了坐标轴大小一致
5. plt.legend()指明要绘制图例（见下图的右上角）

import matplotlib.pyplot as plt
import numpy as np

labels = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

data = np.random.rand(7) * 100

plt.pie(data, labels=labels, autopct='%1.1f%%')
plt.axis('equal')
plt.legend()

plt.show()

柱形图 bar

bar函数用来绘制条形图。

1. 这幅图展示了一组包含7个随机数值的结果，每个数值是[0, 100]的随机数
2. 它们的颜色也是通过随机数生成的。np.random.rand(N * 3).reshape(N, -1)表示先生成21（N x 3）个随机数，然后将它们组装成7行，那么每行就是三个数，这对应了颜色的三个组成部分。如果不理解这行代码，请先学习一下Python 机器学习库 NumPy 教程
3. title指定了图形的标题，labels指定了标签，alpha是透明度

import matplotlib.pyplot as plt
import numpy as np

N = 7

x = np.arange(N)
data = np.random.randint(low=0, high=100, size=N)
colors = np.random.rand(N * 3).reshape(N, -1)
labels = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

plt.title("Weekday Data")
plt.bar(x, data, alpha=0.8, color=colors, tick_label=labels)
plt.show()

直方图 hist

hist函数用来绘制直方图。

[np.random.randint(0, n, n) for n in [3000, 4000, 5000]]生成了包含了三个数组的数组，这其中：

• 第一个数组包含了3000个随机数，这些随机数的范围是 [0, 3000)
• 第二个数组包含了4000个随机数，这些随机数的范围是 [0, 4000)
• 第三个数组包含了5000个随机数，这些随机数的范围是 [0, 5000)

bins数组用来指定我们显示的直方图的边界，即：[0, 100) 会有一个数据点，[100, 500)会有一个数据点，以此类推。所以最终结果一共会显示7个数据点。

import matplotlib.pyplot as plt
import numpy as np

data = [np.random.randint(0, n, n) for n in [3000, 4000, 5000]]
labels = ['3K', '4K', '5K']
bins = [0, 100, 500, 1000, 2000, 3000, 4000, 5000]

plt.hist(data, bins=bins, label=labels)
plt.legend()

plt.show()

等高线图 contour

创建等高线图主要使用 contour 和 contourf 函数。contour 函数绘制等高线，contourf 函数则会填充等高线之间的区域。

contour

contour(X, Y, Z, levels=10, **kwargs)

X, Y: 网格点坐标。

Z: 每个网格点的高度值。

levels: 等高线的数量或等高线的具体值列表。

其他可选参数（kwargs）：线条样式、颜色等。

contourf

contourf(X, Y, Z, levels=10, **kwargs)

与 contour 相同，但 contourf 会填充等高线之间的区域。

levels: 等高线的数量或等高线的具体值列表。

1. 生成数据

   创建一个网格 X, Y，并计算对应的 Z 值。

# 创建网格
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)  #它接受两个一维数组作为输入，并生成两个二维数组，分别表示在二维平面上的网格点的 X 坐标和 Y 坐标。

# 计算 Z 值
Z = (X - 1)**2 + (Y - 1)**2

1. 绘制等高线图：

# 绘制等高线图
plt.contour(X, Y, Z)
plt.title('Contour Plot')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.show()

1. 绘制填充的等高线图：

# 绘制填充的等高线图
plt.contourf(X, Y, Z)
plt.title('Filled Contour Plot')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.colorbar()  # 添加颜色条
plt.show()

自定义等高线和颜色

# 自定义等高线级别和颜色
levels = np.linspace(Z.min(), Z.max(), 7)
contour = plt.contour(X, Y, Z, levels=levels, colors='black')
plt.contourf(X, Y, Z, levels=levels, cmap='RdGy')

# 添加颜色条
plt.colorbar()

# 添加等高线标签
plt.clabel(contour, inline=True, fontsize=8)

plt.title('Custom Contour Plot')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.show()

绘制带有特定样式的等高线

contour = plt.contour(X, Y, Z, levels=10, linewidths=1.5, linestyles='dashed')
plt.contourf(X, Y, Z, levels=10, cmap='viridis')

# 添加颜色条
plt.colorbar()

# 添加等高线标签
plt.clabel(contour, inline=True, fontsize=8)

plt.title('Styled Contour Plot')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.show()

在等高线图上添加其他图形元素

# 创建等高线图
plt.contour(X, Y, Z, levels=10, colors='black')
plt.contourf(X, Y, Z, levels=10, cmap='viridis')

# 添加颜色条
plt.colorbar()

# 添加点和线
plt.scatter([0], [0], color='red')  # 在中心点绘制一个红色点
plt.plot([-5, 5], [0, 0], color='blue', linestyle='--')  # 添加一条水平虚线

plt.title('Contour Plot with Annotations')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.show()

雷达图 polar

animation 动态图

1、初始化图形和数据

创建图形对象，并设置初始数据。plt.subplots() 返回一个图形对象和一个坐标轴对象。plt.plot([], [], 'ro') 创建一个初始为空的红色圆点的 Line2D 对象。

2、定义初始化函数

初始化函数用于设置动画的背景，如==坐标轴范围==等。这里设置 x 轴范围为 [0, 2π]，y 轴范围为 [-1, 1]。

3、定义更新函数

更新函数在每一帧被调用，更新 xdata 和 ydata，并将新的数据设置到 Line2D 对象中。

4、 创建动画对象

使用 FuncAnimation 创建动画对象。参数包括图形对象、更新函数、帧序列、初始化函数和 blit 选项。

5、 显示或保存动画

plt.show() 用于显示动画，ani.save() 用于保存动画。可以选择不同的 writer 保存不同格式的动画文件。

创建基本动画

1. 初始化图形和数据

首先，我们需要设置图形对象和初始数据。

fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'ro')

def init():
    ax.set_xlim(0, 2*np.pi)
    ax.set_ylim(-1, 1)
    return ln,

2. 更新函数

更新函数用于更新每一帧中的数据。

def update(frame):
    xdata.append(frame)
    ydata.append(np.sin(frame))
    ln.set_data(xdata, ydata)
    return ln,

3. 创建动画对象

使用 FuncAnimation 创建动画对象。

ani = animation.FuncAnimation(fig, 
                              update, 
                              frames=np.linspace(0, 2*np.pi, 128),   frames作为参数传递到update函数
                              init_func=init, 
                              interval=1000，            每帧之间的时间间隔（毫秒）
                              blit=True,: 布尔值，表示是否只更新变化的部分。
                              repeat=False,不重复，画完就结束，默认重复
                             )

4. 显示或保存动画

可以使用 plt.show() 来显示动画，或者使用 ani.save() 将动画保存为视频文件。

plt.show()

# 保存动画为 mp4 文件
ani.save('sine_wave_animation.mp4', writer='ffmpeg')

高级用法

动画中的参数

• fig: Matplotlib 图形对象。
• func: 更新函数。
• frames: 动画的帧数据，可以是整数或可迭代对象。
• init_func: 初始化函数，用于设置背景。
• blit: 布尔值，表示是否只更新变化的部分。

动画的间隔和重复

可以控制每帧之间的间隔时间和动画是否重复。

ani = animation.FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128),
                              init_func=init, blit=True, interval=50, repeat=False)

• interval: 每帧之间的时间间隔（毫秒）。
• repeat: 布尔值，表示动画是否循环播放。

使用不同的动画 Writer

Matplotlib 支持多种动画 Writer，例如 ffmpeg 和 imagemagick。可以根据需要选择合适的 Writer。

ani.save('sine_wave_animation.gif', writer='imagemagick')

实例：创建一个散点动画

下面是一个创建随机散点动画的实例：

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

fig, ax = plt.subplots()
x = np.random.rand(100)
y = np.random.rand(100)
scat = ax.scatter(x, y)

def init():
    ax.set_xlim(0, 1)
    ax.set_ylim(0, 1)
    return scat,

def update(frame):
    x = np.random.rand(100)
    y = np.random.rand(100)
    scat.set_offsets(np.c_[x, y])
    return scat,

ani = animation.FuncAnimation(fig, update, frames=50, init_func=init, blit=True, interval=100)
plt.show()

创建一个沿着sin函数移动的点

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

fig, ax = plt.subplots()

# 初始化点的位置
xdata, ydata = [], []
ln, = ax.plot([], [], 'ro')  # 创建一个红色的点，必须

# 初始化函数
def init():
    ax.set_xlim(0, 2 * np.pi)
    ax.set_ylim(-1, 1)
    return ln,

# 更新函数
def update(frame):
    xdata.append(frame) #增加点的数目
    ydata.append(np.sin(frame))
    ln.set_data(xdata, ydata) # 更新点的数据

    # 限制点的数量，以便在图上移动
    if len(xdata) > 50:
        xdata.pop(0)
        ydata.pop(0)

    return ln,

# 创建动画
ani = FuncAnimation(fig, update, frames=np.linspace(0, 2 * np.pi, 128),
                    init_func=init, blit=True)

ani.save('sincurve.gif') #保存动画
# 显示动画
plt.show()