DataWhale_Matplotlib_艺术画笔见乾坤

0 序

这一章节对matplotlib的框架做了详细的介绍，包括matplotlib的三个API分别是什么，有什么作用？matplotlib都有哪些对象容器，分别有什么联系和关系，又包含了哪些功能等等。接下来，我们就一起来看看，俗话说得好，磨刀不误砍柴工，打基础至关重要呀～

1 概述

1.1 matplotlib的三层api

matplotlib有三个层次的API：

matplotlib.backend_bases.FigureCanvas - 绘图区
matplotlib.backend_bases.Renderer - 渲染器，控制如何在 FigureCanvas 上画图。
matplotlib.artist.Artist - 图表组件，即调用了Renderer的接口在Canvas上作图。

1.2 Artist的分类

Artist有两种类型：primitives 和containers。
primitive - 基本要素，它包含一些我们要在绘图区作图用到的标准图形对象，如曲线Line2D，文字text，矩形Rectangle，图像image等
container - 容器，即用来装基本要素的地方，包括图形figure、坐标系Axes和坐标轴Axis。他们之间的关系如下图所示

1.3 matplotlib标准用法

matplotlib的标准使用流程为：

创建一个Figure实例
使用Figure实例创建一个或者多个Axes或Subplot实例
使用Axes实例的辅助方法来创建primitive

Axes是一种容器，它可能是matplotlib API中最重要的类，并且我们大多数时间都花在和它打交道上

# 导入三方模块
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib.patches import Circle, Wedge
from matplotlib.collections import PatchCollection
import numpy as np
import re
import pandas as pd

# 创建一个Figure实例
fig = plt.figure()

# 在画布上建立一个2*1的子画布绘图区
ax = fig.add_subplot(2, 1, 1)
'''这里代表在2*1的第一个画布'''

# 用axes实例的方法画一条曲线
num = np.arange(0.0, 1.0, 0.01)
print(num)
sin = np.sin(2 * np.pi * num)

line, = ax.plot(num, sin, color='blue', lw=2)
'''
ax.plot()返回带有一个元素的元组。通过在分配目标列表中添加逗号，Python解开返回值并将其分配给依次命名为左侧的每个变量。

大多数情况下，这适用于具有多个返回值的函数;
左侧可以包含任意数量的元素，并且如果它是元组或变量列表，则用逗号将进行拆包
'''

2 自定义你的Artist对象

2.1 Artist属性

Figure本身包含一个Rectangle，Rectangle的大小就是Figure的大小，可以用来设置Figure的背景色和透明度。 每个Axes边界框(默认白底黑边)，也有一个Rectangle，通过它可以设置Axes的颜色、透明度等。 这些实例都存储在成员变量(member variables) Figure.patch 和 Axes.patch中 Patch是一个来源于MATLAB的名词，它是图形上颜色的一个2D补丁，包含rectangels-矩形，circles-圆 和 plygons-多边形）

Figure.patch属性：是一个Rectangle，代表了图表的矩形框，它的大小就是图表的大小， 并且可以通过它设置figure的背景色和透明度。 Axes.patch属性：也是一个Rectangle，代表了绘图坐标轴内部的矩形框（白底黑边）， 通过它可以设置Axes的颜色、透明度等。

每个matplotlib Artist都有以下常见属性：

.alpha属性：透明度。值为0—1之间的浮点数
.axes属性：返回这个Artist所属的axes，可能为None
.figure属性：该Artist所属的Figure，可能为None
.label：一个text label
.visible：布尔值，控制Artist是否绘制

# .patch
plt.figure().patch
plt.axes().patch

2.2 属性调用方式

Artist对象的所有属性都通过相应的 get_* 和 set_* 函数进行读写。
例如下面的语句将alpha属性设置为当前值的一半

fig_1 = plt.figure()
ax1 = fig_1.add_subplot(2, 1, 1)
num = np.arange(0.0, 1.0, 0.01)
print(num)
sin = np.sin(2 * np.pi * num)

