matplotlib.backend_bases. FigureCanvas ： 代表了一个绘图区，在这个绘图区上图表被绘制

matplotlib.backend_bases. Renderer ： 代表了渲染器，它知道如何在绘图区上绘图。

matplotlib.artist. Artist ： 代表了图表组件，它知道如何利用渲染器在绘图区上绘图。

通常用于有95%以上的时机都是与 matplotlib.artist.Artist 类打交道，它是高层次的绘图控制。

2.matplotlib 中有两种 Artist

primitive ： 代表了我们在绘图区域上绘制的基础的绘图组件，比如 Line2D ， Rectangle ， Text 以及 AxesImage 等等。

container ： 代表了放置 primitive 的那些绘图组件。比如 Axis 、 Axes 以及 Figure ，如图所示

3.matplotlib的标准使用流程

创建一个 Figure 实例对象 fig

使用 fig 实例创建一个或者多个 Axes 实例，或者创建一个或者多个 Subplot 实例

使用 Axes 实例的方法来创建 primitive

4.Artist的属性

（1）每个在图形中出现的元素都是 Artist， 其属性有：

Figure.patch 属性： 是一个 Rectangle ，代表了图表的矩形框，它的大小就是图表的大小， 并且可以通过它设置图表的背景色和透明度。

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

所有的 Artist 有下列属性：

.alpha 属性： 透明度。值为0--1之间的浮点数

.animated 属性： 一个布尔值，表示是否用于加速动画绘制

.axes 属性： 返回这个 Artist 所属的 axes ，可能为 None

.clip_box 属性： 用于剪切 Artist 的 bounding box

.clip_on 属性： 是否开启 clip

.clip_path 属性： Artist 沿着该 path 执行 clip

.contains 属性： 一个 picking function 用于测试 Artist 是否包含 pick point

.figure 属性： 该 Artist 所属的 Figure ，可能为 None

.gid 属性： 该 Artist 的 id 字符串

.label ： 一个 text label

.picker ： 一个 python object 用于控制 object picking

.transform ： 转换矩阵

.url 属性： 一个 url string ，代表本 Artist

.visible ： 布尔值，控制 Artist 是否绘制

.zorder ： 决定了 Artist 的绘制顺序。 zorder 越小就越底层，则越优先绘制。

（2）获取属性：

fig.get_alpha() # 获取fig的alpha属性值

matplotlib.artist.getp(fig) # 一次获取 fig 的所有属性。

pyplot.getp(fig,"alpha") 来获取属性（一次只能返回一个属性），如果指定属性名，则返回对象的该属性值；如果不指定属性名，则返回对象的所有的属性和值。

（3）设置属性：

fig.set_alpha(0.5) # 设置fig的alpha值为0.5

fig.set(alpha=0.5,zorder=2) #  一次设置多个属性

pyplot.setp(fig,alpha=0.5,zorder=2) 来设置属性（一次可以设置多个属性）。

