python可视化 Task02

学习参考：

1. https://github.com/datawhalechina/fantastic-matplotlib
   2.https://www.bookstack.cn/read/huaxiaozhuan-ai/spilt.2.333f5abdbabf383d.md

1.matplotlib绘图逻辑

1. matplotlib的逻辑是用Artist对象在画布(canvas)上绘制(Render)图形，包含三个层次的API：
   （1）matplotlib.backend_bases.FigureCanvas 代表了绘图区，在这个绘图区上图表被绘制
   （2）matplotlib.backend_bases.Renderer 代表了渲染器，控制如何在 FigureCanvas 上画图。
   （3）matplotlib.artist.Artist 代表了具体的图表组件，调用了Renderer的接口在Canvas上作图，Artist就是具体的调用接口来做出我们想要的图，比如图形、文本、线条的设定。

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

3. matplotlib的标准使用流程为：
   （1）创建一个Figure实例
   （2）使用Figure实例创建一个或者多个Axes或Subplot实例
   （3）使用Axes实例的辅助方法来创建primitive

4. 在图形中的每一个元素都对应着一个matplotlib Artist，且都有其对应的配置属性列表：
   （1）Figure.patch属性：是一个Rectangle，代表了图表的矩形框，它的大小就是图表的大小， 并且可以通过它设置figure的背景色和透明度。
   （2）Axes.patch属性：也是一个Rectangle，代表了绘图坐标轴内部的矩形框（白底黑边）， 通过它可以设置Axes的颜色、透明度等。
   每个matplotlib Artist都有以下属性：

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

5. 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") 来获取属性，如果指定属性名，则返回对象的该属性值；如果不指定属性名，则返回对象的所有的属性和值。

2.primitives基本要素

介绍 primitives 的几种类型：曲线-Line2D，矩形-Rectangle，图像-image

2.1 2DLines类

matplotlib.lines.Line2D类是matplotlib中的曲线类（基类是matplotlib.artist.Artist），它可以有各种各样的颜色、类型、以及标注等等。它的构造函数为：

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)
#关键字参数继承自Artist基类的属性

其中常用的的参数有：
xdata:需要绘制的line中点的在x轴上的取值，若忽略，则默认为range(1,len(ydata)+1)
ydata:需要绘制的line中点的在y轴上的取值
linewidth:线条的宽度
linestyle:线型
color:线条的颜色
marker:点的标记，
markersize:标记的size
Line2D官方文档(https://matplotlib.org/api/_as_gen/matplotlib.lines.Line2D.html#examples-using-matplotlib-lines-line2d)

有三种方法可以用设置Line2D的属性。
(1) 直接在plot()函数中设置

import matplotlib.pyplot as plt
x = range(0,5)
y = [2,5,7,8,10]
plt.plot(x,y, linewidth=10) # 设置线的粗细参数为10

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

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

注：plt.plot() 返回list对象，该对象长度为1，通过解包将其中的matplotlib.lines.Line2D对象赋给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)

• 绘制直线line常用的方法有两种:
  (1)pyplot方法绘制
  (2)Line2D对象绘制

(1)pyplot方法绘制

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

2)Line2D对象绘制

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))
plt.show()

2.2 patches

matplotlib.patches.Patch类是二维图形类（包含Rectangle,Polygon,Arrow,Rectangle等多个图形类）。它的基类是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)

matplotlib中的rectangle、circle、polygon等所有简单的简单图形都采用简单的路径path去实现的，只不过用类的形式进行了更高级的封装。

2.2.1 Rectangle-矩形

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

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

以 plt.hist() 函数为例，展示在底层创建Rectangle实例绘制直方图的逻辑：
（1) plt.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则显示频率统计结果
histtype: 可选{‘bar’, ‘barstacked’, ‘step’, ‘stepfilled’}之一，默认为bar
align: 可选{‘left’, ‘mid’, ‘right’}之一，默认为’mid’，控制柱状图的水平分布，left或者right，会有部分空白区域，推荐使用默认
log: bool，默认False,即y坐标轴是否选择指数刻度
stacked: bool，默认为False，是否为堆积状图