line, = ax1.plot(num, sin, color='blue', lw=2)
ax1.set_alpha(0.8)

# 获取ax1的透明度
ax1_alpha = ax1.get_alpha()
print(ax1_alpha)

# 重设ax1的透明度
ax1.set_alpha(0.5 * ax1_alpha)
print(ax1.get_alpha())

# 如果想一次设置多个属性
'''zorder参数 - 控制绘图顺序'''
ax1.set(alpha=0.5, zorder=2)

可以使用 matplotlib.artist.getp(o,“alpha”) 来获取属性 如果指定属性名，则返回对象的该属性值； 如果不指定属性名，则返回对象的所有的属性和值。

# Figure rectangle的属性
matplotlib.artist.getp(fig.patch)

3 基本元素 - primitives

3.1 2DLines

在matplotlib中曲线的绘制，主要是通过类 matplotlib.lines.Line2D 来完成的。
Line2D的基类 - matplotlib.artist.Artist

matplotlib中线-line的含义：它表示的可以是连接所有顶点的实线样式，也可以是每个顶点的标记。

Line2D的构造函数如下：
class matplotlib.lines.Line2D(
xdata, ydata, linewidth=None, linestyle=None, color=None, marker=None, markersize=None,
markeredgewidth=None, markeredgecolor=None, markerfacecolor=None, markerfacecoloralt=‘none’,
fillstyle=None, antialiased=None, dash_capstyle=None, solid_capstyle=None,
dash_joinstyle=None, solid_joinstyle=None, pickradius=5, drawstyle=None, markevery=None, **kwargs
)
其中，常用参数如下：
xdata - 需要绘制的line中点的在x轴上的取值，若忽略，则默认为range(1,len(ydata)+1)
ydata - 需要绘制的line中点的在y轴上的取值
linewidth - 线条的宽度
linestyle - 线型
color - 线条的颜色
marker - 点的标记
markersize - 标记的size

3.1.1 Lines2D的属性设置

有三种方法可以用设置线的属性

直接在plot()函数中设置

x = range(0, 5)
y = [2, 5, 7, 8, 10]
plt.plot(x, y, linewidth=10)#linewidth - 控制线的粗细程度

通过获得线对象，对线对象进行设置

line, = plt.plot(x, y, '-')
line.set_antialiased(False) # 关闭抗锯齿功能

# 打开抗锯齿试试
line, = plt.plot(x, y, '-')
line.set_antialiased(True)
'''线条更加细腻平滑'''

获得线属性，使用setp()函数设置

lines = plt.plot(x, y)
plt.setp(lines, color='r', linewidth=10)

3.1.2 如何绘制lines

pyplot方法绘制

plt.plot(x,y)

Line2D对象绘制

# 创建实例
fig = plt.figure()

ax = fig.add_subplot(111)
'''和1，1，1效果是一样的'''

# 用Line2D对象绘制线条
line = Line2D(x, y)

# 将线条加入子画布
ax.add_line(line)

# 设置子画布x轴和y轴的范围
ax.set_xlim(min(x), max(x))
ax.set_ylim(min(y), max(y))

errorbar绘制误差折线图

pyplot里有个专门绘制误差线的功能，通过errorbar类实现

它的构造函数：
matplotlib.pyplot.errorbar(
x, y, yerr=None, xerr=None, fmt=’’, ecolor=None, elinewidth=None,
capsize=None, barsabove=False, lolims=False, uplims=False, xlolims=False,
xuplims=False, errorevery=1, capthick=None, *, data=None, **kwargs
)
其中主要的参数是如下：
x - 需要绘制的line中点的在x轴上的取值
y - 需要绘制的line中点的在y轴上的取值
yerr - 指定y轴水平的误差
xerr - 指定x轴水平的误差
fmt - 指定折线图中某个点的颜色，形状，线条风格，例如‘co–’
ecolor - 指定error bar的颜色
elinewidth - 指定error bar的线条宽度