import matplotlib.pyplot as plt
fig = plt.figure() #创建图形
fig.patch # 图表矩形
<matplotlib.patches.Rectangle at 0x1e16abda940>
ax = fig.add_axes([0,0,1,1]) # left,bottom,width,height
ax.patch # Axes矩形
<matplotlib.patches.Rectangle at 0x1e16bfbec88>
import matplotlib
matplotlib.artist.getp(fig) # 获取所有属性
agg_filter = None
    alpha = None
    animated = False
    axes = [<matplotlib.axes._axes.Axes object at 0x000001E16...
    children = [<matplotlib.patches.Rectangle object at 0x000001E...
    clip_box = None
    clip_on = True
    clip_path = None
    constrained_layout = False
    constrained_layout_pads = (0.04167, 0.04167, 0.02, 0.02)
    contains = None
    default_bbox_extra_artists = [<matplotlib.axes._axes.Axes object at 0x000001E16...
    dpi = 72.0
    edgecolor = (1.0, 1.0, 1.0, 0.0)
    facecolor = (1.0, 1.0, 1.0, 0.0)
    figheight = 4.0
    figure = None
    figwidth = 6.0
    frameon = True
    gid = None
    label = 
    path_effects = []
    picker = None
    rasterized = None
    size_inches = [6. 4.]
    sketch_params = None
    snap = None
    tight_layout = False
    transform = IdentityTransform()
    transformed_clip_path_and_affine = (None, None)
    url = None
    visible = True
    window_extent = TransformedBbox(     Bbox(x0=0.0, y0=0.0, x1=6.0, ...
    zorder = 0
plt.getp(fig, "constrained_layout_pads")
# (0.04167, 0.04167, 0.02, 0.02)

二、container

1. Figure类

1.1 matplotlib.figure.Figure 是 最顶层 的 container Artist ，它包含了图表中的所有元素。

Figure.patch 属性： Figure 的背景矩形

Figure.axes 属性： 持有的一个 Axes 实例的列表（包括 Subplot )

Figure.images 属性： 持有的一个 FigureImages patch 列表

Figure.lines 属性： 持有一个 Line2D 实例的列表（很少使用）

Figure.legends 属性： 持有的一个 Figure Legend 实例列表（不同于 Axes.legends )

Figure.patches 属性： 持有的一个 Figure pathes 实例列表（很少使用)

Figure.texts 属性： 持有的 Figure Text 实例列表

其他的属性：

Figure.figsize 属性： 图像的尺寸， (w,h) ，以英寸为单位

Figure.dpi 属性： 图像分辨率

Figure.facecolor 属性： 背景色

Figure.edgecolor 属性： edge color

Figure.linewidth ： edge linewidth

Figure.frameon ： 如果为 False ，则不绘制图像

Figure.subplotpars ： 一个 SubplotParams 实例

Figure.tight_layout ： 如果为 False ，则使用 subplotpars ；否则使用 tight_layout() 调整 subplot parameters

1.2 当你执行 Figure.add_subplot() 或者 Figure.add_axes() 时，这些新建的 Axes 都被添加到 Figure.axes 列表中。

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

1.4 可以通过 Figure.gca() 获取 current axes ，通过 Figure.sca() 设置 current axes 。

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

import matplotlib.pyplot as plt
import matplotlib
fig = plt.figure() #创建图形
ax = fig.add_axes([0,0,1,1])
ax2 = fig.add_subplot(221)
l1 = matplotlib.lines.Line2D([0,1],[0,1],transform=fig.transFigure,figure=fig)
l2 = matplotlib.lines.Line2D([0,1],[1,0],transform=fig.transFigure,figure=fig)
fig.lines.extend([l1,l2])
fig.canvas.draw()
fig.show()
若未提供，则创建一个新的figure。
如果给出了一个整数，而且某个现有的figure对象的number属性刚好等于这个整数，则激活该figure并且返回该figure；否则创建一个新的figure
如果是个字符串，则创建一个新的figure，并且将window title设置为该字符串。
figsize：一对整数的元组。给出了英寸为单位的高度和宽度。默认由rc的 figure.figsize给出
dpi：一个整数，给出figure的分辨率。默认由rc的 figure.dpi给出
facecolor：背景色。若未提供，则由rc的 figure.facecolor给出
edgecolor：border color。若未提供，则由rc的 figure.edgecolor给出返回一个figure
1.7 Figure的一些方法
（1）add_axes
add_axes(*args, **kwargs)
作用：创建一个Axes对象。如果已经存在同样位置同样参数的一个Axes，则返回该Axes，并将其设为current Axes。
rect:一个元组，代表了(left,bottom,width,height)，它是第一个位置参数
axisbg：一个color，背景色
frameon：布尔值，是否display frame
sharex：另一个Axes对象，与该Axes共享 xaxis
sharey：另一个Axes对象，与该Axes共享 yaxis
projection：坐标系类型。projection='polar'也等价于polar=True
aspect：一个数值，指定x和y轴每个单位的尺寸比例。也可以设定为字符串'equal'/'auto'
关键字参数为projection+Axes的合法关键字
　　如果你想在同样的一个rect创建两个Axes，那么你需要设置label参数。不同的Axes通过不同的label鉴别。如果你使用了fig.delaxes()从Figure中移除了ax，那么你可以通过fig.add_exes(ax)来将其放回。
（2）add_subplot
add_subplot(*args,**kwargs)
作用：创建一个subplot。如果已经存在同样位置同样参数的一个subplot，则返回该subplot，并将其设为current Axes。
关键字参数为projection+Axes的合法关键字。projection：坐标系类型。projection='polar'也等价于polar=True
位置参数为：add_subplot(nrows, ncols, plot_number)。表示nrows行， nclos列每个单元格是一个sub-axes。plot_number给出了指定的sub-axes，从 1开始。最大为nrows*ncols。当这三个数字都是个位数时，可以使用一个三位数代替，每位代表一个数。
axisbg：一个color，背景色
frameon：布尔值，是否display frame
sharex：另一个Axes对象，与该Axes共享 xaxis
sharey：另一个Axes对象，与该Axes共享 yaxis
projection：坐标系类型。projection='polar'也等价于polar=True
aspect：一个数值，指定x和y轴每个单位的尺寸比例。也可以设定为字符串'equal'/'auto'
add_axes和add_subplot的区别：
生成子图subplot的时候，必须带着轴域（Axes）方法，客观上就是生成了一个可以画图的子图；
add_subplot方法在生成子图过程，简单明了，而用add_axes方法，则生成子图的灵活性更强，完全可以实现add_subplot方法的功能，可以控制子图显示位置，甚至实现相互重叠的效果。
（3）autofmt_xdate
autofmt_xdate(bottom=0.2, rotation=30, ha='right')
功能：用于设置Date ticklabel的位置。该函数主要用于当xtick为日期，可能会重叠，因此可以旋转一个角度
bottom：设置距离subplot底部的位置。
rotation：设置了xtick label的旋转角度。
ha：设置xtick label的对其方式。
（4）clear()
功能：清除一个figure
（5）clf()
clf(keep_observers=False)
功能：清除一个figure
如果keep_observers=True，则gui仍然会跟踪figure中的axes。
（6）colorbar()
colorbar(mappable, cax=None, ax=None, use_gridspec=True, **kw)
功能：为mappable创建一个colorbar。
mapple：一个ScalarMapple实例。它可以是Image/ContourSet...
cax：指定在哪个axes中绘制colorbar，也可以是None
ax：None | parent axes object(s) from which space for a new colorbar axes will be stolen.
use_gridspec：False | 如果cax为None，则将创建一个新的cax作为Axes的实例。 如果ax是Subplot的实例且use_gridspec为True，则使用grid_spec模块将cax创建为Subplot的实例
（7）delaxes(a)
功能：从figure中移除axes
（8）gca(**kwargs)
功能：返回current axes，如果不存在则创建一个。
（9）get_children()
功能：获取figure中包含的artists
（10）get_dpi/get_edgecolor/get_facecolor/get_figheight/get_figwidth/get_frameon/get_tight_layout...
功能：获取对应的属性值
（11）get_size_inches()
功能：返回fig的当前尺寸（单位为英寸，1in=2.54cm）
（12）legend()
legend(handles, labels, *args, **kwargs)
功能：创建图例
handles：是一个Lin2D/Patch等实例的一个序列
labels：是个字符串序列，用于给上述实例添加图例说明
loc：指定图例的位置。可以是字符串'best'/'upper right'/'upper left' /'lower left'/'lower right'/'right'/'center left'/'center right' /'lower center'/'upper center'/'center'。你也可以指定坐标(x,y)，其中(0,0)是左下角，(1,1)是右上角
numpoint/scatterpoints：图例上每个图例线的点数
fancybox：如果为True，图例的边框采用圆角矩形
shadow：如果为True，图例添加背影
ncol：列数
title：图例的标题
framealpha：一个浮点数，从0到 1，图例的透明度
frameon：一个布尔值，如果为True，则绘制图例的背景框。否则不绘制。
（13）savefig()
savefig(fname, dpi=None, facecolor='w', edgecolor='w',orientation='portrait', papertype=None, format=None, transparent=False, bbox_inches=None, pad_inches=0.1,frameon=None)
功能：保存图像
fname：带路径的文件名。
dpi：保存的分辨率。
facecolor/edgecolor：figure rectangle的背景色和边线颜色
orientation：可以为'landscape' | 'portrait'
format：图片格式。可以为'png'/'pdf'/'svg'/'eps'...
transparent：如果为True，设置figure和axes背景透明（除非你设置了facecolor/edgecolor）
frameon：如果为False，则图形背景透明
（14）sca(a)




    

功能：设置a为current axes并返回它
（15）set_dpi/set_edgecolor...
功能：设置相关属性
（16）show(warn=True)
功能：显示图像。如果warn=True，则开启警报
（17）subplots_adjust()
subplots_adjust(left=None, bottom=None, right=None, top=None,wspace=None, hspace=None)
功能：调整subplot的位置
（18）suptitle(t, **kwargs)
功能：设置图像标题
t：为标题字符串。关键字参数就是Text对象的参数：
x：在图形坐标系中，标题的横坐标（范围 0～1）
y：在图形坐标系中，标题的纵坐标（范围 0～1）
horizontalalignment：标题水平对齐方式，默认为'center'
verticalalignment：标题垂直对齐方式，默认为'top'
fontsize：字体大小
（19）text(x, y, s, *args, **kwargs)
功能：添加文本
x：在图形坐标系中，标题的横坐标（范围 0～1）
y：在图形坐标系中，标题的纵坐标（范围 0～1）
s：文本字符串
（20）tight_layout()
tight_layout(renderer=None, pad=1.08, h_pad=None, w_pad=None, rect=None)
功能：调整subplot的间距
pad：设定subplot和figure edge之间的距离。单位为font-size
h_pad/w_pad：subplot之间的高距/宽距。
2. Axes类
2.1 Axes类是matplotlib的核心，Axes代表了plotting area。大量的用于绘图的Artist存放在它内部，并且它有许多辅助方法来创建和添加Artist给它自己，而且它也有许多赋值方法来访问和修改这些Artist。
　　它有许多方法用于绘图，如.plot()、.text()、.hist()、.imshow()等方法用于创建大多数常见的primitive(如Line2D，Rectangle，Text，Image等等）。这些方法会创建primitive Artist实例，并且添加这些实例到对应的container上去，然后必要的时候会绘制这些图形。
2.2 Subplot就是一个特殊的Axes，其实例是位于网格中某个区域的Subplot实例。其实你也可以在任意区域创建Axes，通过Figure.add_axes([left,bottom,width,height])来创建一个任意区域的Axes，其中left，bottom，width，height都是[0-1]之间的浮点数，他们代表了相对于Figure的坐标。
import matplotlib.pyplot as plt
import matplotlib
fig = plt.figure()
ax = fig.add_axes([0.15,0.1,0.7,0.3])
x = np.arange(0.0,1.0,0.01)
y = np.sin(2 * np.pi * x)
line, = ax.plot(x,y,color='blue',lw=2)
plt.show()
2.3 Axes包含了一个.patch属性，对于笛卡尔坐标系而言，它是一个Rectangle；对于极坐标而言，它是一个Circle。这个.patch属性决定了plotting region的形状、背景和边框。
import matplotlib.pyplot as plt
import matplotlib
fig = plt.figure() # 创建新图表
ax = fig.add_subplot(111) # 创建Axes
rect = ax.patch
rect.set_color('yellow')
plt.show()
2.4 当调用Axes.plot()方法时，该方法会创建一个matplotlib.lines.Line2D实例，然后会利用传给.plot()的关键字参数来更新该Line2D的属性，然后将这个Line2D添加到Axes.lines列表中。该方法返回的刚创建的Line2D列表，因为你可以传递多个(x,y)值从而创建多个Line2D。
　　当调用Axes.hist()方法时，类似于.plot()方法，不过它会添加patches到Axes.patches列表。
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
fig = plt.figure() # 创建新图表
ax = fig.add_subplot(111) # 添加Axes
x, y = np.random.rand(2,200)
line, = ax.plot(x,y,'-',color='blue',linewidth=10)
n,bins,rectangles = ax.hist(np.random.randn(200),50,facecolor='green')
rectangles #<a list of 50 Patch objects>
fig.show()
2.5  你不应该直接通过Axes.lines和Axes.patches列表来添加图表。因为当你通过.plot()和.hist()等方法添加图表时，matplotlib会做许多工作而不仅仅是添加绘图组件到Axes.lines或者Axes.patches列表中。
但是你可以使用Axes的辅助方法.add_line()和.add_patch()方法来添加。
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
fig = plt.figure() # 创建新图表
ax = fig.add_subplot(111)
rect = matplotlib.patches.Rectangle((1,1),width=5,height=12)#创建Rectangle
type(rect.axes) # 未绑定Axes NoneType
rect.get_transform()
CompositeGenericTransform(
    BboxTransformTo(
        Bbox(x0=1.0, y0=1.0, x1=6.0, y1=13.0)),
    Affine2D(
        [[1. 0. 0.]
         [0. 1. 0.]
         [0. 0. 1.]]))
ax.add_patch(rect) # rect添加到ax
rect.axes # 绑定了Axes
<matplotlib.axes._subplots.AxesSubplot at 0x1e16c330cc0>
2.6  下面是Axes用于创建primitive Artist以及添加他们到相应的container中的方法：
ax.annotate()：创建text annotation（Annotate对象），然后添加到ax.texts列表中。
ax.bar()：创建bar chart（Rectangle对象），然后添加到ax.patches列表中。
ax.errorbar()：创建error bar plot（Line2D对象和Rectangle对象），然后添加到ax.lines 列表中和ax.patches列表中。
ax.fill()：创建shared area（Polygon对象），然后添加到ax.patches列表中
ax.hist()：创建histogram（Rectangle对象），然后添加到ax.patches列表中。
ax.imshow()：创建image data（AxesImage对象），然后添加到ax.images列表中。
ax.legend()：创建axes legends（Legend对象），然后添加到ax.legends列表中。
ax.plot()：创建xy plot（Line2D对象），然后添加到ax.lines列表中。
ax.scatter()：创建scatter charts（PolygonCollection对象），然后添加到 ax.collections列表中。
ax.text()：创建text（Text对象），然后添加到ax.texts列表中。
2.7  另外Axes还包含两个最重要的Artist container：
ax.xaxis：XAxis对象的实例，用于处理x轴tick以及label的绘制
ax.yaxis：YAxis对象的实例，用于处理y轴tick以及label的绘制
　　Axes包含了许多辅助方法来访问和修改XAxis和YAxis，这些辅助方法其实内部调用的是XAxis和YAxis的方法。因此通常情况下你不需要直接调用XAxis和YAxis的方法。
ax = fig.add_axes([0.15,0.1,0.7,0.3])
ax.xaxis
# <matplotlib.axis.XAxis at 0x1e16c38fa58>
ax.yaxis
# <matplotlib.axis.YAxis at 0x1e16c0ed2e8>
2.8 Axes的方法
（1）acorr(x, **kwargs)
功能：绘制序列x的自相关
x：一个标量序列。对x执行自相关
normed：一个布尔值，如果为True，则对数据正则化处理
maxlags：一个整数，默认为10.它给出了要展示多少个lag。如果为None，则使用所有的2*len(x)-1个
其他kwargs：控制了Line2D的属性
返回： (lags,c,lin,b)
lags：是一个长度为2*maxlags+的lag vector
c：是长度为2*maxlags+的自相关向量
line：是一个Line2D实例
b：是x-axis
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
x,y = np.random.randn(2,100)
fig = plt.figure() # 创建新图表
ax1 = fig.add_subplot(211)
ax1.acorr(x,usevlines=True,maxlags=50,normed=False,lw=2)
ax1.grid(True)
ax1.axhline(0,color='black',lw=2)
ax2 = fig.add_subplot(212,sharex=ax1)
ax2.acorr(x,usevlines=False,maxlags=50,normed=True,lw=2)
ax2.grid(True)
ax2.axhline(0,color='black',lw=2)
plt.show()
（2）add_artist(a)
功能：添加a（一个Artist对象）到axes上
（3）add_collection(collection, autolim=True)
功能：添加Collection实例到axes上
（4）add_container(container)
功能：添加Container实例到axes上
（5）add_image(image)
功能：添加Image实例到axes上
（6）add_line(line)
功能：添加Line2D实例到axes上
（7）add_patch(p)
功能：添加Patch实例到axes上
（8）add_table(tab)
功能：添加Table实例到axes上
（9）annotate(*args, **kwargs)
功能：对坐标点(x,y)绘制注解
s：注解字符串
xy：一个长度为2的序列，给出了坐标点的(x,y)坐标
xytext：一个长度为2的序列，给出了注解字符串的(x,y)坐标
xycoords：给出了坐标点的(x,y)所对应的坐标系。可以为'figure points'、 'figure pixels'、'figure fraction'、'axes points'、 'axes pixels'、'axes fraction'、'data'。其中figure表示Figure坐标系，axes表示Axes坐标系，data表示被注解的点所在的数据坐标系。points表示单位为点（分辨率的点）；pixels表示单位为像素，fraction表示：(0,0) 为左下角，(1,1) 为右上角
textcoords：给出了注解字符串的(x,y)所对应的坐标系。可以为xycoords允许的值之外，还可以为：
'offset points'：偏移被注解的坐标点的距离为 (x,y)个点（分辨率的点）
'offset pixels'：偏移被注解的坐标点的距离为 (x,y)个像素
arrowprops：一个字典，给出了箭头的类型。
若字典不包含arrowstyle，则可以使用下面的键： width/headwidth/headlength/shrink以及其他的FancyArrowPatch的属性。
如果字典包含了arrowstyle，则上面的这些键将被屏蔽。arrowstyle的值可以为： '-'、'->'、'-['、'|-|'、'-|>'、'<-'、'<->'、 '<|-'、'<|-|>'、'fancy'、'simple'、'wedge'
annotation_clip：一个布尔值。如果为True，则超出axes的部分将会不可见
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
s = "anno"
ax.annotate(s,xy=(0,0.5),xytext=(0.5,0.5),xycoords="axes fraction",
           textcoords="axes fraction",arrowprops={"arrowstyle":"->","color":"green"},color="red",fontsize=24)
ax.set_xlim(-1,1)
ax.set_ylim(-1,1)
# fig.show()
（10）autoscale_view(tight=None, scalex=True, scaley=True)
功能：自动调整坐标轴的范围。如果你不想自动调整x轴，则scalex=False即可，y轴类似。
（11）arrow(x, y, dx, dy, **kwargs)
功能：绘制箭头，箭头起点为 (x,y)，终点为 (x+dx,y+dy)，你也可以使用annotate()来模拟本方法。
x,y：箭头起点坐标（data坐标系）
dxx,dy：箭头终点坐标为 (x+dx,y+dy)（data坐标系）
width：箭头宽度
length_includes_head：如果为True，则箭头的头部也算在箭头长度内
head_width：箭头的头部宽度
head_length：箭头的头部长度
shape：可以为'full'/'left'/'right'。确定是绘制左半边/右半边还是全部画出
其他参数控制了Patch的属性
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.arrow(0.0,0.5,0.3,0.3,width=0.05,head_width=0.1,head_length=0.1,
         shape='left',facecolor='black',edgecolor='blue' )
ax.set_xlim(-1,1)
ax.set_ylim(-1,1)
# fig.show()
（12）axhline(y=0, xmin=0, xmax=1, **kwargs)
功能：绘制水平线
y：一个标量，默认为 0.给出了水平的 y坐标（采用data坐标系）
xmin：一个标量，默认为 0。给出了水平线的起始横坐标。最大为 1（表示最右侧）（使用Axes坐标系）
xmax：一个标量，默认为 1。 给出了水平线的终点横坐标。最小为 0 （表示最左侧）（使用Axes坐标系）
其他关键字参数控制Line2D的属性
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.axhline(y=0.2,xmin=0,xmax=1,lw=4,color='red')
ax.set_xlim(-1,1)
ax.set_ylim(-1,1)
# fig.show()
（13）axhspan(ymin, ymax, xmin=0, xmax=1, **kwargs)
功能：绘制水平区域。
ymin/ymax：给出了水平区域的y坐标的下界和上界，采用data坐标系
xmin/xmax：给出了水平区域的左侧和右侧的位置。采用Axes坐标系，最小为0，最大为 1
其他关键字参数控制Line2D的属性
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.axhspan(ymin=0,ymax=0.2,xmin=0,xmax=0.5,facecolor="yellow",edgecolor="blue")
ax.set_xlim(-1,1)
ax.set_ylim(-1,1)
（14）axis(*v, **kwargs)
功能：设置axis属性，它返回的是(xmin,xmax,ymin,ymax)。data坐标系下每个轴的最小值、最大值。
v：Axis data limits set from a float list，也可以是字符串：
'on'：Toggle axis lines and labels on
'off'：Toggle axis lines and labels off
'equal'：Equal scaling by changing limits
'tight'：Limits set such that all data is shown
'auto'：Automatic scaling, fill rectangle with data
xmin/ymin/ymax/ymax：待设置的轴的最小/最大值
（15）axvline(x=0, ymin=0, ymax=1, **kwargs)
功能：绘制垂直线
x：一个标量，默认为 0.给出了垂直线的 x坐标（采用data坐标系）
ymin：一个标量，默认为 0。给出了垂直线的起始纵坐标。最大为 1（表示最上侧）（使用Axes坐标系）
ymax：一个标量，默认为 1。 给出了垂直线的终点纵坐标。最小为 0 （表示最下侧）（使用Axes坐标系）
其他关键字参数控制Line2D的属性
（16）axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs)
功能：绘制垂直区域
xmin/xmax：给出了垂直区域的x坐标的左侧和右侧，采用data坐标系
ymin/ymax：给出了垂直区域的上侧和下侧的位置。采用Axes坐标系，最小为0，最大为 1
其他关键字参数控制Line2D的属性
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.axvline(x=0.2,ymin=0,ymax=1,lw=4,color='yellow')
print(ax.axis(xmin=-1,xmax=2,ymin=-3,ymax=4))
（17）bar(left, height, width=0.8, bottom=None, **kwargs)
功能：绘制一个bar
left：一个标量或者标量的序列，bar的左侧的x坐标，采用data坐标系
height：一个标量或者标量的序列，bar的高度，采用data坐标系
width：一个标量或者标量的序列，bar的宽度，默认为 0.8，采用data坐标系
bottom：一个标量或者标量的序列，bar的底部的y坐标，默认为 0，采用data坐标系
color：一个标量或者标量的序列，bar的背景色
edgecolor：一个标量或者标量的序列，bar的边色颜色
linewidth：一个标量或者标量的序列，bar的边的线宽
tick_label：一个字符串或者字符串的序列，给出了bar的label
xerr：一个标量或者标量的序列，用于设置bar的errorbar。（水平方向的小横线）
yerr：一个标量或者标量的序列，用于设置bar的errorbar（垂直方向的小横线）
ecolor：一个标量或者标量的序列，用于设置errorbar。
capsize：一个标量，用于设置errorbar。小横线头部的一个小短线
error_kw：一个字典，用于设置errorbar。如ecolor/capsize关键字
align：一个字符串，设定bar的对齐方式。可以为'edge'或者'center'。柱子的左边跟x=left线对齐，还是柱子的中线跟x=left线对齐。
orientation：一个字符串，指定bar的方向。可以为'vertical'或者'horizontal'。它决定了errbar和label放置的位置。
log：一个布尔值，如果为True，则设置axis为对数坐标
返回matplotlib.container.BarContainer.




    

你可以一次添加多个bar，此时就是上述的“标量的序列”。 
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.bar(left=0,height=1,width=0.2,bottom=-1,color='red',edgecolor="green",lw=4,
      tick_label="vertical",xerr=0.3,yerr=0.5,ecolor="orange",capsize=5,align="center",
      orientation="vertical")
ax.bar(left=-1,height=0.5,width=0.2,bottom=0,color='green',edgecolor="red",lw=2,
      tick_label="horizontal",xerr=0.2,yerr=0.3,ecolor="orange",capsize=8,align="center",
      orientation="horizontal")
ax.set_xlim(-1,1)
ax.set_ylim(-1,1)
（18）barh(bottom, width, height=0.8, left=None, **kwargs)
功能：绘制水平的bar
bottom：一个标量或者标量的序列，bar的底部的y坐标，默认为 0，采用data坐标系
width：一个标量或者标量的序列，bar的宽度，默认为 0.8，采用data坐标系
height：一个标量或者标量的序列，bar的高度，采用data坐标系
left：一个标量或者标量的序列，bar的左侧的x坐标，采用data坐标系
其他参数参考 bar方法
它就是bar(orientation='horizontal')。
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.bar(left=-1,height=0.5,width=0.2,bottom=0.4,color='green',edgecolor="red",lw=2,
      tick_label="barhoz",xerr=0.2,yerr=0.3,ecolor="orange",capsize=8,align="center",
      orientation="horizontal")
ax.barh(left=-1,height=0.5,width=0.2,bottom=-0.4,color='green',edgecolor="red",lw=2,
      tick_label="aa",xerr=0.2,yerr=0.3,ecolor="orange",capsize=8,align="center",
      orientation="horizontal")
ax.set_xlim(-1,1)
ax.set_ylim(-1,1)
（19）cla()/clear()：清除Axes
（20）clabel(CS, *args, **kwargs)
功能：为等高线添加label。
CS：由contour函数返回的ContourSet，代表一组等高线
fontsize：label的字体大小，或者给出字符串'smaller'/'x-large'
colors：如果为None，则使用对应的等高线的颜色。如果为一个字符串指定的颜色，则所有的等高线label使用该颜色。如果为一组颜色，则不同的等高线的label按顺序使用其中的不同的颜色。
inline：一个布尔值。如果为True，则移除label覆盖的底层的等高线（嵌入式）；否则就全部绘制（重叠式）
inline_spacing:一个浮点数，单位为像素点。它控制了label距离等高线的距离
delta = 0.025
x = np.arange(-3,3,delta)
y = np.arange(-2,2,delta)
X,Y = np.meshgrid(x,y)
Z = 3*X**2+4*Y**2
fig = plt.figure(figsize=(10,4))
ax1 = fig.add_subplot(121)
CS1 = ax1.contour(X,Y,Z)
ax1.clabel(CS1,fontsize=10,inline=1)
ax1.set_title('inline')
ax2 = fig.add_subplot(122)
CS2 = ax2.contour(X,Y,Z)
ax2.clabel(CS2,fontsize=10,inline=0,colors='red')
ax2.set_title('no_inline')
（21）contour(*args, **kwargs)
功能：绘制等高线，它返回一个QuadContourSet对象
最常用的四种方式：
contour(Z)：其中 Z为二维数组。数据坐标系下的坐标点 (i,j)对应了Z[j,i]（x轴对应列，y轴对应行）。该方法随机挑选一些等高线绘制。
contour(X,Y,Z)：其中 X/Y/Z均为二维数组，且形状相同。对应位置的横坐标由 X提供，纵坐标由 Y提供，值由 Z 提供。该方法随机挑选一些等高线绘制。
X和Y也可以同时是一维数组，且len(X)是Z的列数，len(Y)是Z的行数。
contour(Z,N)/contour(X,Y,Z,N)：N为一个整数，表示绘制N条等高线。该方法随机挑选N条等高线绘制。
contour(Z,V)/contour(X,Y,Z,V)：V为一个递增的序列，表示绘制那些值位于V中的等高线
其他关键字参数：
colors：如果为None，则由cmap给出。如果是一个字符串，这所有的等高线由字符串指定的颜色给出。如果是一个序列，该序列中每个都代表了一个颜色，则等高线的颜色依次由该序列给出。
cmap：一个Colormap对象。如果为None，则默认的Colormap将被使用
levels：一个序列（升序排列）。指定了要绘制等高线值位于levels的等高线。
origin：参考Axes.imshow中的该参数设置。
extent：它是一个元组(x0,x1,y0,y1)。如果给出了(X,Y)，则该参数无效。如果未给出(X,Y)：
如果origin非None，则它给出了外边界， Z[0,0]位于图形中间
如果origin为None，则(x0,y0)对应Z[0,0]；(x1,y1)对应Z[-1.-1]，等价于同时使用了set_xlim(left,right)+set_ylim(bottom,top)
antialiased：一个布尔值，用于开启/关闭反走样
linewidths：如果为None，则使用默认值。如果为一个整数，则所有的等高线都是用该线宽。如果为一个整数序列，则等高线依次使用它指定的线宽。只有contour适用
linestyles：如果为None，则使用默认的实线。你也可以指定为'solid'/'dashed'/'dashdot'/'dotted'。你可以指定搜有的等高线使用一种线型，也可以使用一个线型序列。只有contour适用
fig = plt.figure(figsize=(12,10))
Z = np.array([[9,8,7,6],[12,15,13,10],[0,7,3,2]]) # Z必须是二维的
# 最简单的
ax1 = fig.add_subplot(221)
ax1.grid(True,which="both")
cs1 = ax1.contour(Z) # Z[0,1]对应于坐标(0,1)
ax1.clabel(cs1,inline=0,fontsize=8,colors="red")
ax1.set_xlim(-0.5,3.5)
ax1.set_ylim(0,3.0)
ax1.set_title("contour(Z)")
# 提供X/Y
ax2 = fig.add_subplot(222)
ax2.grid(True,which="both")
X,Y=np.mgrid[2:5,1:5]
cs2 = ax2.contour(X,Y,Z) # 对应位置的横坐标由X提供，纵坐标由Y提供，值由Z提供
ax2.clabel(cs2,inline=0,fontsize=8,colors="red")
ax2.set_xlim(1.5,4.5)
ax2.set_ylim(0,4.5)
ax2.set_title("contour(X,Y,Z)")
# 指定N
ax3 = fig.add_subplot(223)
ax3.grid(True,which="both")
cs3 = ax3.contour(Z,2) # Z[0,1]对应于坐标(0,1)
ax3.clabel(cs3,inline=0,fontsize=8,colors="red")
ax3.set_xlim(-0.5,3.5)
ax3.set_ylim(0,3.0)
ax3.set_title("contour(Z,N)")
# 指定了 等高线的值序列
ax4 = fig.add_subplot(224)
ax4.grid(True,which="both")
cs4 = ax4.contour(Z,[6,7,8,9,10,11]) # Z[0,1]对应于坐标(0,1)
ax4.clabel(cs4,inline=0,fontsize=8,colors="red")
ax4.set_xlim(-0.5,3.5)
ax4.set_ylim(0,3.0)
ax4.set_title("contour(Z,V)")
（22）contourf(*args, **kwargs)
作用：它绘制的是带填充的等高线。其参数和用法基本和contour相同。它返回一个QuadContourSet对象
contourf(Z,V)/contourf(X,Y,Z,V)：V是递增的序列，指定了等高线的值。该方法会填充V中相邻两个等高线之间的区域
contourf不同与contour的关键字参数为hatches：它指定了填充区域的填充类型（如以小斜线填充）。如果为None，则无任何hatch。它典型值为hatches=['.', '/', '\', None, '\\', '*','-',]
contourf填充的是半开半闭区间(z1,z2]
（23）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, **kwargs)
功能：绘制errorbar，返回(plotline, caplines, barlinecols)
x：一个序列，指定x坐标
y：一个序列，指定y坐标。即： y=f(x)
yerr：指定y的error。如果为标量，则每个点都是相同的error；如果为一维向量，则依次给出了每个点的error。如果是个二维向量，则依次给出了每个点的上error和下error
xerr：指定x的error。如果为标量，则每个点都是相同的error；如果为一维向量，则依次给出了每个点的error。如果是个二维向量，则依次给出了每个点的左error和右error
fmt：可以为空字符串，或者'none'或者其他的plot format string。如果是'none'则只有errorbars能够被绘制
ecolor：指定了errorbar的颜色
elinewidth：指定了errorbar的线宽
capsize：指定了errorbar头部的小横线的宽度
errorevery：一个整数。如果为 4， 则每隔 4个点才绘制一个errorbar
其他的关键字参数都是用于指定marker的类型。如： `marker='s', mfc='red', mec='green', ms=20, mew=4。他们是markderfacecolor,markeredgecolor,markdersize,markderedgewidth`的缩写。
x = np.linspace(0,6,num=20)
y = np.sin(x)
xerr = 0.1
yerr = 0.2
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.errorbar(x,y,yerr,xerr,fmt='',ecolor='red',capsize=2,marker='o')
（24）eventplot(positions, orientation='horizontal', lineoffsets=1, linelengths=1,linewidths=None, colors=None, linestyles='solid', **kwargs) 
作用：绘制时间线。时间线就是在指定位置上并排的一系列线段。返回 matplotlib.collections.EventCollection的一个列表。
positions：一个一维或者二维的数组。每一行代表了一组直线
orientation：可以为'horizonal'|'vertical'，代表了摆放时间线的方式。如果是水平走向的，则垂直摆放直线；如果是垂直走向的，则水平放置直线
lineoffsets：一个浮点数或者浮点数的序列，指定了时间线中轴距离y=0的偏离值
linelengths：一个浮点数或者浮点数的序列，指定了线的长度
linewidths：一个浮点数或者浮点数的序列，指定了线的宽度
colors：一个颜色或者一组颜色，指定了线的颜色。颜色可以为颜色字符串，或者一个RGB元组。
linestyles：一个线型或者一组线型，指定了线型。线型在'solid' | 'dashed' | 'dashdot' | 'dotted'四者之一。
　　如果positions是一个一维数组，表示绘制一组时间线。那么lineoffsets/linelengths/linewidths/colors/linestyles都是标量值，指定该组时间线的格式。如果positions是一个二维数组则，有多少行，就有多少组时间线。制定时间线格式的这些参数都是序列，序列长度就是positions的行数。
position = np.arange(0,100).reshape((2,-1))
colors = np.array(['r','g'])
lineoffsets = np.array([0,2])
linelengths = np.array([1,2])
fig = plt.figure()
ax1 = fig.add_subplot(1,2,1)
ax1.eventplot(position,colors=colors,lineoffsets=lineoffsets,linelengths=linelengths)
ax2 = fig.add_subplot(1,2,2)
ax2.eventplot([0,1,2,3,4,5],colors='g',lineoffsets=1,linelengths=2,orientation='vertical')
（25）fill(*args, **kwargs)
功能：绘制多边形。返回一个Patch列表。
其常用的方式为：
绘制一个多边形： fill(x,y,'b')，其中x为多边形的边上的点的x坐标；y为多边形的边上的点的y坐标。'b'为多边形的填充颜色。
绘制多个多边形： fill(x1,y1,'b',x2,y2,'r')。这里指定多个x,y,color就可以。
closed关键字参数：一个布尔值，确定是否封闭多边形（即多一条从起点到终点的边）。默认为True
plot()支持的color string在这里也被支持
剩下的关键字参数用于控制Polygon的属性。如
hatch：一个字符串，指定填充方式，如['/' | '\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*']
label：一个字符串，指定标签
fill：一个布尔值，决定是否填充
facecolor/edgecolor/color：颜色
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,2,num=20)
y = np.sin(x)
fig = plt.figure()
ax1 = fig.add_subplot(1,2,1)
ax1.fill(x,y,edgecolor='r')
ax2 = fig.add_subplot(1,2,2)
ax2.fill(x,y,closed=False,fill=False,edgecolor='g',label='testfill')
（26）fill_between(x, y1, y2=0, where=None, interpolate=False, step=None, **kwargs)
功能：绘制填充区域。它填充两个曲线之间的部分。它返回一个PolyCollection对象。
x：一个序列，指定x坐标
y1：第一条曲线的纵坐标。如果为标量，说明该曲线为水平线。
y2：第二条曲线的纵坐标。如果为标量，说明该曲线为水平线。
where：指定填充哪里。如果为None，则填充两条曲线之间的所有区域，这是默认值。如果非None，则他是一个一维布尔数组，长度与x相同。只有为True对应的x处才被填充。
interpolate：一个布尔值。如果True，则进行插值计算来寻找两个曲线的交点。如果为False，则不进行插值。
step：可以为'pre'/'post'/'mid'或者None，设定填充区域的边界的形状。
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,4,num=20)
y1 = np.sin(x)
y2 = x ** 2
fig = plt.figure()
ax1 = fig.add_subplot(1,2,1)
ax1.fill_between(x,y1,y2,edgecolor='r',step=None)
ax2 = fig.add_subplot(1,2,2)
ax2.fill_between(x,y1,y2,edgecolor='g',where=x>2,step="post")
ax2.set_xlim(0,4)
（27）fill_betweenx(y, x1, x2=0, where=None, step=None, **kwargs)
功能：绘制填充区域。该区域是以y为自变量，x为函数的两条曲线合围而成。它返回一个PolyCollection对象。
y：一个序列，为纵坐标
x1：第一个曲线的x坐标。它是一个反函数，即以y为自变量
x2：第二个曲线的y坐标。它也是一个反函数
where：指定填充哪里。如果为None，则填充两条曲线之间的所有区域，这是默认值。如果非None，则他是一个一维布尔数组，长度与y相同。只有为True对应的y处才被填充。
step：可以为'pre'/'post'/'mid'或者None，设定填充区域的边界的形状。
通常建议提供一个alpha参数，用于设定填充的透明度。如果同一个区域被多个fill_between()填充，那么设定alpha之后会让每一层都能显示出来。
fill_between沿着x轴填充；fill_betweenx沿着y轴填充
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,4,num=20)
y1 = np.sin(x)
y2 = x
fig = plt.figure()
ax1 = fig.add_subplot(1,2,1)
ax1.fill_between(x,y1,y2,edgecolor='r',step=None)
ax1.axhline(y=0,color='black')
ax2 = fig.add_subplot(1,2,2)
ax2.fill_betweenx(x,y1,y2,edgecolor='g')
ax2.set_xlim(0,4) 
（28）findobj(match=None, include_self=True)
功能：筛选出合适的artist对象，返回一个列表。他会递归的向下搜寻
match指定过滤器。
如果为None，则它选出axes包含的所有artist
如果为一个函数，则函数接受一个artist参数，返回布尔值。所有返回True的artist被选中
如果是一个类，则返回属于该类的artist
include_self：如果为True，则也检查自己
（29）get_xx函数
功能：返回对应的属性值。如：get_alpha/get_anchor/get_animated/get_aspect/get_axis_bgcolor/get_axisbelow/get_clip_box/get_clip_path/get_frame_on/get_gidget_label/get_legend/get_lines/get_title/get_transform/get_visibleget_xaxis/get_xlabel/get_xlim/get_xscale/get_xticklabels/get_yaxis...
（30）grid(b=None, which='major', axis='both', **kwargs)
功能：开启关闭网格。