import numpy as np 
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)#alpha设置透明度，0为完全透明 
plt.xlabel('scores') 
plt.ylabel('count') 
plt.xlim(0,100)#设置x轴分布范围 plt.show()

(2) 创建Rectangle实例绘制直方图

import pandas as pd
import re
# 对上述创建的数据集x进行分为10组，对于plt.hist()中的bins分组参数
df = pd.DataFrame(columns = ['data'])
df.loc[:,'data'] = x
df['fenzu'] = pd.cut(df['data'], bins=bins, right = False,include_lowest=True)  # 把一组数据分割成离散的左开右闭区间(https://www.cnblogs.com/sench/p/10128216.html)
df

x=df[‘data’]:array-like(一维数组)
bins = bins:bins是被切割后的区间，有3种形式：

1. int型的标量
   当bins为一个int型的标量时，代表将x平分成bins份。x的范围在每侧扩展0.1%，以包括x的最大值和最小值。
2. 标量序列
   标量序列定义了被分割后每一个bin的区间边缘，此时x没有扩展。
3. pandas.IntervalIndex 定义要使用的精确区间。

right=False: bool型参数，默认为True，表示是否包含区间右部。
include_lowest=True：bool型的参数，表示区间的左边是开还是闭的，默认为false，也就是不包含区间左部（闭）。
retbins=False：给分割后的bins打标签，labels的长度必须和划分后的区间长度相等，比如bins=[1,2,3]，划分后有2个区间(1,2]，(2,3]，则labels的长度必须为2。如果指定labels=False，则返回x中的数据在第几个bin中（从0开始）。

df['fenzu'].value_counts()  # 统计每个分割区间的数量

df_cnt = df['fenzu'].value_counts().reset_index()  # 按照区间数量的大小排序
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

df_cnt.sort_values('mini',ascending = True,inplace = True)  # 数据框按照'mini'列数值大小（ascending = True，有小到大）排序，并替换原数据框（inplace = True）
df_cnt

df_cnt.reset_index(inplace = True,drop = True)  # 经过以上变化后，索引需要重新排序，替换原数据框（inplace = True，默认值为False），不保留索引列（drop = True，默认值为False）
df_cnt

#用Rectangle把hist绘制出来
fig = plt.figure()
ax1 = fig.add_subplot(111)

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'])  # 创建图形对象rect，包含10个小的Rectangle
    # 每个Rectangle的位置和大小由((x,y),width,height)参数决定
    ax1.add_patch(rect)  # 将图形对象rect添加进坐标系ax1中
ax1.set_xlim(0, 100)
ax1.set_ylim(0, 16)
plt.show()  # 创建底层的Recentagle对象实现了plt.hist()

2.2.2 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、[颜色]组来绘制多个多边形。

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)

2.2.3 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：契型的形状，一维数组。（饼图的每部分的定义为 x/sum(x)，或者在 sum(x) <= 1 为 x）
• explode：如果不是等于None，则是一个len(x)数组，它指定用于偏移每个楔形块的半径的分数。（每一块离开中心的距离）
• labels：用于指定每个契型块的标记，取值是列表或为None。
• colors：饼图循环使用的颜色序列。如果取值为None，将使用当前活动循环中的颜色。
• startangle：饼状图开始的绘制的角度。(扇区将从 x 轴（角度 0）开始逆时针排列；如果指定atartangle 的值为 90，饼图将从 y 轴开始)
• autopct： 格式化绘制在圆弧中的标签
• shadow: bool值，为饼图添加阴影效果，默认为False

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) 
ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle. 
plt.show()