# 绘制一个errorbar试试，创建一个画布
fig = plt.figure()
x = np.arange(10)
y = 2.5 * np.sin(x / 20 * np.pi)

# 生成0.05-0.2中10个元素的等差数列，这里的个数和x轴个数（若连续则为观测个数）保持一致
yerr = np.linspace(0.05, 0.2, 10)
print(yerr)

# 创建误差折线图
plt.errorbar(x, y + 3, yerr=yerr, label='both limits (default)')

3.1.3 patches

matplotlib.patches.Patch类是二维图形类。它的基类是matplotlib.artist.Artist，它的构造函数如下

Patch( edgecolor=None, facecolor=None, color=None,linewidth=None, linestyle=None, antialiased=None,hatch=None, fill=True, capstyle=None, joinstyle=None,**kwargs )

Rectangle-矩形

Rectangle矩形类在官网中的定义是： 通过锚点xy及其宽度和高度生成。
Rectangle本身的主要比较简单，即xy控制锚点，width和height分别控制宽和高。它的构造函数如下

class matplotlib.patches.Rectangle(xy, width, height, angle=0.0, **kwargs)
实际中最常见的矩形图是hist直方图和bar条形图

hist-直方图

构造函数如下

matplotlib.pyplot.hist(
        x, bins=None, range=None, density=None, bottom=None, histtype=‘bar’, align=‘mid’, 
        log=False, color=None, label=None, stacked=False, normed=None
        )

            常用的参数如下：

                x - 数据集，最终的直方图将对数据集进行统计
                bins - 统计的区间分布
                range - tuple, 显示的区间，range在没有给出bins时生效
                density - bool，默认为false，显示的是频数统计结果，为True则显示频率统计结果，这里需要注意，
                            频率统计结果=区间数目/(总数*区间宽度)，和normed效果一致，官方推荐使用density
                histtype - 可选{‘bar’, ‘barstacked’, ‘step’, ‘stepfilled’}之一，默认为bar，推荐使用默认配置，
                            step使用的是梯状，stepfilled则会对梯状内部进行填充，效果与bar类似
                align - 可选{‘left’, ‘mid’, ‘right’}之一，默认为’mid’，控制柱状图的水平分布，left或者right，
                            会有部分空白区域，推荐使用默认
                log - bool，默认False,即y坐标轴是否选择指数刻度
                stacked - bool，默认为False，是否为堆积状图

# hist绘制直方图

## 生成100个0-99间的随机整数作为数据集
x = np.random.randint(0, 100, 100)

## 划分分桶区间：[0,10), [10, 20)...[90, 100]
bins = np.arange(0, 101, 10)

## 绘制柱状图
plt.hist(x, bins, color='fuchsia', alpha=0.5)
plt.xlabel('scores')
plt.ylabel('count')
plt.xlim(0, 100)

Rectangle矩形类绘制直方图

# 创建一个DataFrame数据框
df = pd.DataFrame(columns = ['data'])

# ‘data’列用x填充
df.loc[:, 'data'] = x

# 分桶列
df['fenzu'] = pd.cut(df['data'], bins=bins, right=False, include_lowest=True)
'''
参数解释：
    right - 是否包含右端点
    include_lowest - 是否包含左端点
'''

# 将分桶列排列重组
df_cnt = df['fenzu'].value_counts().reset_index()
print(df_cnt)

# 利用正则将第一个数字取出的记为最小值
df_cnt.loc[:,'mini'] = df_cnt['index'].astype(str).map(lambda x:re.findall('\[(.*)\,',x)[0]).astype(int)

# 将右边的取出记为最大值
df_cnt.loc[:,'maxi'] = df_cnt['index'].astype(str).map(lambda x:re.findall('\,(.*)\)',x)[0]).astype(int)