b为布尔值，指定你想开启(True)还是关闭网格
which：可以为'major'/'minor'/'both'，指定你想开启哪个级别的网格
axis：可以为'x'/'y'/'both'，指定你想在那个轴上开启网格
其他的关键字参数设定了网格的线条类型。如color/linestype/linewidth
还有一种简单用法，就是axes.grid()，此时表示：如果网格开启，则关闭。如果网格关闭，则开启。
（31）hexbin(x, y, C=None, gridsize=100, bins=None, xscale='linear', yscale='linear',extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='none', reduce_C_function=<function mean>, mincnt=None,marginals=False, **kwargs)
功能：绘制hexbin。它用于同一个地方有很多点的情况，是六边形面元划分，是一种二元直方图。返回一个PolyCollection对象。
x/y：一维数组，它们形状相同。它们给出了绘制六边形面元的点。




    

C：如果非None，则它给出了坐标(x[i],y[i])的count value。它和x长度相同，也是一维数组
x/y/C也可能是masked array，此时只有unmasked的点才被绘制
reduce_C_function：将坐标(x[i],y[i])的count value进行归并。因为同一个坐标可能被设定了多个count value。而每个点根据其count value来染色
gridsize：一个整数。它调整了六边形面元x方向的尺寸，y方向的尺寸自动选取。你也可以设定它为一个元组，同时调整x/y方向的尺寸。它实际上给出的是x轴可以放置的面元数量，因此该数值越大，六边形面元尺寸越小。
bins：
如果为None，则每个六边形面元的颜色值直接对应了它的count value
如果为'log'，则每个六边形面元的颜色值对应了它的count value+1的对数值
如果为一个整数， divide the counts in the specified number of bins, and color the hexagons accordingly
如果为一个整数序列，则the values of the lower bound of the bins to be used
xscale：可以为'linear'/'log'，设置了x轴是线性还是对数
scale：可以为'linear'/'log'，设置了y轴是线性还是对数
mincnt：一个整数或者None。它指定显示这一类的面元：面元包含的坐标点的数量超过mincnt。对于面元包含坐标点数量少于mincnt的，不显示。
marginals：一个布尔值。如果为True，则沿着坐标轴绘制密度条。
extent：一个元组(left, right, bottom, top)，等价于同时使用了set_xlim(left,right)+set_ylim(bottom,top)。
剩下的参数设定颜色和面元的属性。
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.array([1,2,3,4,5,6,7,8,8,9,9,9])
y = x
C = [1,1,2,2,3,3,4,4,5,5,6,6]
fig = plt.figure(figsize=(8,6))
ax1 = fig.add_subplot(2,2,1)
ax1.hexbin(x,y)
ax1.set_xlim(-1,10)
ax1.set_ylim(-1,10)
ax1.set_title("simple")
ax2 = fig.add_subplot(2,2,2)
ax2.hexbin(x,y,C,gridsize=10)
ax2.set_xlim(-1,10)
ax2.set_ylim(-1,10)
ax2.set_title("C & gridsize")
ax3 = fig.add_subplot(2,2,3)
ax3.hexbin(x,y,C,gridsize=10,mincnt=1)
ax3.set_xlim(-1,10)
ax3.set_ylim(-1,10)
ax3.set_title("mincent")
ax4 = fig.add_subplot(2,2,4)
ax4.hexbin(x,y,C,gridsize=10,marginals=True)
ax4.set_xlim(-1,10)
ax4.set_ylim(-1,10)
ax4.set_title("marginals")
（32）hist(x, bins=10, range=None, normed=False, weights=None, cumulative=False,bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None,log=False, color=None, label=None, stacked=False, **kwargs) 
功能：绘制直方图。 其返回值为：
如果绘制一个直方图，那么就是元组 (n, bins, patches)，n为频数/频率；bins为直方图的各个分界点；patches为每个直方图。
如果绘制多个直方图，那么就是元组 ([n0, n1, ...], bins, [patches0, patches1,...])
x:一个序列或者一维数组，给定了直方图的数据
bins：一个整数。返回了bins+1个分界点，将竖着划分成等分的bins份。你可以传递一个序列，指定分界点，此时可以实现非等分的划分。
range：一个元组，给出了数据的上界和下界，在这之外的数据不被考虑。默认就是(x.min(),x.max())
normed：布尔值，如果为True，则返回的是数据出现的频率；否则返回的是数据出现的频数
weights：长度与x相同的序列，给出了每个数据的权重
cumulative ：布尔值。如果为True，则计算的是累积频率/频数
bottom：一个整数或者整数序列或者None，指定了直方图底部的纵坐标。默认为 0
histtype：直方图的类型。可以为'bar'/'barstacked'/'step'/'stepfilled'
align：直方图每个小矩形的对齐方式。可以为'left'/'mid'/right'
orientation：调整方向。可以为'horizontal'/'vertical'。如果为水平则，使用barh，同时bottom参数设定的是左侧的横坐标值
rwidth：一个标量值，设定了直方图每个矩形的相对于默认值的宽度。如果直方图类型为 step/stepfilled，则忽略该参数。
log：布尔值。如果为True：则x轴使用对数坐标
color：颜色或者颜色序列，用于给直方图指定颜色
label：字符串或者字符串序列。给直方图指定标签
stacked：一个布尔值。如果为True，则多个直方图会叠加在一起。
其他参数设置了Patch的属性
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.random.randn(1000)
fig = plt.figure(figsize=(8,6))
ax1 = fig.add_subplot(2,2,1)
ax1.hist(x,bins=20)
ax1.set_title("default")
ax2 = fig.add_subplot(2,2,2)
ax2.hist(x,bins=20,normed=True)
ax2.set_title("normed")
ax3 = fig.add_subplot(2,2,3)
ax3.hist(x,bins=20,normed=True,histtype="step")
ax3.set_title("histtype")
ax4 = fig.add_subplot(2,2,4)
ax4.hist(x,bins=20,normed=True,rwidth=0.6,label="aaa",color="r")
ax4.set_title("rwidth&color")
plt.show()
（33）hist2d(x, y, bins=10, range=None, normed=False, weights=None, cmin=None, cmax=None, **kwargs)
功能：绘制二维直方图。其返回值为元组 (counts, xedges, yedges, Image)
x:一个序列或者一维数组，给定了x坐标序列
y:一个序列或者一维数组，给定了y坐标序列
bins：
如果为整数，则给出了两个维度上的区间数量
如果为int,int序列，则分别给出了x区间数量和y区间数量
如果给定了一个一维数组，则给出了 x_edges=y_edges=bins
如果为定了array,array，则分别给出了x_edges,y_edges
range：一个(2,2)的数组，给出了数据的上界和下界，在这之外的数据不被考虑。默认就是(x.min(),x.max())
normed：布尔值，如果为True，则返回的是数据出现的频率；否则返回的是数据出现的频数
weights：长度与x相同的序列，给出了每个数据的权重
cmin：一个标量值。那些count值小于cmin的单元不被显示。同时返回的结果中，这些单元返回nan
cmax：一个标量值。那些count值大于cmax的单元不被显示。同时返回的结果中，这些单元返回nan
其他参数设置了pcolorfast()属性
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
data = np.random.randn(2,1000)
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
result = ax.hist2d(data[0,:],data[1,:],normed=True,bins=[20,40])
（34）hlines(y, xmin, xmax, colors='k', linestyles='solid', label='', **kwargs)
功能：从xmin到xmax绘制一系列的水平线。这些水平线的纵坐标由y提供。
y：水平线的纵坐标。如果为标量，则为一条水平；如果为序列，则为一系列水平线。数据坐标系
xmin/xmax：水平线的起点和终点的横坐标。如果是个标量，则所有的水平线公用。如果是序列，则每个水平线设置一个。数据坐标系
linestyles：指定线型。可以为一个字符串（所有水平线公用），或者字符串序列（每个水平线一个）。线型在'solid' | 'dashed' | 'dashdot' | 'dotted'四者之一
colors：指定颜色。可以为一个颜色（所有水平线公用），或者颜色序列（每个水平线一个）。
label：一个字符串，指定标签。
其他关键字参数设置LineCollection属性。
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
y = [1,2,3,3]
fig = plt.figure()
ax = fig.add_subplot()
r = ax.hlines(y,xmin=0,xmax=[2,2,-1,3],colors=['r','g','y','b'])
ax.set_xlim(-1,4)
ax.set_ylim(0,4)
print(r)
（35）imshow(X, cmap=None, norm=None, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, shape=None, filternorm=1, filterrad=4.0, imlim=None, resample=None, url=None, **kwargs)
功能：绘制图片。返回一个AxesImage对象
X：包含了图片的数据。其形状可以为：
(n,m)（灰度图），类型为float
(n,m,3)（RGB图），类型为float（此时每个元素的值都在 0 和 1.0 之间），或者unit8
(n,m,4)（RGBA图），类型为float（此时每个元素的值都在 0 和 1.0 之间），或者unit8
cmap：一个Colormap实例。默认由rc的image.cmap指定。如果X是RGB/RGBA，则忽略该参数
aspect：一个字符串，指定图片的缩放。可以为：
'auto'：缩放图片的宽高比，是的它匹配axes
'equal'：当extent参数为None时，修改axes的宽高比，使得它匹配图片；如果extent参数不是None，则修改axes的宽高比来匹配extent
None：默认由rc的image.aspect指定
interpolation：一个字符串，指定插值方式。可以为'none', 'nearest', 'bilinear', 'bicubic','spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom','gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos'
norm：一个Normalize实例，用于将图片亮度正则化到 0~1。如果为None，则采用normalize.norm
vmin/vmax：用于辅助norm进行正则化。如果你传入了一个norm实例，则该参数忽略
alpha：浮点数，指定透明度
origin：可以为'upper'/'lower'。图片的第一个像素X[0,0]放置在坐标原点。
'upper'：横坐标向右，纵坐标向下
'lower'：横坐标向右，纵坐标向上
extent：一个元组(left, right, bottom, top)，等价于同时使用了set_xlim(left,right)+set_ylim(bottom,top)
shape：一个元组(column,rows)，用于rar buffer image
filternorm/filterrad：用于过滤
其他参数用于调整 Artist属性
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
data = plt.imread("IU.jpg")
print(data.shape) # (660, 500, 3)
fig = plt.figure(figsize=(8,6))
ax1 = fig.add_subplot(221)
ax1.imshow(data)
ax1.set_title("default")
ax2 = fig.add_subplot(222)
ax2.imshow(data[:300,:300,:],aspect="equal")
ax2.set_title("partial")
ax3 = fig.add_subplot(223)
ax3.imshow(data,origin="lower")
ax3.set_title("origin=lower")
ax4 = fig.add_subplot(224)
ax4.imshow(data,origin="upper")
ax4.set_title("origin=upper")
（36）legend(*args, **kwargs)
功能：创建一个图例。
最简单的方式：你首先创建一个Axes，然后在其中添加lines，然后直接调用ax.legend()即可。此时那些label非空的线将被图例注释
你也可以采用下面面向对象的方案：线创建line，然后调用line.set_label()，然后调用ax.legend()。此时的逻辑更清晰
如果你不想让某个line被图例注释，则它的label要么为空字符串，要么为以下划线开始。
还有一种直接控制图例的方式：它直接显式指定了被注释的line和对应的label
ax.legend((line1,line2,line3),('label1','label2','label3'))
loc：指定了图例的位置。可以为整数或者字符串。可以是字符串'best'/'upper right'/'upper left' /'lower left'/'lower right'/'right'/'center left'/'center right' /'lower center'/'upper center'/'center'，对应于整数的 0~10。你也可以指定坐标(x,y)，其中(0,0)是左下角，(1,1)是右上角
ncol：一个整数，指定图例中有几列，默认为 1列
prop：一个字典，或者FontProperties实例，可以指定图例中的字体属性。
fontsize：控制字体大小，可以为整数、浮点数（指定字体绝对大小），或者字符串 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'
numpoint/scatterpoints：图例上每个图例线的点数
fancybox：如果为True，图例的边框采用圆角矩形
framealpha：一个浮点数，从0到 1，图例的透明度
frameon：一个布尔值，如果为True，则绘制图例的背景框。否则不绘制。
shadow：如果为True，图例添加背影
ncol：列数
title：图例的标题
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,10)
y1 = np.sin(x)
y2 = x ** 0.2
fig = plt.figure(figsize=(8,6))
ax1 = fig.add_subplot(221)
ax1.plot(x,y1,label=r"sin(x)")
ax1.scatter(x,y2,label=r"$x^2$")
ax1.legend()
ax1.set_title("default")
ax2 = fig.add_subplot(222)
line1 = ax2.plot(x,y1)[0]
line1.set_label(r"sin(x)")
line2 = ax2.scatter(x,y2)
line2.set_label(r"$x^2$")
ax2.legend(loc="upper left",fancybox=True,fontsize=18,framealpha=0.2)  
ax2.set_title("loc+fancybox+fontsize+framealpha")                
ax3 = fig.add_subplot(223)
line3 = ax3.plot(x,y1)[0]
line4 = ax3.scatter(x,y2)
ax3.legend((line3,line4),(r"sin(x)",r"$x^2$"),loc="upper right",ncol=2,shadow=True)  
ax3.set_title("ncol+shadow")
ax4 = fig.add_subplot(224)
ax4.plot(x,y1,label=r"sin(x)")
ax4.scatter(x,y2,label=r"$x^2$")
ax4.legend(frameon=False)  
ax4.set_title("frameon")
（37）locator_params(axis='both', tight=None, **kwargs)
功能：控制tick locator
axis：一个字符串，指定控制那个轴。可以为'x'/'y'/'both'。
tight：一个布尔值。它传递给autoscale_view()
其他关键字参数传递给set_params()方法
如果你想调整主轴上的刻度线的数量，可以使用ax.locator_params(tight=True,nbins=4)
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,10)
y = np.sin(x)
fig = plt.figure()
ax1 = fig.add_subplot(121)
ax1.plot(x,y)
ax1.set_title("default")
ax2 = fig.add_subplot(122)
ax2.plot(x,y)
ax2.locator_params(axis="x",tight=True,nbins=12)
ax2.set_title("locator_params")
plt.tight_layout()
plt.show()
（38）loglog(*args, **kwargs)
功能：绘制line，但是将x轴和y轴都调整为对数坐标
x：数据的x坐标
y：数据的y坐标
basex/basey：一个大于 1 的标量，控制对数的底数
subsx/subsy：一个序列，给出了x/y轴的子刻度的位置（数据坐标系）。默认为None，此时子刻度是自动划分的
nonposx/nonposy：如果为'mask'，则x/y的负数或者零将被视作无效的数；如果为'clip'，则x/y的负数或者零将被视作一个非常小的正数（因为对数的自变量要大于零）
剩下的参数将被作为Line2D的属性
（39）margins(*args, **kw)
功能：设置Axes的margin。你可以通过ax.margins()获取当前的margin。 你也可以通过ax.margins(x=xmargin,y=ymargin)来设置margin。这两个参数的值是0~1
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,10)
y = np.sin(x)
fig = plt.figure()
ax1 = fig.add_subplot(121)
ax1.plot(x,y)
ax1.set_title("default")
ax2 = fig.add_subplot(122)
ax2.plot(x,y)
ax2.margins(x=0.5,y=0.5)
ax2.set_title("margins")
plt.tight_layout()
plt.show()
（40）matshow(Z, **kwargs)
功能：将一个矩阵绘制成图片。
Z：一个形状为(n,m)的数组
其他参数见imshow
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
Z1= np.random.randn(100,100)
Z2 = np.arange(0,10000).reshape((100,100))
fig = plt.figure()
ax1 = fig.add_subplot(121)
ax1.matshow(Z1)
ax2 = fig.add_subplot(122)
ax2.matshow(Z2,origin="lower")
（41）minorticks_off()：关闭次刻度线。minorticks_on()：打开次刻度线。
（42）pcolor(*args, **kwargs)
功能：绘制一个pseudocolor plot，返回一个Collection实例。对于大型数组，它很慢，此时推荐使用pcolormesh()。
常用的方式为： pcolor(C,*kwargs)，此时C为一个二维数组。也可以指定pcolor(X,Y,C,*kwargs)。X/Y/C都是二维数组，并且X和Y的尺寸比C大。它将在四个点决定的矩形中填充颜色C[i,j]： (X[i, j], Y[i, j])，(X[i, j+1], Y[i, j+1])， (X[i+1, j], Y[i+1, j])，(X[i+1, j+1], Y[i+1, j+1])。X/Y也可以是一维的，但是首先会进行广播法则。
cmap：一个Colormap实例。如果为None，则使用rc的设置
edgecolors：None或者'none'或者一个颜色或者一个颜色序列。用于设定边的颜色
其他参数设置PopyCollection属性
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
Z = np.arange(0,10000).reshape((100,100))
fig = plt.figure()
ax1 = fig.add_subplot(121)
ax1.pcolor(Z)
ax2 = fig.add_subplot(122)
X2,Y2 = np.mgrid[0:100:1,100:0:-1]
ax2.pcolor(X2,Y2,Z)
（43）pcolorfast(*args, **kwargs)
用法和pcolor相同，它是一个实验性质的，提供了一个更快的实现。
（44）pcolormesh(*args, **kwargs)
作用和pcolor相同。但是它是另一个实现方式，并且返回不同的对象，它返回的是QuadMesh对象。它的速度更快。其参数和用法与pcolor相同。




    

