matplotlib 第二章学习

一、概述

1.matplotlib的三层api

matplotlib的原理或者说基础逻辑是，用Artist对象在画布(canvas)上绘制(Render)图形。

matplotlib有三个层次的API：

matplotlib.backend_bases.FigureCanvas 代表了绘图区，所有的图像都是在绘图区完成的
matplotlib.backend_bases.Renderer 代表了渲染器，可以近似理解为画笔，控制如何在 FigureCanvas 上画图。
matplotlib.artist.Artist 代表了具体的图表组件，即调用了Renderer的接口在Canvas上作图。
前两者处理程序和计算机的底层交互的事项，第三项Artist就是具体的调用接口来做出我们想要的图，比如图形、文本、线条的设定。所以通常来说，我们95%的时间，都是用来和matplotlib.artist.Artist类打交道的。

2.Artist的分类

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

3. matplotlib标准用法¶

matplotlib的标准使用流程为：

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

值得一提的是，Axes是一种容器，它可能是matplotlib API中最重要的类，并且我们大多数时间都花在和它打交道上。更具体的信息会在之后容器小节说明。

一个流程示例及说明如下：

import matplotlib.pyplot as plt
import numpy as np

# step 1 
# 我们用 matplotlib.pyplot.figure() 创建了一个Figure实例
fig = plt.figure()

# step 2
# 然后用Figure实例创建了一个两行一列(即可以有两个subplot)的绘图区，并同时在第一个位置创建了一个subplot
ax = fig.add_subplot(2, 1, 1) # two rows, one column, first plot

# step 3
# 然后用Axes实例的方法画了一条曲线
t = np.arange(0.0, 1.0, 0.01)
s = np.sin(2*np.pi*t)
line, = ax.plot(t, s, color='blue', lw=2)

注意到最后一列代码：line, = ax.plot(t, s, color='blue', lw=2)

对“,”的理解：ax.plot() 返回的是只有一个元素的列表。加“,”来解压缩返回值，并从左依次对变量进行赋值。

所以可以改写为：

(line,) = ax.plot(x, np.sin(x))
[line] = ax.plot(x, np.sin(x))
line = ax.plot(x,np.sin(x))[0]

add_axes()方法

fig1=plt.figure()
ax3 = fig1.add_axes([0.1,0.1,0.8,0.8])
ax3 = fig1.add_axes([0.4,0.4,0.8,0.8])
plt.show()

对比上述两种方法,add_subplot()方法生成子图过程，简单明了，而用add_axes()方法，则生成子图的灵活性更强，完全可以实现add_subplot()方法的功能，可以控制子图的显示位置，甚至实现相互重叠的效果。

二、自定义你的Artist对象

1.Artist属性

在图形中的每一个元素都对应着一个matplotlib 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是否绘制

理解：Figure.patch属性与Axes.patch属性都是Ractangel,存储颜色、大小、透明度等实例。

函数形式：plt.figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True)

参数：

num : 图像编号或名称，数字为编号，字符串为名称
figsize : 指定figure的宽和高，单位为英寸
dpi : 指定绘图对象的分辨率，即每英寸多少个像素，缺省值为80
facecolor : 背景的颜色
edgecolor : 边框颜色
frameon : 是否显示边框

# .patch
plt.figure(figsize=(4, 3), facecolor='blue').patch
plt.axes().patch

可以看到图表的矩形框变成蓝色。

2.属性的调用方法

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

a = o.get_alpha()
o.set_alpha(0.5*a)

如果想一次设置多个属性，也可以用set方法：

o.set(alpha=0.5, zorder=2)

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

import matplotlib
# Figure rectangle的属性
matplotlib.artist.getp(fig.patch)
matplotlib.artist.getp(fig.patch,'height')

matplotlib.artist.getp(fig)

可以看到fig和fig.patch的属性值不一样，修改fig的参数并不影响fig.patch。

解释：matplotlib中的artist有两类，primitives基础对象和container容器对象。figure就是一个容器对象，而figure.patch是figure容器中的一个基础对象。可以看到patch对象的zorder=1，figure对象的zorder=0，zorder越大表示在图像上越上面，可以认为patch是画在figure上的一个背景。
因为patch是无限延伸平铺在整个figure上面的背景图片，所有从结果上看对fig设置颜色和fig.patch设置颜色没有区别。