# 最小值和最大值的差值是这个分桶区间的宽度
df_cnt.loc[:,'width'] = df_cnt['maxi']- df_cnt['mini']

# 根据最小值升序
df_cnt.sort_values('mini', ascending=True, inplace=True)

# 重塑索引
df_cnt.reset_index(inplace=True, drop=True)
print(df_cnt.head(20))

# 用Rectangle绘制hist
# 创建实例
fig = plt.figure()

# 创建子画布
ax2 = fig.add_subplot(111)
# rect2 = plt.Rectangle((0, 0), 10, 10)
# ax2.add_patch(rect2)
for i in df_cnt.index:
    # 每个矩形的起始是它的min，终止是min+width，高度是分组数（y）
    rect = plt.Rectangle((df_cnt.loc[i, 'mini'], 0), df_cnt.loc[i, 'width'], df_cnt.loc[i, 'fenzu'])
    ax2.add_patch(rect)
ax2.set_xlim(0, 100)
ax2.set_ylim(0, 16)

bar-柱状图

bar()的构造函数如下：

matplotlib.pyplot.bar(left, height, alpha=1, width=0.8, color=, edgecolor=, label=, lw=3)

    常用的参数：

            left - x轴的位置序列，一般采用range函数产生一个序列，但是有时候可以是字符串
            height - y轴的数值序列，也就是柱形图的高度，一般就是我们需要展示的数据；
            alpha - 透明度，值越小越透明
            width - 为柱形图的宽度，一般这是为0.8即可；
            color或facecolor - 柱形图填充的颜色；
            edgecolor - 图形边缘颜色
            label - 解释每个图像代表的含义，这个参数是为legend()函数做铺垫的，表示该次bar的标签
            lw - linewidths,边缘or线的宽度

# bar绘制柱状图
y = range(1, 17)
plt.bar(np.arange(16), y, alpha=0.5, width=0.5, color='yellow', edgecolor='red', label='the first bar', lw=3)

Rectangle矩形类绘制柱状图

fig = plt.figure()
ax1 = fig.add_subplot(111)

for i in range(1, 17):
    # 生成一个个的矩形框
    rect = plt.Rectangle((i+0.25, 0), 0.5, i)
    # 将生成的矩形框加入子画布
    ax1.add_patch(rect)
ax1.set_xlim(0, 16)
ax1.set_ylim(0, 16)

Polygon-多边形

matplotlib.patches.Polygon类是多边形类。其基类是matplotlib.patches.Patch，它的构造函数如下：

class matplotlib.patches.Polygon(xy, closed=True, **kwargs)
其中：
xy是一个N×2的numpy array，为多边形的顶点。
closed为True则指定多边形将起点和终点重合从而显式关闭多边形

matplotlib.patches.Polygon类中常用的是fill类，它是基于xy绘制一个填充的多边形，它的定义如下：

matplotlib.pyplot.fill(*args, data=None, **kwargs)

关于x、y和color的序列，其中color是可选的参数，每个多边形都是由其节点的x和y位置列表定义的，后面可以选择一个颜色说明符。您可以通过提供多个x、y、[颜色]组来绘制多个多边形

fill绘制图形

x = np.linspace(0, 5 * np.pi, 1000)
y1 = np.sin(x)
y2 = np.sin(2 * x)
plt.fill(x, y1, color='g', alpha=0.3)
plt.fill(x, y2, color='r', alpha=0.3)

Wedge-契形

matplotlib.patches.Polygon类是多边形类。其基类是matplotlib.patches.Patch，它的构造函数如下：

class matplotlib.patches.Wedge(center, r, theta1, theta2, width=None, **kwargs)
一个Wedge是以坐标x,y为中心，半径为r，从θ1扫到θ2(单位是度)；
如果宽度给定，则从内半径r到外半径r画出部分楔形；
wedge中比较常见的是绘制饼状图