edgecolors：除了pcolor的edgecolors之外，还多了一个'face'，表示使用与四边形背景色相同的颜色。
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
Z = np.arange(0,25).reshape((5,5))
fig = plt.figure()
ax1 = fig.add_subplot(121)
print(ax1.pcolor(Z,edgecolors="black"))
ax2 = fig.add_subplot(122)
print(ax2.pcolor(Z,edgecolors="face"))
（45）pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6,shadow=False, labeldistance=1.1, startangle=None, radius=None, counterclock=True,wedgeprops=None, textprops=None, center=(0, 0), frame=False)
功能：绘制饼状图。
x：数据序列。每一块饼的权重为x/sum(x)；如果sum(x)<=1，则x已经代表了每一块饼的权重，此时并不会除以sum(x)。饼状图从x轴开始，逆时针绘制。
explode：如果不是None，则它给出了每个饼的径向偏移量。该偏移量表示：径向偏移除以半径。
colors：给出了每一块饼的颜色。可以为None或者颜色序列
labels：给出了每个饼的字符串标签。可以为None或者字符串序列
autopct：它可以为一个字符串，可以指定每个饼的数值标签，但是该字符串是 fmt%pct，通过pct参数格式化，pct为饼的比重（自动提供）。也可以是一个可调用对象。
pctdistance：若autopct为None，则忽略之。否则就是数值标签的径向距离，它是个相对距离，相对于半径。
labeldistance：控制了饼的字符串标签的径向距离，它是个相对距离，相对于半径。
shadow：一个布尔值，如果为True，则绘制带阴影的饼状图
startangle：如果不是None，则它可控制了第一块饼与x轴的夹角
radius：一个标量，控制了饼状图的半径。如果为None，则默认为 1
counterclock：一个布尔值。如果为True，则为逆时针方向；否则为顺时针排列
wedgeprops：一个字典，控制了每一块饼的某些属性，如线型
textprops：一个字典，控制了饼的文字的一些属性
center：一个二元的元组，指定了饼状图的中心
frame：一个布尔值，控制是否绘制axes frame（也就是背后的数轴）。发现版本1.5.3中，开启它是个Bug，图形混乱。
为了显示好看，建议使用ax.set_aspect(1)将Axes的长宽比设置为 1， 此时的饼状图是个圆形（否则为椭圆）。
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
X = np.linspace(1,10,num=5)
x = [0.1,0.2,0.2,0.4,0.1]
fig = plt.figure(figsize=(10,6))
ax1 = fig.add_subplot(321)
ax1.pie(X)
ax1.set_title("default")
ax2 = fig.add_subplot(322)
ax2.pie(X,explode=[0,0,0.1,0.1,0.2])
ax2.set_title("explode")
ax3 = fig.add_subplot(323)
ax3.pie(x,labels=['a','b','c','d','e'])
ax3.set_title("labels+aspect=1")
ax3.set_aspect(1)
ax4 = fig.add_subplot(324)
ax4.pie(x,autopct="num:%.2f%%")
ax4.set_title("autopct")
ax5 = fig.add_subplot(325)
ax5.pie(x,labels=['a','b','c','d','e'],autopct="num:%.2f%%",pctdistance=1,labeldistance=0.5,shadow=True)
ax5.set_title("pctdistance+labeldistance")
plt.tight_layout()
plt.show()
（46）plot(*args, **kwargs)
功能：绘制line或者marker。他返回line的列表。
最简单的用法是：plot(x,y)，其中x为数据点的横坐标，y为数据点的纵坐标。此时采用默认的线型和颜色。
你也可以设置线型和颜色为 plot(x,y,'bo')：'b'代表颜色为蓝色，'o'代表使用小圆圈标记数据点。'bo'称作plot format string
你也可以省略x：plot(y)。此时隐含着x等于[0,1,...len(y-1)]
如果x/y为二维数组，那么每一行作为一组line来绘制
如果你想一次绘制多条线，可以用plot(x1,y1,'b+',x2,y2,'b-',x3,y3,'bo')
控制marker的字符串可以为：'-'/'--'/'-.'/':'/'.'/','/'o'/'v'/'^'/'<'/'>'/'1'/'2'/'3'/'4'/'s'/'p'/'*'/'h'/'H'/'+'/'x'/'D'/'d'/'|'/'_'
控制颜色的字符串可以为： 'b'/'g'/'r'/'c'/'m'/'y'/'k'/'w'；你也可以指定它们的全名，如'red'；或者指定十六进制字符串'#00ff00；或者指定一个RGB/RGBA元组： (0,1,0)/(0,1,0,1)。
默认情况下，不同的线采用不同的线型，它由rc的axes.prop_cycle参数控制，并且是循环使用。这些参数都可以单独地作为关键字参数来设置。如果一个plot绘制了多条线，则其参数对所有的线起作用。这些关键字全部用于设定Line2D的属性。
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
X = np.linspace(1,10,num=10)
markers = ['-','--','-.',':','.',',','o','v','^','<','>','1','2','3','4','s','p','*','h','H','+','x','D','d','|','_']
colors =[ 'b','g','r','c','m','y','k','w']
fig = plt.figure(figsize=(10,8))
ax1 = fig.add_subplot(2,1,1)
for i,marker in enumerate(markers):
    ax1.plot(X,np.ones_like(X)+i,marker+'b',label="marker:%s"%marker)