from matplotlib.patches import Circle, Wedge
from matplotlib.patches import Circle, Wedge

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),             # Full circle
    Wedge((0.3, 0.3), .2, 54, 162),  # Full ring
    Wedge((0.3, 0.3), .2, 162, 324),              # Full sector
    Wedge((0.3, 0.3), .2, 324, 360),  # Ring sector
]
patches

colors = 100 * np.random.rand(len(patches))
p = PatchCollection(patches, alpha=0.4)
p.set_array(colors)
ax1.add_collection(p)
plt.show()

2.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=<deprecated parameter>, edgecolors=None, *, plotnonfinite=False, data=None, **kwargs)

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

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

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

2.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=<deprecated parameter>, filternorm=1, filterrad=4.0, imlim=<deprecated parameter>, resample=None, url=None, *, data=None, **kwargs）

使用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)  # 4*4二维数组
fig, axs = plt.subplots(nrows=3, ncols=6, figsize=(9, 6),  # 创建3*6个子图
                        subplot_kw={
     'xticks': [], 'yticks': []})  
  #subplot_kw：把字典的关键字传递给add_subplots()来创建每个子图
  #将xticks和yticks设定为空列表，用以隐藏图形的x轴和y轴刻度
#fig, axs = plt.subplots(nrows=3, ncols=6, figsize=(9, 6))
for ax, interp_method in zip(axs.flat, methods):  # axs.flat为axs数组迭代器，包含多个matplotlib.axes._subplots.AxesSubplot对象
    ax.imshow(grid, interpolation=interp_method, cmap='viridis')  # cmap设定配色方案（默认：'viridis'）
    ax.set_title(str(interp_method))

plt.tight_layout()  # 自动调整图形的坐标轴标签、刻度标签以及标题大小，避免图形之间的堆叠
plt.show()

3 对象容器 - Object container

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

3.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两个实例, 刚刚添加的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HNbVngE7-1608304901127)(en-resource://database/595:0)]
由于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)
for ax in fig.axes:  # fig.axes为Axes实例的列表
    ax.grid(True)

3.2 Axes容器

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

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

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还包含两个最重要的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.3 Axis容器

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

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

每个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, '-')

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()# 获取轴视角（位置）的间隔

3.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)
plt.show()

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

%matplotlib inline
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
import numpy as np

x = np.linspace(-2*np.pi,2*np.pi,100)
y = [x,x**2,x**3,np.sin(x),np.cos(x),1.0/(1.0+np.exp(-x))]
fig, axs = plt.subplots(nrows = 2, ncols = 3)
for i in range(6):
    line = Line2D(x,y[i])
    r = i//3
    c = i%3
    axs[r,c].add_line(line)
    axs[r,c].set_xlim(min(x)-0.2, max(x)+0.2)
    axs[r,c].set_ylim(min(y[i])-0.2, max(y[i])+0.2)
    
fig.suptitle(t = 'super title',x = 0.5,y = 1.05,fontsize = 16.0)
fig.text(x = 0.5, y = 0, s = 'X axis',fontsize = 14.0)
fig.text(x = 0, y = 0.5, s = 'Y axis', rotation = 'vertical',fontsize = 14.0)
plt.tight_layout()
plt.show()

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

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

x = np.arange(0,10,0.1)
y = -1 * (x - 2) * (x - 8) +10
fig,axs = plt.subplots(2, 1)
axs[0].plot(x, y, color='red')
for i in np.arange(20,90,1):
    rect = plt.Rectangle((x[i],0),width = (x[i+1]-x[i]),height = y[i],color = "grey",alpha = 0.5)
    axs[0].add_patch(rect)
axs[0].set_ylim(-0.2, 20)

x2 = np.arange(2,9,0.1)
y1 = -1 * (x2 - 2) * (x2 - 8) +10
y2 = 0
axs[1].plot(x,y,color = "red")
axs[1].fill_between(x2, y1, y2, where = y1>y2,facecolor='grey',alpha = 0.5, interpolate= True)
axs[1].set_ylim(-0.2, 20)

plt.show()