matplotlib.pyplot.pie的构造函数如下

matplotlib.pyplot.pie(
x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6,
shadow=False, labeldistance=1.1, startangle=0, radius=1,
counterclock=True, wedgeprops=None, textprops=None, center=0, 0,
frame=False, rotatelabels=False, *, normalize=None, data=None
)
制作数据x的饼图，每个楔子的面积用x/sum(x)表示
其中主要的参数如下：
x - 契型的形状，一维数组。
explode - 如果不是等于None，则是一个len(x)数组，它指定用于偏移每个楔形块的半径的分数。
labels - 用于指定每个契型块的标记，取值是列表或为None。
colors - 饼图循环使用的颜色序列。如果取值为None，将使用当前活动循环中的颜色。
startangle - 饼状图开始的绘制的角度。
autopct - 控制饼图内百分比设置,可以使用format字符串或者format function
'%1.1f’指小数点前后位数(如下例，百分值显示1位小数)；
shadow - 在饼图下面画一个阴影。默认值：False，即不画阴影

pie绘制饼状图

# 生成饼图的标签
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'

# 给定每个标签的数值
sizes = [15, 30, 45, 10]

# 类似与excel将饼图拉出来
explode = (0, 0.1, 0, 0)

fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True, startangle=90)
ax1.axis('equal')
'''该行代码使饼图长宽相等'''

wedge绘制饼图

fig = plt.figure()
ax = fig.add_subplot()

patches = []

# 以0.3，0.3为中心，0.2为半径，按照角度扫描顺序，分辨绘制4个子扇图
patches += [
    Wedge((0.3, 0.3), .2, 0, 54),
    Wedge((0.3, 0.3), .2, 54, 162),
    Wedge((0.3, 0.3), .2, 162, 324),
    Wedge((0.3, 0.3), .2, 324, 360)
]

colors = 100 * np.random.rand(len(patches))
'''通过random.rand函数可以返回一个或一组服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1'''

# 构造一个patch的集合
p = PatchCollection(patches, alpha=0.4)

# 将color分别赋予每个patch
p.set_array(colors)

# 将集合添加至子画布
ax.add_collection(p)

3.1.4 collections

collections类是用来绘制一组对象的集合
collections有许多不同的子类，如RegularPolyCollection, CircleCollection, Pathcollection, 分别对应不同的集合子类型。
其中比较常用的就是散点图，它是属于PathCollection子类，scatter方法提供了该类的封装，根据x与y绘制不同大小或颜色标记的散点图。 它的构造函数如下：

Axes.scatter(
self, x, y, s=None, c=None, marker=None, cmap=None, norm=None,
vmin=None, vmax=None, alpha=None, linewidths=None, verts=,
edgecolors=None, *, plotnonfinite=False, data=None, **kwargs
)
其中主要的参数如下：

        x - 数据点x轴的位置
        y - 数据点y轴的位置
        s - 尺寸大小
        c - 可以是单个颜色格式的字符串，也可以是一系列颜色
        marker - 标记的类型

scatter绘制散点图

x = list(np.arange(0, 11, 2))

# 这里的10一定得用列表框起来，不然没法得到6个10的列表，就变成60了。这边是生成y的数组，每个元素都是10
y = [10] * len(x)

# 尺寸 = 20 * 2 ** n
s = [20 * 2 ** n for n in range(len(x))]

plt.scatter(x, y, s)

3.1.5 images

images是matplotlib中绘制image图像的类，其中最常用的imshow可以根据数组绘制成图像，它的构造函数如下：

class matplotlib.image.AxesImage(
ax, cmap=None, norm=None, interpolation=None, origin=None,
extent=None, filternorm=True, filterrad=4.0, resample=False, **kwargs
)

imshow根据数组绘制图像,构造函数如下：