ax1.legend(loc="best",ncol=4,framealpha=0.3)
ax1.set_ylim(-1,100)
ax2 = fig.add_subplot(2,1,2)
for i,color in enumerate(colors):
    ax2.plot(X,np.ones_like(X)+i,'-'+color,label="color:%s"%color)
ax2.legend(loc="best",ncol=2,framealpha=0.3)
ax2.set_ylim(-1,9)
（47）plot_date(x, y, fmt='o', tz=None, xdate=True, ydate=False, **kwargs)
功能：绘制日期相关的数据。它类似于plot()方法，但是plot_data的x轴或者y轴可能是日期相关的数据。
x/y：待绘制的点的坐标序列。如果是日期序列，则代表了从 0001-01-01 UTC以来的天数（浮点数）（它映射到整数 1）。日期必须大于等于 0（1代表第一天），且日期跨度大于一个月（31天）
fmt：plot format string，如bo
tz：指定时区。可以为时区字符串，也可以为tzinfo实例或者None
xdate：一个布尔值。如果为True，则x轴为时间序列
ydate：一个布尔值。如果为True，则y轴为时间序列
其他参数用于设定Line2D的属性
注意：plot_date()使用默认的dates.AutoDateLocator/dates.AutoDateFormatter。如果你希望使用自定义的，则你需要在调用plot_date()之后调用方法来设置date ticker/date formatter
设置时区：
from datetime import timezone,timedelta
ax.plot_date(X,Y,tz=timezone(+timedelta(hours=23)))   
设置日期格式化和位置：　　
from matplotlib.dates import AutoDateLocator,AutoDateFormatter,DateFormatter
autoloc = AutoDateLocator() #默认的 formatter
autofmt = AutoDateFormatter() #默认的 locator
myfmt = DateFormatter('%Y-%m-%d %H:%M:%S')#自定义的formatter,使用`strftime()`的格式化方式
ax.xaxis.set_major_locator(autodates)       #设置时间间隔
ax.xaxis.set_major_formatter(myfmt)      #设置时间显示格式
ax.xaxis.set_major_locator()设置x轴的主刻度的locator
ax.xaxis.set_major_formatter()设置x轴的主刻度的formatter
DateFormatter：初始化字符串的解释与strftime()相同
常见的一些DateLocator有：MinuteLocator、HourLocator 、DayLocator、WeekdayLocator、MonthLocator、YearLocator、AutoDateLocator
（48）properties()
功能：返回一个字典，该字典中包含了axes中的所有属性的键值对。
（49）quiver(*args, **kw)
功能：创建一个二维的场向量。
常见的调用方式有： quiver(U,V,**kw)、 quiver(U,V,C,**kw)、quiver(X,Y,U,V,C,**kw)、quiver(X,Y,U,V,C,**kw)。其中 U/V为向量的x轴分量和y轴分量。X/Y为绘制向量的起点坐标。C用于指定每个箭头的颜色。
如果为指定X/Y，则默认每个向量的起点从每个单元格生成。
units：一个字符串，指定箭头的单位。除了箭头的长度以外，其他的度量都是以该单位为准。可以为：
'width'/'height'：以axes的宽度/高度为单位
'dots'/'inches'：以像素点/英寸为单位
'x'/'y'/'xy'：以数据坐标系下的X/Y为单位，而xy'表示数据坐标系下的单位矩形的对角线为单位。
angles：指定向量的角度。正方形可能因为X/Y轴缩放尺度不同而显示为长方形。可以为'uv'，表示只采用U,V的值计算；可以为'xy'，表示角度计算时考虑X轴与Y轴的缩放尺度。
scale：一个浮点数，决定缩放比例。它和scale_units决定了箭头的全长。假如向量的长度计算得到为 10，那么假如scale为 2， 而scale_units为dots，那么该向量的长度为5像素点。
scale_units：一个字符串，指定缩放比例的单位。可以为'width'/'height'/'dots'/'inches'/'x'/'y'/'xy'
width:一个标量，指定箭头的宽度，单位由units参数指定
headwitdh:一个标量，指定箭头的头部的宽度，单位由units参数指定
headlength:一个标量，指定箭头的头部的长度，单位由units参数指定
headaxislength:一个标量，指定的是箭头的头部的左半边小三角与箭杆的相交的长度。单位由units参数指定
minshaft:一个标量，Length below which arrow scales, in units of head length. 。不要设置成小于 1，否则图形很难看
minlength:一个标量，指定所有箭头的最短长度（单位由units参数指定）。如果有的箭头长度小于它，则绘制成一个点。
pivot:一个字符串，控制了箭头旋转的中心。可以为'tail'/'mid'/'middle'/'tip'。tip表示箭头的尖尖。
color:给出了箭头的颜色。如果给出了C参数，则该参数被忽略。
其他参数控制了PolyCollection的属性
X,Y = np.mgrid[10:12,18:20:1]
U = np.arange(4,8).reshape(2,2)
V = U
fig = plt.figure()
ax1 = fig.add_subplot(2,1,1)
ax1.quiver(X,Y,U,V,label="default",color="red")
ax1.quiver(X,Y,U,V,angles="xy",label="xy")
ax1.grid()
ax1.set_xlim(9.5,11.5)
ax1.set_ylim(17.5,19.5)
ax1.set_title("default")
ax1.legend(loc="best")
ax2 = fig.add_subplot(2,1,2)
ax2.quiver(X,Y,U,V,label="scale",color="red",scale=40,scale_units='x')
ax2.quiver(X,Y,U,V,units='dots',width=4,angles="xy",headaxislength=5,
           headwidth=8,headlength=10,scale=40,scale_units="width",
           label="set_width_length")