fig = plt.figure()
fig.set_facecolor('gray')
ax = fig.add_subplot(111)

fig = plt.figure()
fig.patch.set_facecolor('gray')
ax = fig.add_subplot(111)

三、基本元素-primitives

1.2DLines

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

matplotlib中线-line的含义：它表示的可以是连接所有顶点的实线样式，也可以是每个顶点的标记。此外，这条线也会受到绘画风格的影响，比如，我们可以创建虚线种类的线。

它的构造函数：

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:点的标记，详细可参考markers API
• markersize:标记的size

其他详细参数可参考Line2D官方文档

a. 如何设置Line2D的属性

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

1. 直接在plot()函数中设置

参考：https://blog.csdn.net/qq_41870157/article/details/104328111 plt.plot()函数参数详解

官方文档：https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot

参数较多，多用多练。

import matplotlib.pyplot as plt
x = range(0,5)
y = [2,5,7,8,10]
plt.plot(x,y, linewidth=2,color='#008100',marker='*',linestyle='-.') #color：RGB

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

x = range(0,5)
y = [2,5,7,8,10]
line, = plt.plot(x, y, '-')
line.set_antialiased(False) # 关闭抗锯齿功能
line.set(color='b',marker='p',linestyle=':')

用上述调用属性方法来修改line对象

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

x = range(0,5)
y = [2,5,7,8,10]
lines = plt.plot(x, y)
plt.setp(lines, color='r', linewidth=10)

b. 如何绘制lines

1) 绘制直线line 常用的方法有两种

• pyplot方法绘制
• Line2D对象绘制

1.pyplot方法绘制

import matplotlib.pyplot as plt
x = range(0,5)
y = [2,5,7,8,10]
plt.plot(x,y) 

2.Line2D对象绘制

import matplotlib.pyplot as plt
from matplotlib.lines import Line2D      

fig = plt.figure()
ax = fig.add_subplot(111)
line = Line2D(x, y)
ax.add_line(line)
ax.set_xlim(min(x), max(x))
ax.set_ylim(min(y), max(y))
line.set_color("r")
line.set_marker('*')
fig.set_facecolor('b')
plt.show()

总结：线的相关属性对line设置，画布的相关属性对fig，坐标轴的相关属性、图例等对ax设置

2) 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的线条宽度

import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
x = np.arange(10)
y = 2.5 * np.sin(x / 20 * np.pi)
yerr = np.linspace(0.05, 0.2, 10)
plt.errorbar(x, y + 3, yerr=yerr, label='both limits (default)',ecolor='g',fmt='k*--',elinewidth=3)
plt.legend(loc=2)

2. patches

matplotlib.patches.Patch类是二维图形类。它的基类是matplotlib.artist.Artist，它的构造函数：
详细清单见 matplotlib.patches API

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

a. Rectangle-矩形

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

class matplotlib.patches.Rectangle(xy, width, height, angle=0.0, **kwargs)

在实际中最常见的矩形图是hist直方图和bar条形图。

1) 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绘制直方图

参考：https://www.cnblogs.com/zyg123/p/10504645.html

import matplotlib.pyplot as plt
import numpy as np 
np.random.seed(0)
x=np.random.randint(0,100,100) #生成【0-100】之间的100个数据,即 数据集 
bins=np.arange(0,101,10) #设置连续的边界值，即直方图的分布区间[0,10],[10,20]... 
plt.hist(x,bins,color='fuchsia',alpha=0.5,density=True,histtype='step',log=True)
#alpha设置透明度，0为完全透明 ,显示频率统计结果
plt.xlabel('scores') 
plt.ylabel('count') 
plt.xlim(0,100)#设置x轴分布范围 plt.show()

Rectangle矩形类绘制直方图

import pandas as pd
import re
df = pd.DataFrame(columns = ['data'])
#将x赋值到df的data列
df.loc[:,'data'] = x
#将data列分组
df['fenzu'] = pd.cut(df['data'], bins=bins, right = False,include_lowest=True)

df_cnt = df['fenzu'].value_counts().reset_index()
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)
#用Rectangle把hist绘制出来
import matplotlib.pyplot as plt

fig = plt.figure()
ax1 = fig.add_subplot(111)
#rect1 = plt.Rectangle((0,0),10,10)
#ax1.add_patch(rect)
#ax2 = fig.add_subplot(212)
for i in df_cnt.index:
    rect =  plt.Rectangle((df_cnt.loc[i,'mini'],0),df_cnt.loc[i,'width'],
                          df_cnt.loc[i,'fenzu'])