matplotlib.pyplot.imshow(
X, cmap=None, norm=None, aspect=None, interpolation=None,
alpha=None, vmin=None, vmax=None, origin=None, extent=None,
shape=, filternorm=1, filterrad=4.0, imlim=, resample=None,
url=None, *, data=None, **kwargs
）
主要参数解释如下：
orign - 指定绘制热图时的方向，默认值为upper,此时热图的右上角为(0, 0)
当设置为lower时，热图的左下角为(0,0)
cmap - colormap的简称，用于指定渐变色，默认的值为viridis
vmin和vmax - 用于限定数值的范围，只将vmin和vmax之间的值进行映射
interprolation - 控制热图的显示形式，是一个较难理解的参数
extent - 指定热图x轴和y轴的极值，取值为一个长度为4的元组或列表
其中，前两个数值对应x轴的最小值和最大值，后两个参数对应y轴的最小值和最大值

使用imshow画图时首先需要传入一个数组，数组对应的是空间内的像素位置和像素点的值
interpolation参数可以设置不同的差值方法

# 举个例子
methods = [
    None, 'none', 'nearest', 'bilinear', 'bicubic', 'spline16', 
    'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 
    'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos']

grid = np.random.rand(4, 4)

# subplot_kw - 字典类型，可选参数。把字典的关键字传递给add_subplot()来创建每个子图
fig, axes = plt.subplots(nrows=3, ncols=6, figsize=(9, 6), 
                         subplot_kw={'xticks': [], 'yticks': []})

for ax, interp_method in zip(axes.flat, methods):
    ax.imshow(grid, interpolation=interp_method, cmap='viridis')
    ax.set_title(str(interp_method))


# tight_layout会自动调整子图参数，使之填充整个图像区域。这是个实验特性，可能在一些情况下不工作。
# 它仅仅检查坐标轴标签、刻度标签以及标题的部分
plt.tight_layout()

4 对象容器 - Object container

容器会包含一些primitives，并且容器还有它自身的属性。
比如Axes Artist，它是一种容器，它包含了很多primitives，比如Line2D，Text；同时，它也有自身的属性，比如xscal，用来控制X轴是linear还是log的

4.1 Figure容器

matplotlib.figure.Figure是Artist最顶层的container-对象容器它包含了图表中的所有元素。
一张图表的背景就是Figure.patch的一个矩形Rectangle

当我们向图表添加Figure.add_subplot()或者Figure.add_axes()元素时，这些都会被添加到Figure.axes列表中

# 创建一个Figure
fig = plt.figure()

ax1 = fig.add_subplot(211)
ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.3])
'''位置参数，四个数分别代表了(left,bottom,width,height)'''

由于Figure维持了current axes，因此你应该手动的从Figure.axes列表中添加删除元素
而是要通过Figure.add_subplot()、Figure.add_axes()来添加元素
通过Figure.delaxes()来删除元素。
也可以迭代或者访问Figure.axes中的Axes，然后修改这个Axes的属性

# 遍历axes里的内容，并且添加网格线
fig = plt.figure()
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)

for ax in fig.axes:
    ax.grid(True)

Figure也有它自己的text、line、patch、image
可以直接通过add primitive语句直接添加
但是注意Figure默认的坐标系是以像素为单位，需要转换成figure坐标系：(0,0)表示左下点，(1,1)表示右上点

Figure容器的常见属性：
    Figure.patch属性 - Figure的背景矩形
    Figure.axes属性 - 一个Axes实例的列表（包括Subplot)
    Figure.images属性 - 一个FigureImages patch列表
    Figure.lines属性 - 一个Line2D实例的列表（很少使用）
    Figure.legends属性 - 一个Figure Legend实例列表（不同于Axes.legends)
    Figure.texts属性 - 一个Figure Text实例列表

4.2 Axes容器

matplotlib.axes.Axes是matplotlib的核心。
大量的用于绘图的Artist存放在它内部，并且它有许多辅助方法来创建和添加Artist给它自己，而且它也有许多赋值方法来访问和修改这些Artist。