ax2.quiver(X,Y,U,V,label="pivot_tip",color="green",scale=40,scale_units='x',pivot='tip')
ax2.quiver(X,Y,U,V,label="pivot_mid",color="blue",scale=40,scale_units='x',pivot='mid')
ax2.grid()
ax2.set_xlim(9.5,11.5)
ax2.set_ylim(17.5,19.5)
ax2.set_title("width&length&pivot")
ax2.legend(loc="best")
（50） quiverkey(*args, **kw)
功能：给quiver设置key。常用的调用方式为：quiverkey(Q,X,Y,U,label,**kw)。
Q：一个Quiver实例，由quiver()返回
X/Y：key放置的位置，都是标量
U：key的长度，都是标量
label：一个字符串，指定了标记。
coordinates：一个字符串，指定了X/Y的坐标系。
'axes'：axes坐标系，(0，0)为axes的左下角，(1,1)为axes的右上角。
'figure'：figure坐标系，(0，0)为figure的左下角，(1,1)为figure的右上角。
'data'：data坐标系
'inches'：为figure坐标系，但是以像素点为基准。(0,0)为左下角
color：重写了Q的color
labelpos：放置标记的位置，可以为'N'/'S'/'E'/'W'
labelsep：给出了标记和箭头的距离，单位为英寸
labelcolor：给出了标记的颜色
fontproperties：一个字典或者FontProperties实例，设置了标记的字体。
其他的关键字参数用于重写quiver的一些属性。
X,Y = np.mgrid[10:12,18:20:1]
U = np.arange(4,8).reshape(2,2)
V = U
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
quiver = ax.quiver(X,Y,U,V,label="default",color="red")
ax.quiverkey(quiver,11,19,2,r'$2m/s$',coordinates='data',labelpos="W",\
            fontproperties={'weight':'bold','size':20})
ax.grid()
ax.set_xlim(9.5,11.5)
ax.set_ylim(17.5,19.5)
ax.set_title("default")
ax.legend(loc="best")
（51） remove()
功能：从figure中移除本axes。除非重绘figure，否则看不出来效果。
（52）scatter(x, y, s=20, c=None, marker='o', cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, **kwargs)
功能：绘制散点图。返回一个PathCollection实例。