#rect2 = plt.Rectangle((10,0),10,5)
    ax1.add_patch(rect)
#ax1.add_patch(rect2)
ax1.set_xlim(0, 100)
ax1.set_ylim(0, 16)
plt.show()

看到这里，忘记了正则表达式。

参考：

https://blog.csdn.net/ysy_1_2/article/details/104790079

https://www.cnblogs.com/xieshengsen/p/6727064.html

'\[(.*)\,'：. 代表任何字符，*代表重复上一个字符0次或者多次，()起来是把里面看成一个整体，则这个正则表达式的意思是[与,之间的数字。返回的list中取第一个位置上的值。

正则 re.findall 的简单用法（返回string中所有与pattern相匹配的全部字串，返回形式为数组）

plt.rectangle画柱形图时，是一个柱子一个柱子画的。第一个参数(xy)传入柱子左下角的坐标(元组的形式)，第二个参数传入柱子的宽，第三个参数传入柱子的高，后面也可以传入颜色等参数。基于此就可以给不同的柱子不同的样式。

fig = plt.figure()
ax1 = fig.add_subplot(111)
rect1 = plt.Rectangle((0,0),10,8)
ax1.add_patch(rect1)
rect2 = plt.Rectangle((10,5),10,10,color='r')
ax1.add_patch(rect2)
ax1.set_xlim(0, 100)
ax1.set_ylim(0, 16)

2) 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的标签

bar绘制柱状图

import matplotlib as mpl
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)
plt.legend()

Ractangle矩形类绘制柱状图

#import matplotlib.pyplot as plt
fig = plt.figure()
ax2 = fig.add_subplot(111)

for i in range(0,17):
    rect1 =  plt.Rectangle((i+0.25,0),0.5,i,color='y')
    ax2.add_patch(rect1)
ax2.set_xlim(-1, 18)
ax2.set_ylim(0, 16)
plt.show()

b. 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绘制图形

import matplotlib.pyplot as plt
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)

a=np.c_[x.reshape(x.shape[0],-1),y1.reshape(y1.shape[0],-1)]
fig = plt.figure()
ax = fig.add_subplot(111)
poly = plt.Polygon(a,alpha=0.3,color='g')
ax.add_patch(poly)
ax.set_xlim(0,16)
ax.set_ylim(-1,1)

c. Wedge-契形¶

matplotlib.patches.Wedge类是多边形类。其基类是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)表示。
其中最主要的参数是前4个：

• x：契型的形状，一维数组。
• explode：如果不是等于None，则是一个len(x)数组，它指定用于偏移每个楔形块的半径的分数。
• labels：用于指定每个契型块的标记，取值是列表或为None。
• colors：饼图循环使用的颜色序列。如果取值为None，将使用当前活动循环中的颜色。
• startangle：饼状图开始的绘制的角度。

pie绘制饼状图

import matplotlib.pyplot as plt 
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
sizes = [15, 30, 45, 10] 
explode = (0, 0.1, 0, 0) 
fig1, ax1 = plt.subplots() 
ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True, startangle=90)   #autopct来修改数据显示格式
ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle. 
plt.show()

wedge绘制饼图

import matplotlib.pyplot as plt 
from matplotlib.patches import Circle, Wedge
from matplotlib.collections import PatchCollection

fig = plt.figure()
ax1 = fig.add_subplot(111)
theta1 = 0
sizes = [15, 30, 45, 10] 
patches = []
patches += [
    Wedge((0.3, 0.3), .2, 0, 54,color='r',width=0.05),  #从0.2-0.05=0.15到0.2画饼图           
    Wedge((0.3, 0.3), .2, 54, 162,color='y'),  
    Wedge((0.3, 0.3), .2, 162, 324,color='b'),              
    Wedge((0.3, 0.3), .2, 324, 360,color='k'),  
]

for i in range(4):
    ax1.add_patch(patches[i])

3. 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)

其中最主要的参数是前5个：

x：数据点x轴的位置

y：数据点y轴的位置

s：尺寸大小

c：可以是单个颜色格式的字符串，也可以是一系列颜色

marker: 标记的类型

scatter绘制散点图