和Figure容器类似，Axes包含了一个patch属性
对于笛卡尔坐标系而言，它是一个Rectangle；
对于极坐标而言，它是一个Circle;
这个patch属性决定了绘图区域的形状、背景和边框

fig = plt.figure()
ax = fig.add_subplot(111)

# axes的path是一个rectangle实例
rect = ax.patch

# 设置绿色背景
rect.set_facecolor('green')

不应该直接通过Axes.lines和Axes.patches列表来添加图表。
因为当创建或添加一个对象到图表中时，Axes会做许多自动化的工作:
它会设置Artist中figure和axes的属性，同时默认Axes的转换；
它也会检视Artist中的数据，来更新数据结构，这样数据范围和呈现方式可以根据作图范围自动调整
也可以使用Axes的辅助方法.add_line()和.add_patch()方法来直接添加

另外Axes还包含两个最重要的Artist container：

ax.xaxis：XAxis对象的实例，用于处理x轴tick以及label的绘制
ax.yaxis：YAxis对象的实例，用于处理y轴tick以及label的绘制

Axes容器的常见属性有：
artists - Artist实例列表
patch - Axes所在的矩形实例
collections - Collection实例
images - Axes图像
legends - Legend 实例
lines - Line2D 实例
patches - Patch 实例
texts - Text 实例
xaxis - matplotlib.axis.XAxis 实例
yaxis - matplotlib.axis.YAxis 实例

4.3 Axis容器

matplotlib.axis.Axis实例处理tick line、grid line、tick label以及axis label的绘制，
它包括坐标轴上的刻度线、刻度label、坐标网格、坐标轴标题。
通常你可以独立的配置y轴的左边刻度以及右边的刻度，也可以独立地配置x轴的上边刻度以及下边的刻度
刻度包括主刻度和次刻度，它们都是Tick刻度对象

每个Axis都有一个label属性，也有主刻度列表和次刻度列表。这些ticks是axis.XTick和axis.YTick实例，它们包含着line primitive以及text primitive用来渲染刻度线以及刻度文本

刻度是动态创建的，只有在需要创建的时候才创建（比如缩放的时候）。Axis也提供了一些辅助方法来获取刻度文本、刻度线位置等等

# 创建画布
fig, ax = plt.subplots()

x = range(0, 5)
y = [2, 5, 7, 8, 10]

plt.plot(x, y, '-')

# 取x轴对象
axis = ax.xaxis

# 获取刻度线位置
axis.get_ticklocs()

# 获取刻度label列表（一个text实例的列表）
'''可以通过minor=True/False控制输出minor/major'''
axis.get_ticklabels()

# 获取刻度线列表（一个line2D实例的列表）
'''可以通过minor=True/False控制输出minor/major'''
axis.get_ticklines()

# 获取轴刻度间隔
axis.get_data_interval()

# 获取轴视角间隔
axis.get_view_interval()

展示如何调整一些轴和刻度的属性

fig = plt.figure()

# 创建figure矩形实例
rect = fig.patch

# 设置该矩形为黄色背景
rect.set_facecolor('lightgoldenrodyellow')

# 创建一个axes对象，从（0.1，0.3）开始，宽和高均为0.4
ax = fig.add_axes([0.1, 0.3, 0.4, 0.4])

# 创建axse矩形实例，将ax的矩形设置为灰色
rect = ax.patch
rect.set_facecolor('lightslategray')


for label in ax.xaxis.get_ticklabels():
    label.set_color('red')
    '''调整x轴刻度标签实例（text实例）'''
    
    label.set_rotation(45)
    '''旋转角度为45度'''
    
    label.set_fontsize(16)
    '''设置字体大小'''