x/y：数据的x坐标和y坐标，要求它们形状为(n,)
s:指定散点的尺寸，可以为标量，也可以为一个长度为n的序列
c：指定散点的颜色。可以为一个颜色，或者颜色序列
marker：指定散点的类型，默认为'o'。可以为'.',',','o','v','^','<','>','1','2','3','4','s','p','*','h','H','+','x','D','d','|','_','None',None,' ','','$...$'之一。也可以为一个Path实例。也可以是一个元组(numsided,style,angle)：
numsided指定了边的数量
style：可以为0(正多边形）；1（星星状的符号）；2（一个*）;3（一个圆，此时numsided,angle被忽略）
angle：指定了散点旋转的角度（按照角度制而不是弧度制）
cmap：设定一个colormap。可以是Colormap实例，或者它的名字。只有当c参数为一列浮点数时，有效
norm：一个Normalize实例，用于将亮度调整到0~1
vmin,vmax：一个标量，用于辅助默认的norm调整亮度（如果你传入了一个Normalize实例给norm，则该参数忽略）
alpha：一个标量，设置透明度
linewidths：一个标量或者序列，设置线宽
edgecolors：设定边线的颜色，可以为一个颜色，或者颜色序列
其他参数用于设定Collection参数
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
X = np.linspace(1,10,num=20)
fig = plt.figure(figsize=(10,8))
ax1 = fig.add_subplot(2,1,1)
ax1.scatter(X,np.ones_like(X),label='default')
ax1.scatter(X,np.ones_like(X)+1,c='red',label='colored')
ax1.scatter(X,np.ones_like(X)+2,marker=(5,2,30),label='marked')
ax1.scatter(X,np.ones_like(X)+3,marker='s',s=50,label='sized')
ax1.scatter(X,np.ones_like(X)+4,marker='s',edgecolors='g',label='edgecolors')
ax1.legend(loc='best')
（53）semilogx(*args, **kwargs)
功能：它类似plot()，只是将x轴设置为对数坐标。除了多了下面的参数外，其他设置与plot()一样。
basex：一个大于 1 的标量，用于设置对数的底数
subx：一个序列或者None。用于设置x轴的主要刻度值。默认采用自动设定
nonposx：如果为'mask'，则x的负数或者零将被视作无效的数；如果为'clip'，则x的负数或者零将被视作一个非常小的正数（因为对数的自变量要大于零）
 （54）semilogy(*args, **kwargs)
功能：它类似plot()，只是将y轴设置为对数坐标。除了多了下面的参数外，其他设置与plot()一样。
basey：一个大于 1 的标量，用于设置对数的底数
suby：一个序列或者None。用于设置y轴的主要刻度值。默认采用自动设定
nonposy：如果为'mask'，则y的负数或者零将被视作无效的数；如果为'clip'，则y的负数或者零将被视作一个非常小的正数（因为对数的自变量要大于零）
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
X = np.linspace(10,100)
Y = X
fig = plt.figure(figsize=(12,6))
ax1 = fig.add_subplot(2,2,1)
ax1.semilogx(X,Y,basex=2)
ax1.set_title("semilogx:basex=2")
ax2 = fig.add_subplot(2,2,2)
ax2.semilogx(X,Y,basex=2)
ax2.set_title("semilogx:basey=2")
ax3 = fig.add_subplot(2,2,3)
ax3.loglog(X,Y,basex=10,basey=10)
ax3.set_title("loglog:basex=10,basey=10")
plt.tight_layout()
plt.show()
（55）spy(Z, precision=0, marker=None, markersize=None, aspect='equal',origin='upper', **kwargs)
功能：绘制矩阵中的非零值。
Z：待绘制的二维矩阵，它和precision决定了绘制区域。坐标点(i,j)对应于Z[j,i]，即列对应于x轴。
precision：只有Z中的那些大于precision的值才被绘制
marker：用它来表示Z中的非零值
markersize：marker的大小。
aspect：高宽比
origin：参考imshow的origin
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
Z = [[3,3,5,7],[-1,0,2,2],[4,100,2,0]]
fig = plt.figure()
ax1 = fig.add_subplot(1,2,1)
ax1.spy(Z)
ax1.set_title("default")
ax2 = fig.add_subplot(1,2,2)
ax2.spy(Z,precision=1,marker='^')
ax2.set_title("marker&precision")
plt.tight_layout()
（56）stem(*args, **kwargs)
功能：绘制stem图。其调用方式为：




    

stem(y, linefmt='b-', markerfmt='bo', basefmt='r-') 
stem(x, y, linefmt='b-', markerfmt='bo', basefmt='r-')
其中：`linefmt`决定了垂线的格式。`markerfmt`决定了每个`fmt`的格式。`x`决定了每条垂线的位置（如果未提供，则为`[0,1,...len(y)-1]`）。`y`序列决定了每条垂线的高度。 `basefmt`决定了位于`y=0`这条基准直线的格式。　　
fig = plt.figure()
ax1 = fig.add_subplot(1,2,1)
ax1.stem(y,linefmt='b-.',markerfmt='ys',basefmt='r-')
ax1.set_title("y")
ax2 = fig.add_subplot(1,2,2)
ax2.stem(x,y,linefmt='b-',markerfmt='bo',basefmt='r-')
ax2.set_title("x&y")
（57）step(x, y, *args, **kwargs)
功能：绘制阶梯图。调用方式为step(x, y, *args, **kwargs)
x/y：都是一维序列，并且假设x为单调递增的（如果不满足，也不报错）
where：指定分步类型。可以为'pre'/'post'/'mid'
其他参数与plot()相同
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(1,10,num=10)
y = x ** 2
fig = plt.figure()
ax1 = fig.add_subplot(1,3,1)
ax1.step(x,y,'r',where='pre')
ax1.set_title("pre")
ax2 = fig.add_subplot(1,3,2)
ax2.step(x,y,'g',where='post')
ax2.set_title("post")
ax3 = fig.add_subplot(1,3,3)
ax3.step(x,y,'b',where='mid')
ax3.set_title("mid")
plt.tight_layout()
plt.show()
（58） streamplot(x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=1, start_points=None)
功能：绘制向量场流线。
x/y：一维数组，给出了网格的坐标
u/v：二维数组，给出了每个网格的向量。其行数等于y的长度，列数等于x的长度
density：一个浮点数或者浮点数的二元元组。控制了绘制向量场的密度。
linewidth：标量或者二维数组，给出了每个向量箭头的线宽
color：标量或者二维数组，给出了每个向量箭头的颜色
cmap：一个Colormap实例。当color是一个二维数组时，它配合使用，给出了每个向量箭头的颜色
norm：一个Normalize实例。当color是一个二维数组时，它配合使用，将颜色亮度调整为0~1
arrowsize：一个浮点数，给出了箭头缩放比例
arrowstyle：一个字符串，给出了箭头的类型。
minlength：一个浮点数，限定了最小的向量长度
start_points：它是一个N*2的数组，N流线起点的个数，给出了流线起始点的位置
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(1,5,num=10)
y = np.linspace(1,5,num=10)
u,_ = np.meshgrid(x,y)
v = u ** 2
fig = plt.figure()
ax1 = fig.add_subplot(1,2,1)
ax1.streamplot(x,y,u,v)
ax1.quiver(x,y,u,v)
ax1.set_title("default")
ax2 = fig.add_subplot(1,2,2)
ax2.streamplot(x,y,u,v,density=0.5,arrowsize=2,arrowstyle='->')
ax2.quiver(x,y,u,v,label='quiver',width=4,units="dots",scale=0.5,scale_units="dots")
ax2.set_title("styled")
table(cellText=None, cellColours=None,
cellLoc='right', colWidths=None,  rowLabels=None, rowColours=None, rowLoc='left',  colLabels=None, colColours=None, colLoc='center',  loc='bottom', bbox=None)
（60）text(x, y, s, fontdict=None, withdash=False, **kwargs)
功能：添加文本，返回一个Text实例。
s：一个字符串，被添加的文本
x/y：一个标量，文本被添加的坐标
fontdict：一个字典，给出了字体属性。
withdash：一个布尔值。如果为True，则创建一个TextWithDash实例而不是Text实例。
其他参数用于控制Text属性
（61）tick_params(axis='both', **kwargs)
功能：控制tick和tick label。
axis：一个字符串，指定要控制那个轴。可以为'x'/'y'/'both'
reset：一个布尔值。如果为True，那么在进行处理其他关键字参数之前，先恢复默认值。默认为False
which：一个字符串，指定控制主刻度还是次刻度。可以为'major'/'minor'/'both'
direction：一个字符串，控制将刻度放置在axes里面还是外面。可以为'in'/'out'/'inout'
length：一个标量值。给出了每个刻度线的长度（就是那个小竖线），单位为像素点
width：一个标量值。给出了每个刻度线的宽度（就是那个小竖线），单位为像素点
color：给出刻度线的颜色
pad：一个标量值，给出了刻度线和刻度label之间的距离，单位为像素点
labelsize：一个标量值，给出了刻度label的字体大小。可以为数值，单位为像素点。也可以为字符串，如large'
labelcolor：给出了刻度label的颜色
colors：同时调整刻度线的颜色和刻度label的颜色
bottom/top/left/right：一个布尔值或者字符串'on'/'off'。控制是否绘制对应位置的刻度线
labelbottom/labeltop/labelleft/labelright：一个布尔值或者字符串'on'/'off'。控制是否绘制对应位置的刻度label
（62）vlines(x, ymin, ymax, colors='k', linestyles='solid', label='', **kwargs)
功能：绘制一群垂直线。
x：标量或者一维数组，给出了垂线的位置
ymin/ymax：给出了垂线的起始和终止位置。如果是个标量，则所有垂线共享该值
colors：给出垂线的颜色
linestyles：给出了垂线的线型
label：一个字符串
其他关键字参数设置LineCollection参数
（63）xcorr(x, y, normed=True, detrend=<function detrend_none>, usevlines=True,maxlags=10, **kwargs)
功能：绘制互相关图。参数解释参考acorr()自相关函数。
3. Axis类
（1）matplotlib.axis.Axis实例处理tick line、grid line、tick label以及axis label的绘制，它包括坐标轴上的刻度线、刻度label、坐标网格、坐标轴标题。通常你可以独立的配置y轴的左边刻度以及右边的刻度，也可以独立地配置x轴的上边刻度以及下边的刻度。
刻度包括主刻度和次刻度，它们都是Tick刻度对象。
（2）Axis也存储了数据用于内部的缩放以及自适应处理。它还有Locator实例和Formatter实例用于控制刻度线的位置以及刻度label。
（3）每个Axis都有一个.label属性，也有主刻度列表和次刻度列表。这些tick是XTick和YTick的实例，他们存放着实际的line primitive以及text primitive来渲染刻度线以及刻度文本。
（4）刻度是动态创建的，只有在需要创建的时候才创建（比如缩放的时候）。Axis也提供了一些辅助方法来获取刻度文本、刻度线位置等等：
Axis.get_major_ticks()：获取主刻度列表（一个Tick对象的列表）
Axis.get_minor_ticks()：获取次刻度列表（一个Tick对象的列表）
Axis.get_majorticklabels()：获取主刻度label列表（一个Text对象的列表）
Axis.get_majorticklines():获取主刻度线（一个Line2D对象的列表）
Axis.get_ticklocs()：获取刻度线位置的列表。 可以通过minor=True|False关键字参数控制输出minor还是major的tick location。
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_scale()：获取坐标轴的缩放属性，如'log'或者'linear'
Axis.get_view_interval():获取内部的axis view limits实例
Axis.get_data_interval():获取内部的axis data limits实例
Axis.get_gridlines():获取grid line的列表
Axis.get_label():获取axis label(一个Text实例)
Axis.get_label_text():获取axis label的字符串
Axis.get_major_locator():获取major tick locator(一个matplotlib.ticker.Locator实例)
Axis.get_minor_locator():获取minor tick locator(一个matplotlib.ticker.Locator实例)
Axis.get_major_formatter():获取major tick formatter(一个matplotlib.ticker.Formatter实例)
Axis.get_minor_formatter():获取minor tick formatter(一个matplotlib.ticker.Formatter实例)
Axis.grid(b=None,which='major',**kwargs):一个开关，用于控制major或者minor的tick的on|off
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib
fig = plt.figure()
rect = fig.patch # fig的Rectangle
rect.set_facecolor('lightgoldenrodyellow')
ax = fig.add_subplot(111) # 创建 Axes
rect = ax.patch # ax的Rectangle
rect.set_facecolor("lightslategray")
axis = ax.xaxis # 轴
axis.get_ticklocs() # tick location,array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])
axis.get_ticklabels() # tick label,<a list of 6 Text major ticklabel objects>
axis.get_ticklines() # tick line ,<a list of 12 Line2D ticklines objects>
axis.get_scale() # 缩放类型，'linear'
axis.get_gridlines() # grid，<a list of 6 Line2D gridline objects>
for label in ax.xaxis.get_ticklabels():
    label.set_color("red")
    label.set_rotation(45)
    label.set_fontsize(16)
for line in ax.yaxis.get_ticklines():
    line.set_color("green")
    line.set_markersize(15)
    line.set_markeredgewidth(5)    
plt.tight_layout()    
fig.show()   
（5） Axis 方法
axis_date(tz=None)：将x轴视作时间轴
cla()：清除axis
get_xxx()方法：参考前面叙述的内容
set_xxx()方法：对应的设置方法。
（6）获取刻度线或者刻度label之后，可以设置其各种属性，如可以对刻度label旋转 30度：
for line in axis.get_majorticklabels():
    line.set_rotation(30)
4. Tick类
 （1）matplotlib.axis.Tick类是从Figure-->Axes-->Tick这个container体系中最末端的container。Tick容纳了tick、grid line以及tick对应的label。所有的这些都可以通过Tick的属性获取:
Tick.tick1line：一个Line2D实例
Tick.tick2line：一个Line2D实例
Tick.gridline：一个Line2D实例
Tick.label1：一个Text实例
Tick.label2：一个Text实例
Tick.gridOn：一个布尔值，决定了是否绘制tickline
Tick.tick1On：一个布尔值，决定了是否绘制1st tickline
Tick.tick2On：一个布尔值，决定了是否绘制2nd tickline
Tick.label1On：一个布尔值，决定了是否绘制1st tick label
Tick.label2On：一个布尔值，决定了是否绘制2nd tick label
y轴分为左右两个，因此tick1*对应左侧的轴；tick2*对应右侧的轴。 x轴分为上下两个，因此tick1*对应下侧的轴；tick2*对应上侧的轴。
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(100*np.random.rand(20)) # 添加Line2D
formatter = matplotlib.ticker.FormatStrFormatter("$%1.2f")
ax.yaxis.set_major_formatter(formatter) # 设置major_formatter
for tick in ax.yaxis.get_major_ticks():
    tick.label10n = True
    tick.label20n = True
    tick.label1.set_color("red")
    tick.label2.set_color("green")
fig.show()
（2）方法有：
get_loc()：以标量的形式返回Tick的坐标
get_pad()：返回Tick的label和刻度线之间的距离（单位为像素点）
set_label(s)/set_label1(s)/set_label2(s)：设置label
set_pad(val)：设置Tick的label和刻度线之间的距离（单位为像素点）
三、primitive
1.Line2D类
matplotlib.lines.Line2D类是matplotlib中的曲线类（基类是matplotlib.artist.Artist），它可以有各种各样的颜色、类型、以及标注等等。它的构造函数为：
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)
这些关键字参数都是Line2D的属性。其属性有：
继承自Artist基类的属性：.alpha、.animated、.axes、.clip_box、..clip_on、.clip_path、.contains、.figure、.gid、.label、.picker、.transform、.url、.visible、.zorder
.antialiased或者.aa属性：一个布尔值。如果为True则表示线条是抗锯齿处理的
.color或者.c属性：一个matplotlib color值，表示线条的颜色，
.dash_capstyle属性：为'butt' or 'round' or 'projecting'，表示虚线头端类型
.dash_joinstyle属性：为'miter' or 'round' or 'bevel'，表示虚线连接处类型
.dashes属性：一个数值序列，表示虚线的实部、虚部的尺寸。如果为(None,None)则虚线成为实线
.drawstyle属性：为'default'or'steps'or'step-pre'or'step-mid'or'step-post'，表示曲线类型。
'default'：点之间以直线连接
'steps*'：绘制阶梯图。其中steps等价于steps-pre，是为了保持兼容旧代码
.fillstyle属性：为'full'or'left'or'right'or'bottom'or'top'or'none'表示marker的填充类型。
'full'：填充整个marker
none：不填充marker
其他值：表示填充一半marker
.linestyle或者ls属性：指定线型，可以为以下值：
'-'或者'solid'：表示实线
'--'或者dashed：表示虚线
'-.'或者dash_dot：表示点划线
':'或者'dotted'：表示点线
'None'或者' '或者''：表示没有线条（不画线）
.linewidth或者lw属性：为浮点值，表示线条宽度
.marker属性：可以为一系列的字符串，如'.'、','、'o'....,表示线条的marker
.markeredgecolor或者.mec属性:可以为matplotlib color，表示marker的边的颜色
.markeredgewidth或者.mew属性:可以为浮点数，表示marker边的宽度
.markerfacecolor或者.mfc属性：可以为matplotlib color，表示marker的前景色
.markerfacecoloralt或者.mfcalt属性：可以为matplotlib color，表示marker的可选前景色
.markersize或者.ms属性：可以为浮点数，表示marker的大小
.markevery属性：指定每隔多少个点绘制一个marker，可以为以下值：
None：表示每个点都绘制marker
N：表示每隔N个点绘制marker，从0开始
(start,N)：表示每隔N个点绘制marker，从start开始
[i,j,m,n]：只有点i,j,m,n的marker绘制
...其他值参考文档
.pickradius属性：浮点值，表示pick radius
.solid_capstyle属性：可以为'butt'、'round'、'projecting'，表示实线的头端类型
.sold_joinstyle属性：可以为'miter'、'round'、'bevel'，表示实线连接处的类型
.xdata属性：可以为一维的numpy.array，表示x轴数据
.ydata属性：可以为一维的numpy.array，表示y轴数据
2.Text类
matplotlib.text.Text类是绘制文字的类（基类是matplotlib.artist.Artist）。它的构造函数为：
Text(x=0, y=0, text='', color=None, verticalalignment='baseline',
  horizontalalignment=’left’, multialignment=None, fontproperties
  =None, rotation=None, linespacing=None, rotation_
  mode=None, usetex=None, wrap=False, **kwargs)