x = [0,2,4,6,8,10] 
y = [10]*len(x) 
s = [20*2**n for n in range(len(x))] 
plt.scatter(x,y,s=s) 
plt.show()

利用axes.scatter绘制散点图

fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(x,y,s=s,marker='*',color='k')

4. 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）

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

import matplotlib.pyplot as plt
import numpy as np
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)

fig, axs = plt.subplots(nrows=3, ncols=6, figsize=(9, 6),
                        subplot_kw={'xticks': [], 'yticks': []})

for ax, interp_method in zip(axs.flat, methods):
    ax.imshow(grid, interpolation=interp_method, cmap='gray') #色谱
    ax.set_title(str(interp_method)) #设置图的题目

plt.tight_layout()  #排列的开一些
plt.show()

参考：https://www.cnblogs.com/denny402/p/5122594.html matplotlib.pyplot.imshow()函数使用方法

cmap: 颜色图谱（colormap), 默认绘制为RGB(A)颜色空间

https://liam.page/2014/09/11/matplotlib-tutorial-zh-cn/

REF:

https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.imshow

https://blog.csdn.net/iamzhangzhuping/article/details/50803636

https://stackoverflow.com/questions/36431496/typeerror-invalid-dimensions-for-image-data-when-plotting-array-with-imshow

四、对象容器 - Object container

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

1. Figure容器

matplotlib.figure.Figure是Artist最顶层的container-对象容器，它包含了图表中的所有元素。一张图表的背景就是在Figure.patch的一个矩形Rectangle。
当我们向图表添加Figure.add_subplot()或者Figure.add_axes()元素时，这些都会被添加到Figure.axes列表中。

fig = plt.figure()
ax1 = fig.add_subplot(211) # 作一幅2*1的图，选择第1个子图
ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.3]) # 位置参数，四个数分别代表了(left,bottom,width,height)
print(ax1) 
print(fig.axes) # fig.axes 中包含了subplot和axes两个实例, 刚刚添加的

由于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)
ax3 = fig.add_axes([0.5,0.3,0.8,0.4])
for ax in fig.axes:
    ax.grid(True)
    ax.plot(range(5),range(5))

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实例列表

2. Axes容器¶

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

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

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

fig = plt.figure()
ax = fig.add_subplot(111)
rect = ax.patch  # axes的patch是一个Rectangle实例
rect.set_facecolor('green')
fig.patch.set_facecolor('b')

可以看到fig.patch决定了外侧坐标系区域的颜色。

Axes有许多方法用于绘图，如.plot()、.text()、.hist()、.imshow()等方法用于创建大多数常见的primitive(如Line2D，Rectangle，Text，Image等等）。在primitives中已经涉及，不再赘述。

Subplot就是一个特殊的Axes，其实例是位于网格中某个区域的Subplot实例。其实你也可以在任意区域创建Axes，通过Figure.add_axes([left,bottom,width,height])来创建一个任意区域的Axes，其中left,bottom,width,height都是[0—1]之间的浮点数，他们代表了相对于Figure的坐标。

你不应该直接通过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 实例

3. Axis容器

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

刻度包括主刻度和次刻度，它们都是Tick刻度对象。

Axis也存储了用于自适应，平移以及缩放的data_interval和view_interval。它还有Locator实例和Formatter实例用于控制刻度线的位置以及刻度label。

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

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

# 不用print，直接显示结果
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"

fig, ax = plt.subplots()
x = range(0,5)
y = [2,5,7,8,10]
plt.plot(x, y, '-')

axis = ax.xaxis # axis为X轴对象
axis.get_ticklocs()     # 获取刻度线位置
axis.get_ticklabels()   # 获取刻度label列表(一个Text实例的列表）。 可以通过minor=True|False关键字参数控制输出minor还是major的tick label。
axis.get_ticklines()    # 获取刻度线列表(一个Line2D实例的列表）。 可以通过minor=True|False关键字参数控制输出minor还是major的tick line。
axis.get_data_interval()# 获取轴刻度间隔
axis.get_view_interval()# 获取轴视角（位置）的间隔

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wx4wz4CB-1608306184931)(/Users/mao/Documents/机器学习/datawhale/matplotlib学习/第二章 /23.jpg)]

下面的例子展示了如何调整一些轴和刻度的属性(忽略美观度，仅作调整参考)：