for line in ax.yaxis.get_ticklines():
    line.set_color('green')
    '''调用y轴刻度线条实例（line2D实例）'''
    
    line.set_markersize(25)
    '''设置marker（标记）大小'''
    
    line.set_markeredgewidth(2)
    '''设置marker(标记)粗细'''

4.4 Tick容器

matplotlib.axis.Tick是从Figure到Axes到Axis到Tick中最末端的容器对象。
Tick包含了tick、grid line实例以及对应的label

所有的这些都可以通过Tick的属性获取，常见的tick属性有
Tick.tick1line - Line2D实例
Tick.tick2line - Line2D实例
Tick.gridline - Line2D实例
Tick.label1 - Text实例
Tick.label2 - Text实例

y轴分为左右两个，因此tick1对应左侧的轴；tick2对应右侧的轴。
x轴分为上下两个，因此tick1对应下侧的轴；tick2对应上侧的轴。

# 将y轴右边轴设置成主轴，并将标签设置为美元符号且为绿色
fig, ax = plt.subplots()
ax.plot(100 * np.random.rand(20))

# 设置ticker的显示格式:美元符号，两位小数
formatter = matplotlib.ticker.FormatStrFormatter('$%1.2f')
ax.yaxis.set_major_formatter(formatter)

# 设置ticker的参数，右侧为主轴，颜色为绿色
ax.yaxis.set_tick_params(which='major', labelcolor='green', labelleft=False, labelright=True)

5 思考题

5.1

questions：primitives 和 container的区别和联系是什么？

answer：primitives是图形中的基本要素，包含一些我们在绘图区域作图时用到的标准图形对象，如Line2D, Text, Rectangle, image等；

5.2

questions：四个容器的联系和区别是么？他们分别控制一张图表的哪些要素？

answer：四个容器关系为Figure包含Axes包含Axis包含Tick；
Figure控制图表中的所有元素；
Axes控制大量的用于绘图的Artist；
Axis控制坐标轴如坐标轴上的刻度线、刻度label、坐标网格、坐标轴标题；
Tick控制图表的tickTick，包含了tick、grid line实例以及对应的label

6 绘图题

6.1

教程中展示的案例都是单一图，请自行创建数据，画出包含6个子图的线图，要求：
子图排布是 2 * 3 （2行 3列）；
线图可用教程中line2D方法绘制；
需要设置每个子图的横坐标和纵坐标刻度；
并设置整个图的标题，横坐标名称，以及纵坐标名称

# 创建一个2*3的画布,分别放这6组数据
fig = plt.figure()

for i in range(1, 7):
    x = np.random.randint(0, 10, 5)
    y = [2, 5, 7, 8, 10]
    ax = fig.add_subplot(2, 3, i)
    ax.plot(x, y)

plt.suptitle('total_title', fontsize=20, color='red', backgroundcolor='yellow')
'''设置全局标题'''

plt.xlabel('x_label')
plt.ylabel('y_label')
plt.subplots_adjust(wspace=0.1, hspace=0.1)
plt.tight_layout()

6.2

分别用一组长方形柱和填充面积的方式模仿画出下图，函数 y = -1 * (x - 2) * (x - 8) +10 在区间[2,9]的积分面积

# 生成数据
x = np.linspace(2, 9, 20000)


def cal_y(x):
    y = -1 * (x - 2) * (x - 8) + 10
    return y


y = cal_y(x)

fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)

# 绘制图像
ax.plot(x, y)

# 因为要用长方形柱子并填充，所以先给到分桶
cut = (9 - 2) / 20000

for x, y in zip(x, y):
    rect = plt.Rectangle((x, 0), cut, y)
    ax.add_patch(rect)

7 结语

这期的内容比较多，但是基础而又重要，这对理解matplotlib里面的运作原理非常有帮助。通过这一课，我对matplotlib不再停留在浑浑噩噩的阶段，至少心中有了一个框架，问题分解后，解决问题就容易多了。希望这一次学习能对大家有帮助，下节课继续～