这些关键字参数也是属性。其属性有：
继承自Artist基类的属性：.alpha、.animated、.axes、.clip_box、..clip_on、.clip_path、.contains、.figure、.gid、.label、.picker、.transform、.url、.visible、.zorder
.backgroundcolor属性：背景色，可以为任何matplotlib color
.bbox属性：文本框的边框。其值是FancyBboxPatch类的属性字典。
.color属性：字体颜色，可以为任何matplotlib color
.family或者.name或者.fontfamily或者.fontname属性：字体的名字。可以是string或者string list（表示可以为若干个名字，优先级依次递减）。string必须是一个真实字体的名字，或者一个字体的class name。
.fontproperties或者.font_properties属性：字体的属性，值是一个matplotlib.font_manager.FontProperties实例（该实例一次性设置字体的很多属性，比如字体类型、字体名字、字体大小、宽度、...）
.horizontalalignment或者.ha属性：水平对齐方式，可以为'center'、'right'、'left'
.linespacing属性：为浮点数，单位为font size，表示行间距
.multialignment属性：multiline text对齐方式，可以为'left'、'right'、'center'
.position属性：为一个元组(x,y)，表示文本框的位置
.rotation属性：字体旋转角度。可以为下列值：
浮点数，表示角度
'vertical'、'horizontal'
.rotation_mode属性：旋转模式。可以为下列值：
'anchor'：文本首先对齐，然后根据对齐点来旋转
None：文本先旋转，再对齐
.size或者.fontsize属性：字体大小。可以为下列值：
浮点值，表示字体大小
'xx-small'、'x-small'、'small'、'medium'、'large'、'x-large'、'xx-large'
.stretch或者.fontstretch属性：字体沿水平方向的拉伸。可以为下列值：
整数，在[0---1000]之间
'ultra-condensed'、'extra-condensed'、'condensed'、'semi-condensed' 、'normal'、'semi-expanded'、'expanded'、'extra-expanded'、'ultra-expanded'
.style或者.fontstyle属性：字体样式，可以为'normal'、'italic'、'oblique'
.text属性：文本字符串，可以为任意字符串（他可以包含'\n'换行符或者LATEX语法）
.variant或者.fontvariant属性：表示字体形变，可以为下列值：'normal'、'small-caps'
.verticalalignment或者.ma或者.va属性：表示文本的垂直对齐，可以为下列值：
'center'、'top'、'bottom'、'baseline'
.weight或者.fontweight属性：设置字体的weight，可以为下列值：
一个整数值，在[0---1000]之间
'ultralight'、'light'、'normal'、'regular'、'book'、'medium'、 'roman'、'semibold'、'demibold'、'demi'、'bold'、'heavy'、 'extrabold'、'black'
.x属性：一个浮点值，表示文本框位置的x值
.y属性：一个浮点值，表示文本框位置的y值
3.Annotation类　　
matplotlib.text.Annotation类是图表中的图式，它是一个带箭头的文本框，用于解说图表中的图形。它的基类是matplotlib.text.Text和matplotlib.text._AnnotationBase。其构造函数为：
Annotation(s, xy, xytext=None, xycoords=’data’, textcoords=None, arrowprops
  =None, annotation_clip=None, **kwargs)
在位置xytext处放置一个文本框，该文本框用于解释点xy，文本框的文本为s。
s：文本框的文本字符串
xy：被解释的点的坐标
xytext：文本框放置的位置。如果为None，则默认取xy
xycoords：xy坐标系，默认取'data'坐标系（即xy是数据坐标系中的点）。可以为以下值：
'figure points'：从figure左下角开始的点
'figure pixesl'：从figure左下角开始的像素值
'figure fraction'：(0,0)代表figure的左下角，(1,1)代表figure的右上角
'axes points'：从axes左下角开始的点
'axes pixels'：从axes左下角开始的像素
'axes fraction'：(0,0)代表axes的左下角，(1,1)代表axes的右上角
'data'：使用被标注对象的坐标系
'offset points'：指定从xy的偏移点
'polar'：极坐标系
textcoords：文本框坐标系（即xytext是文本坐标系中的点），默认等于xycoords
arrowprops：指定文本框和被解释的点之间的箭头。如果不是None，则是一个字典，该字典设定了matplotlib.lines.Line2D的属性。
如果该字典有一个arrowstyle属性，则该键对应的值也是一个字典，创建一个FancyArrowsPatch实例，实例属性由该字典指定。
如果该字典没有arrowstyle属性，则创建一个YAArrow实例，
annotation_clip：控制超出axes区域的annotation的显示。如果为True则annotation 只显示位于axes区域内的内容。
额外的关键字参数全部是设置Text的属性
4.Legend　　
matplotlib.legend.Legend是图例类，它的基类是matplotlib.artist.Artist。其构造函数为：
  Legend(parent, handles, labels, loc=None, numpoints=None, markerscale
  =None, markerfirst=True, scatterpoints=None,
  scatteryoffsets=None, prop=None, fontsize=None, borderpad
  =None, labelspacing=None, handlelength=None,
  handleheight=None, handletextpad=None, borderaxespad
  =None, columnspacing=None, ncol=1, mode=None,
  fancybox=None, shadow=None, title=None, framealpha
  =None, bbox_to_anchor=None, bbox_transform=None,
  frameon=None, handler_map=None)
其关键字参数为：
parent：持有该legend的artist
loc：图例的位置。其值可以为字符串或者数字：
best或0：自动计算
upper right或1： 右上角
upper left或2：上角
lower left或3：下角
lower right或4：右下角
right或5：右边
center left或6：中间偏左
center right或7：中间偏右
lower center或8：中间底部
upper center或9：中间顶部
center或10：正中央
handle：一个artist列表，添加这些artist到legend中
lebels：一个字符串列表添加到legend中
prop：字体属性
fontsize: 字体大小（只有prop未设置时有效）
markerscale: marker的缩放比例（相对于原始大小）
markerfirst: 如果为True，则marker放在label左侧；否则marker放在label右侧
numpoints: the number of points in the legend for line为线条图图例条目创建的标记点数
scatterpoints: the number of points in the legend for scatter plot为散点图图例条目创建的标记点数
scatteryoffsets: a list of offsets for scatter symbols in legend为散点图图例条目创建的标记的垂直偏移量
frameon: if True, draw a frame around the legend. If None, use rc控制是否应在图例周围绘制框架
fancybox: if True, draw a frame with a round fancybox. If None, use rc控制是否应在构成图例北京的FancyBboxPatch周围启用圆边
shadow: if True, draw a shadow behind legend控制是否在图例后面画一个阴影
framealpha: If not None, alpha channel for the frame.控制图例框架的Alpha透明度
ncol: number of columns设置图例分为n列展示
borderpad: the fractional whitespace inside the legend border图例边框的内边距
labelspacing: the vertical space between the legend entries图例条目之间的垂直间距
handlelength: the length of the legend handles图例句柄的长度
handleheight: the height of the legend handles图例句柄的高度
handletextpad: the pad between the legend handle and text图例句柄和文本之间的间距
borderaxespad: the pad between the axes and legend border轴域图例边框之间的距离
columnspacing：the spacing between columns列间距
title: 图例的标题
bbox_to_anchor: the bbox that the legend will be anchored.指定图例在轴的位置
bbox_transform: the transform for the bbox. transAxes if Noneloc a location code
其他关键字参数用于设置属性
继承自Artist基类的属性： .alpha、.animated、.axes、.clip_box、..clip_on、.clip_path、.contains、 .figure、.gid、.label、.picker、.transform、.url、.visible、.zorder
5.Patch类
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)
edgecolor：可以为matplotlib color，表示边线条的颜色，若为none则表示无颜色
facecolor：可以为matplotlib color，表示前景色，若为none则表示无颜色
color可以为matplotlib color，表示边线条和前景色的颜色。
linewidth：为浮点数，表示线条宽度
linestyle：指定线型，可以为以下值：
'-'或者'solid'：表示实线
'--'或者dashed：表示虚线
'-.'或者dash_dot：表示点划线
':'或者'dotted'：表示点线
'None'或者' '或者''：表示没有线条（不画线）
antialiased：一个布尔值。如果为True则表示线条是抗锯齿处理的
hatch：设置hatching pattern，可以为下列的值：
'\'、'|'、'-'、'+'、'x'、'o'、'0'、'.'、'*'
fill：为布尔值。如果为True则填充图形，否则不填充
capstyle：为'butt' or 'round' or 'projecting'，表示线条头端类型
joinstyle：可以为'miter'、'round'、'bevel'，表示矩形线条接头类型
其他关键字参数用于设置属性
如果 edgecolor, facecolor, linewidth, or antialiased 为None则这些值从rc params中读取
属性如下：
继承自Artist基类的属性：.alpha、.animated、.axes、.clip_box、..clip_on、.clip_path、.contains、 .figure、.gid、.label、path_effects、.picker、.transform、.url、.visible、 .zorder
.antialiased或者.aa属性：一个布尔值。如果为True则表示线条是抗锯齿处理的
.capstyle属性：为'butt' or 'round' or 'projecting'，表示线条头端类型
.color属性：可以为matplotlib color，表示边线条和前景色的颜色。
.edgecolor或者.ec属性：可以为matplotlib color，表示边线条的颜色，若为none则表示无颜色
.facecolor或者.fc属性：可以为matplotlib color，表示前景色，若为none则表示无颜色
.fill属性：为布尔值。如果为True则填充图形，否则不填充
.hatch属性：设置hatching pattern，可以为下列的值：
'\'、'|'、'-'、'+'、'x'、'o'、'0'、'.'、'*'
.joinstyle属性：可以为'miter'、'round'、'bevel'，表示矩形线条接头类型
.linestyle或者.ls属性：指定线型，可以为以下值：
'-'或者'solid'：表示实线
'--'或者dashed：表示虚线
'-.'或者dash_dot：表示点划线
':'或者'dotted'：表示点线
'None'或者' '或者''：表示没有线条（不画线）
.linewidth或者.lw属性：为浮点数，表示线条宽度
6.Rectangle类　　
matplotlib.patches.Rectangle类是矩形类（基类是matplotlib.patches.Patch），其构造函数为：Rectangle(xy,width,height,angle=0.0,**kwargs)。
xy：矩形左下角坐标
width：矩形宽度
height：矩形高度
其他关键字参数用于设置属性
其属性有：
继承自Artist基类的属性： .alpha、.animated、.axes、.clip_box、..clip_on、.clip_path、.contains、 .figure、.gid、.label、.picker、.transform、.url、.visible、.zorder
继承自Patch基类的属性： .antialiased或者.aa、.capstyle、.color、.edgecolor或者.ec、.facecolor或者.fc、.fill、.hatch、.joinstyle、.linestyle或者.ls、.linewidth或者.lw属性
7.Polygon类
matplotlib.patches.Polygon类是多边形类。其基类是matplotlib.patches.Patch。其构造函数为： Polygon(xy, closed=True, **kwargs)。
xy是一个N×2的numpy array，为多边形的顶点。
closed为True则指定多边形将起点和终点重合从而显式关闭多边形。
其他关键字参数用于设置属性
Polygon的属性有：
继承自Artist基类的属性： .alpha、.animated、.axes、.clip_box、..clip_on、.clip_path、.contains、 .figure、.gid、.label、.picker、.transform、.url、.visible、.zorder
继承自Patch基类的属性： .antialiased或者.aa、.capstyle、.color、.edgecolor或者.ec、.facecolor或者.fc、.fill、.hatch、.joinstyle、.linestyle或者.ls、.linewidth或者.lw属性
8.PolyCollection类
matplotlib.collections.PolyCollection是多边形集合类，其基类是matplotlib.collections._CollectionWithSizes。它的构造函数为：PolyCollection(verts, sizes=None, closed=True, **kwargs)。
其关键字参数为：
verts：一个顶点序列。每个顶点都由xy元组或者xy数组组成
sizes：一个浮点数序列，依次指定每个顶点正方形的边长。如果序列长度小于顶点长度，则循环从序列头部再开始 挑选
closed：如果为True，则显式封闭多边形
edgecolors: collection的边的颜色
其他关键字参数用于设置属性
下面为属性：
继承自Artist基类的属性： .alpha、.animated、.axes、.clip_box、..clip_on、.clip_path、.contains、 .figure、.gid、.label、.picker、.transform、.url、.visible、.zorder
.facecolors: collection的前景色
.linewidths: collection的边线宽
.antialiaseds:抗锯齿属性，可以为True或者False
.offsets: 设置collection的偏移
.norm: 归一化对象
.cmap:color map
参考文献：
【1】Artist tutorial — Matplotlib 3.1.1 documentation
【2】matplotlib命令与格式：tick刻度对象命令合集_开码河粉-CSDN博客