fig = plt.figure(figsize=(12,8)) # 创建一个新图表
rect = fig.patch   # 矩形实例并将其设为黄色
rect.set_facecolor('lightgoldenrodyellow')

ax1 = fig.add_axes([0.1, 0.3, 0.4, 0.4]) # 创一个axes对象，从(0.1,0.3)的位置开始，宽和高都为0.4，
rect = ax1.patch   # ax1的矩形设为灰色
rect.set_facecolor('lightslategray')
ax1.grid(True)

for label in ax1.xaxis.get_ticklabels(): 
    # 调用x轴刻度标签实例，是一个text实例
    label.set_color('red') # 颜色
    label.set_rotation(45) # 旋转角度
    label.set_fontsize(16) # 字体大小

for line in ax1.yaxis.get_ticklines():
    # 调用y轴刻度线条实例, 是一个Line2D实例
    line.set_color('green')    # 颜色
    line.set_markersize(5)    # marker大小
    line.set_markeredgewidth(2)# marker粗细

plt.show()

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轴右边轴设为主轴，并将标签设置为美元符号且为绿色

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

fig, ax = plt.subplots()
ax.plot(100*np.random.rand(20))

# 设置ticker的显示格式
formatter = matplotlib.ticker.FormatStrFormatter('$%1.2f')  #改变坐标轴数字显示格式
ax.yaxis.set_major_formatter(formatter)
x_style = matplotlib.ticker.FormatStrFormatter('%1.3f')
ax.xaxis.set_major_formatter(x_style)
# 设置ticker的参数，右侧为主轴，颜色为绿色
ax.yaxis.set_tick_params(which='major', labelcolor='green',
                         labelleft=False, labelright=True)

plt.show()

五 思考题

1. primitives 和 container的区别和联系是什么？
2. 四个容器的联系和区别是么？他们分别控制一张图表的哪些要素？

答：1.primitives是基本图形要素，包括曲线、文本、矩形、图像等。container是容器，包括Figure、Axes、Axis。figure是底层的画布，axes决定是绘图区域里的形状、背景、边框，这里面就可以放一些基本图形要素。

两者联系：container是用来装基本要素primitives的。

2.联系：由大到小 Figure–>Axes–>Axis–>Tick
Figure：最顶层的对象容器，决定着画布的大小，绘图区域外的颜色等。
Axes：决定是绘图区域里的形状、背景、边框，这里面就可以放一些基本图形要素。
Axis：实例处理tick line、grid line、tick label以及axis label的绘制。
Tick：包含了tick、grid line实例以及对应的label。

六 绘图题

1.1subplots方法

import matplotlib.pyplot as plt
import numpy as np
x=np.arange(5)
np.random.seed(44)
y=np.random.randint(1,5,5)
fig,ax=plt.subplots(2,3,figsize=(12,8))
for i in range(2):
    for j in range(3):
        ax[i][j].plot(x,y)
        ax[i][j].set_title('line')
        ax[i][j].set_xlabel('Xaxis')
        ax[i][j].set_ylabel('yaxis')
plt.tight_layout()
plt.show()

2.1

#分别用一组长方形柱和填充面积的方式模仿画出下图，函数 y = -1 * (x - 2) * (x - 8) +10 在区间[2,9]的积分面积
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0,10,0.2)
y = (-1)*(x-2)*(x-8)+10
x1= np.arange(2,9.2,0.2)
y1= (-1)*(x1-2)*(x1-8)+10
fig = plt.figure()
ax = fig.add_subplot()
ax.plot(x,y,color='r')
ax.set_xlim(-1,11)
ax.set_ylim(0,20)

ax.bar(x1,y1,alpha=0.5,width=0.15,color='gray',align='edge')

2.2

import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0,10,0.2)
y = (-1)*(x-2)*(x-8)+10
x1 = np.arange(2,9.2,0.2)
y1 = (-1)*(x1-2)*(x1-8)+10
x1=np.insert(x1,0,2)
x1=np.append(x1,9)
y1=np.insert(y1,0,0)
y1=np.append(y1,0)
X = np.c_[x1.reshape(x1.shape[0],-1),y1.reshape(y1.shape[0],-1)]
fig = plt.figure()
ax = fig.add_subplot()
ax.plot(x,y,color='r')
ax.set_xlim(-1,11)
ax.set_ylim(0,20)
poly=plt.Polygon(X,alpha=0.5,color='gray')
ax.add_patch(poly)