Matplotlib快速应用

最新推荐文章于 2023-12-27 20:26:05 发布

hyfine_

最新推荐文章于 2023-12-27 20:26:05 发布

阅读量364

点赞数 1

分类专栏：人工智障

本文链接：https://blog.csdn.net/f290131665/article/details/80034543

版权

人工智障专栏收录该内容

10 篇文章 1 订阅

订阅专栏

Matplotlib初步应用

环境搭建

采用anaconda，自带各种科学计算的库，省去自己安装，版本适配的麻烦

Numpy

Numpy是一种开源的扩展的数值计算库。

ndarray，numpy的array对象。三种方法获得该对象：
- nd_a = np.array(py_a) # python的数组a通过numpy.array方法转变为ndarray类型的数组
- nd_b = np.arange(10) # arange函数生成ndarray对象
- 读取数据库或文件：nd_c = np.loadtxt(parameters)，注意参数的作用。
索引和切片
- ndarray和array一样，从0元素开始索引
- 用name[start :end :step]方式切片

numpy常用函数

min、max、median、mean（平均值）、var（方差）、sort
函数的调用支持面向过程和面向对象两种方式，np.sort(ndarrayObj)和ndarrayObj.sort()效果一样，这里注意一个区别。
np.sort(ndarray)不会改变ndarray原数组对象，返回一个新的已排序的对象，而ndarray.sort()不会产生新对象，而是将自身排序。
random随机数生成、linspace(start,end,amount)生成等区间的离散列。
random.randn(count)生成count个均值为0方差为1的数组
数据的导入：converters参数的使用。


# 这里将第0列日期数据的str型数据转换成float，且日期数据格式为‘12/01/1995’（1995-12-01）


# 需要导入包

import matplotlib.datas as matdata
date,otherdata = np.loadtxt(..,converters={0:matdata.strpdata2num('%m/%d/%y')},..)

# 显示的时候如果需要这个日期数据，用相应的画图函数

plt.plot_date(date,otherdata)

# 这个函数会识别float形式的日期数据



# 生成数据


#创造一组服从正态分布的定量数据

data = normal(0, 10, size=10)

#创造一组服从均匀分布的定性数据

data = randint(0, 10, size=10)

numpy统计函数：
位置：均值mean(ndarray)、中位数median(ndarray)、众数mode(ndarray)
发散程度：极差ptp(data)、方差var(ndarray)、标准差std(ndarray)
异常（偏差程度，z-分数）：(data[0]-mean(data)) / std(data)，通常绝对值大于3视为异常

相关度（协方差COV、相关系数衡量CORRCOEF）：


#计算两组数的协方差


#参数bias=1表示结果需要除以N，否则只计算了分子部分


#返回结果为矩阵，第i行第j列的数据表示第i组数与第j组数的协方差。对角线为方差

cov(data, bias=1)


#计算两组数的相关系数


#返回结果矩阵，第i行第j列的数据表示第i组数与第j组数的相关系数。对角线为1

corrcoef(data)

包	方法	说明
numpy	array	创造一组数
numpy.random	normal	创造一组服从正态分布的定量数
numpy.random	randint	创造一组服从均匀分布的定性数
numpy	mean	计算均值
numpy	median	计算中位数
scipy.stats	mode	计算众数
numpy	ptp	计算极差
numpy	var	计算方差
numpy	std	计算标准差
numpy	cov	计算协方差
numpy	corrcoef	计算相关系数

练习一：numpy生成100以内随机数组，存储数组到文件，读取文件，数组排序、求最大值、最小值、均值、方差

import  numpy as np
# 产生100个元素的ndarray，[0,1000)之间
nd_a = np.random.randint(0,1000,100)

# 保存为文件，参数看文档
np.savetxt('arraydata.txt',nd_a,delimiter=',',header='my random data',footer='over',fmt='%d')

# 读取文件
nd_b = np.loadtxt('arraydata.txt',dtype=int,delimiter=',',skiprows=1,unpack=False,)

# 对比原数组和读取的数组元素个数是否一致
print('loaded-' + str(nd_b.size) + ',original-'+str(nd_a.__len__()))

# 排序
nd_c = np.sort(nd_b)

# 输出排序后的结果：排序产生的新数组和原数组
print(nd_c)
print(nd_b)

# 输出max
print('max:loaded-'+ str(np.max(nd_b)) + ',original-' + str(nd_a.max()))
# 输出min
print('min:loaded-'+ str(np.min(nd_b)) + ',original-' + str(nd_a.min()))
# 输出mean
print('mean:loaded-'+ str(np.mean(nd_b)) + ',original-' + str(nd_a.mean()))
#输出方差var
print('avriance:loaded-'+ str(np.var(nd_b)) + ',original-' + str(nd_a.var()))

练习二：Iris数据集的简单练习

import  numpy as np
# 这里的路径是因为本py文件和数据文件不在一个目录下
import  os
pro_root = os.path.abspath('..')
sepal_length,sepal_width,petal_length,petal_width = np.loadtxt(pro_root+'\\dataset\\iris.data',
                  delimiter=',',
                  unpack=True,dtype=float,usecols=(0,1,2,3))

# 三种花的统计值，简单的统计
print(sepal_length[:50].mean())
print(sepal_length[:50].var())

print(sepal_length[51:100].mean())
print(sepal_length[51:100].var())

print(sepal_length[101:150].mean())
print(sepal_length[101:150].var())

#---------------------numpy简单学习--------------------------------

# 列表list转矩阵
array = np.array([[1,2,3],[2,3,4]]) # 2*3矩阵

# 查看维度
array.ndim # dimention

# 形状，行列值
array.shape

# 大小，个数
array.size

# 指定array类型
x = np.array(list,dtype=np.xxx) # np.xxx表示np的类型
x.dtype # 查看类型

# 生成指定维度的空array
x = np.zeros((2,3,4)) # 这表明x是三维数组，2行3列，第三个维度size(深度、高度)为4

# 同理生成值都为1的array
x = np.ones((2,3,4))   # 同理，np.empty((shape)) 生成近似zeros的array

# 产生随机的矩阵
x = np.random.random((shape)) # 生成shape样式的矩阵，值随机(0,1)区间内

# 生成有序的序列
x = np.arange(start,end,step)  # 生成1维数据列，类似python的range的效果，默认区间左闭右开
# 注，range返回的是range对象，到list还需要转换

# 将np.array重新构形
x.reshape((new shape)) # 比如 new shape = (2,3,4) 将x装换为3维矩阵
# 注，转换前后的size不能变，如size=10的array不能reshape为(2,3,4)的矩阵

x.reshape((-1,3,4)) # new shape中可以用-1表示自动计算值，根据size自动填写，显然只能指定一个-1值

# 区间均分,类似于分箱
x = np.linspace(start,end,nbins) # 将[start,end]区域分成nbins段，返回一个array，默认包含首尾（闭区间）


# -------------- 基础运算 -------------------------------
# np中的运算会作用于array的每个元素,可以直接调用np的函数，也可以用oob方式调用ndarray的成员方法，且可以指定参数axis，表示对某一维度上进行运算

# 矩阵乘法 np.dot(x,y)
x = np.arange(0,4).reshape((2,2))
y = np.arange(5,9).reshape((-1,2))
r1 = x*y         # 元素对应相乘
r2 = np.dot(x,y) # 矩阵乘法运算
r2 = x.dot(b)    # 同上

# 最大，最小，求和，一下方法可指定参数axis（如，axis=0），表示在这个维度、轴、rank上运算
np.sum(x) # x.sum()
np.min(x) # x.min()
np.max(x) # x.max()

# 最大值最小值的索引,多维矩阵也按一维线性索引返回
index = np.argmin(x)
index = np.ragmax(x)

# 中位数、平均值、累计值
mean = np.mean(x)
median = np.median(x)
cumsum = np.cumsum(x) # 累计和
np.diff(x) # x[j,i+1]-x[j,i]，按行输出

np.sort(x) # 逐行排序

# 矩阵转置
np.transpose(x) 
x.T

# clip可以理解为一种过滤
np.clip(x,a,b) # x矩阵的元素中所有小于a的元素置为a,大于b的置为b,即ab为取值范围

# 多维矩阵的单行形式
x.flat # x.flatten() ，当然也可以reshape到一维数组

# 数据合并
np.vstack((a,b)) # vertical 垂直合并
np.hstack((a,b)) # horizontal 水平合并a、b
np.concatenate((a,b,c,d,...,n),axis=j) # 在j维度上对a到n的array合并

# 分裂矩阵
np.split(x,nbins,axis=n) # 对x做第n维的nbins等份分割，检测nbins必须满足axis=n上等份要求，否则出错，如4列分3份，出错……
np.array_split(x,nbins,axis=n) # 不等份 分割。对nbins无检测

##！ python默认是引用赋值
a = np.array(....)
b = a # 此时a is b == True，同一块内存，修改一个，都改变
b = a.copy() # 重新创建一个值一样的对象给b，此时a、b两个不同内存空间的对象，不再关联，彼此独立

散点图

scatter(xList,yList)函数

外观参数：用以区分不同类型数据。颜色-c，点大小-s，透明度-alpha，点形状-marker

# 查看花的sepal的length和width的关系
import  numpy as np
import  matplotlib.pyplot as plt
import  os
pro_root = os.path.abspath('..')

sepal_length,sepal_width = np.loadtxt(pro_root+'\\dataset\\iris.data',
                  delimiter=',',
                  unpack=True,dtype=float,usecols=(0,1))

plt.scatter(sepal_width[:50],sepal_length[:50],marker='*',c='red',alpha=0.5,s=50)
plt.scatter(sepal_width[51:100],sepal_length[51:100],marker=',',c='green',alpha=0.5,s=50)
plt.scatter(sepal_width[101:150],sepal_length[101:150],marker='.',c='blue',alpha=0.5,s=50)
plt.show()

# 可以看到三种花的sepal的宽和长都是近似正相关的

折线图

plt.plot(xlist,ylist)、plt.plot_date(date,data,linestyle=’.’)(这个函数需要指定linestyle，否则画出的是点，而不是线)

练习一：[0,10]内的正弦图象

# 0,10内正弦图象
import  numpy as np
import  matplotlib.pyplot as plt

# 只分成20份，能看到折线
xlist = np.linspace(0,10,20)
ylist = np.sin(xlist)
plt.plot(xlist,ylist,'b:')

# 分成100份，几乎是光滑曲线
alist = np.linspace(0,10,100)
blist = np.cos(alist)
plt.plot(alist,blist,'r--')

plt.show()

# plot函数的参数需要注意,'r--'这是一种组合的参数，r表示颜色red，--表示线的样式，具体的组合看文档

练习二：iris练习

import  numpy as np
import  matplotlib.pyplot as plt
import  os
pro_root = os.path.abspath('..')
data = np.loadtxt(pro_root+'\\dataset\\iris.data',
                  delimiter=',',
                  unpack=False,dtype=float,usecols=(0,1,2,3))

for x in data[0:50]:
    plt.plot(x,'r--')
for x in data[51:100]:
    plt.plot(x,'g-')
for x in data[100:150]:
    plt.plot(x,'b-.')

# 对图做个加工
# x、y轴标签与图形标题
plt.xlabel('category')
plt.ylabel('value')
plt.title('iris\'s sepal and petal leagth and width')

# X轴上的标签
xticks=['sepal length','sepal width','petal length','petal width']
#设置x轴的刻度，将构建的xticks代入
plt.xticks(range(len(xticks)),xticks,rotation=0)

# 图中可以看出三种类型的折线图
plt.show()

条形图

np.bar(parameters)

练习：iris的两种条形图

"""
累计条形图，stacked bar graph
"""
import numpy as np
import matplotlib.pyplot as plt
from src.utils import utils as tool

sepal_length,sepal_width,petal_length,petal_width = np.loadtxt(tool.getPath()+'/dataset/iris.data',
                  delimiter=',',
                  unpack=True,dtype=float,usecols=(0,1,2,3))

# data
sun_sepal_length = [np.sum(sepal_length[0:50]),np.sum(sepal_length[51:100]),np.sum(sepal_length[101:150])]
sun_sepal_width = [np.sum(sepal_width[0:50]),np.sum(sepal_width[51:100]),np.sum(sepal_width[101:150])]
sun_petal_length = [np.sum(petal_length[0:50]),np.sum(petal_length[51:100]),np.sum(petal_length[101:150])]
sun_petal_width = [np.sum(petal_width[0:50]),np.sum(petal_width[51:100]),np.sum(petal_width[101:150])]


# plot
left = np.arange(3)
width = 0.5
# 这里有大量重复的矩阵计算，需要优化
bar1 = plt.bar(left,sun_sepal_length,width,yerr=sun_sepal_length,align='center',color='red')
bar2 = plt.bar(left,sun_sepal_width,width,yerr=sun_sepal_width,bottom=sun_sepal_length,align='center',color='green')
bar3 = plt.bar(left,sun_petal_length,width,yerr=sun_petal_length,bottom=np.add(sun_sepal_length,sun_sepal_width),align='center',color='blue')
bar4 = plt.bar(left,sun_petal_width,width,yerr=sun_petal_width,bottom=np.add(np.add(sun_sepal_length,sun_sepal_width),sun_petal_length),align='center',color='black')
# 坐标轴美化
plt.ylabel('value')
plt.title('this is title')
plt.xticks(left,('typeA','typeB','typeC'))
# 图例标注
plt.legend((bar1[0], bar2[0],bar3[0],bar4[0]), ('sepal_length', 'sepal_width','petal_length','petal_width'))
plt.show()

"""
并列对比条形图
"""
import numpy as np
import matplotlib.pyplot as plt
from src.utils import utils as tool

sepal_length,sepal_width,petal_length,petal_width = np.loadtxt(tool.getPath()+'/dataset/iris.data',
                  delimiter=',',
                  unpack=True,dtype=float,usecols=(0,1,2,3))

# data
sun_sepal_length = [np.sum(sepal_length[0:50]),np.sum(sepal_length[51:100]),np.sum(sepal_length[101:150])]
sun_sepal_width = [np.sum(sepal_width[0:50]),np.sum(sepal_width[51:100]),np.sum(sepal_width[101:150])]
sun_petal_length = [np.sum(petal_length[0:50]),np.sum(petal_length[51:100]),np.sum(petal_length[101:150])]
sun_petal_width = [np.sum(petal_width[0:50]),np.sum(petal_width[51:100]),np.sum(petal_width[101:150])]

x = np.arange(0,15,5)
width = 0.5

bar1 = plt.bar(x,sun_sepal_length,width,color='red')
bar2 = plt.bar(x+width+0.1,sun_sepal_width,width,color='green')
bar3 = plt.bar(x+width*2+0.2,sun_petal_length,width,color='blue')
bar4 = plt.bar(x+width*3+0.3,sun_petal_width,width,color='black')

plt.xticks(x+width*2,('A','B','C'))
plt.legend((bar1[0],bar2[0],bar3[0],bar4[0]),('sepal_length','sepal_width','petal_length','petal_width'),loc=2)

plt.show()

直方图

类似于条形图，但是通常是展示连续数据。

plt.hist(data,bins,color,normed)，bins表示的直方图的分段数量，normed决定y轴是频率还是计数

# 随机生成数据做直方图
import numpy as np
import matplotlib.pyplot as plt

mean = 20
var = 0.5
data = mean+var*np.random.randn(100000)

# plt.hist(data,bins=50,normed=False,color='red')
# 当直方图的划分很大时，就是密度曲线
plt.hist(data,bins=500,normed=True,color='red')
plt.show()

# 二维的直方图，用颜色表示联合密度
import numpy as np
import matplotlib.pyplot as plt

# xy均值分别为1和5，方差都为1
x = 1+np.random.randn(2000)
y = 5+np.random.randn(2000)

plt.hist2d(x,y,bins=40)
# 图通过颜色深浅表示概率，显然在(x,y)=(1,5)处密度最大，颜色最亮
plt.show()

饼状图

plt.pie(dataArray,labels,autopct=’%d’,explode,shadow)

autopct用于格式化饼块的占比数据显示格式
explode是一个集合，表示每一块饼距离中心的距离，用以强调突出某一个饼块
shadow是boolean型数据指示是否给饼块添加立体阴影

import matplotlib.pyplot as plt

data = (20, 10, 30, 25)
labels = 'SH', 'BJ', 'SZ', 'GZ'
colors = ('red', 'green', 'blue', 'yellow')
explode = (0, 0, 0.2, 0.05)

# 饼图中坐标x、y默认不是1比1的，所以图像会椭圆，需要指定坐标轴1:1以画出正圆
plt.axes(aspect=1)

plt.pie(x=data,labels=labels,colors=colors,explode=explode, autopct='%0.1f%%', shadow=True)
plt.show()

箱形图

plt.boxplot(data,sym,whis)

sym表示异常点的显示样式，可同时指定颜色、样式等
whis，whiskers，表示离群点的范围。箱形图会统计[最小值、四分位值Q1、中间值、四分之三分位值Q3、最大值，平均值，以及离群点]，这里最小值和最大值是排除离群点的，那么怎么确定离群点和最小值最大值之间的区分呢？用whis， $最小值=Q1-(Q3-Q1)*whis$ ， $最大值=Q3+(Q3-Q1)*whis$ ，即异常点的判定取决于箱长(Q3-Q1)和whis。whis默认为1.5

import numpy as np
import matplotlib.pyplot as plt
from src.utils import utils as tool

sepal_length,sepal_width,petal_length,petal_width = np.loadtxt(tool.getPath()+'/dataset/iris.data',
                  delimiter=',',
                  unpack=True,dtype=float,usecols=(0,1,2,3))

# 画三种花的sepal_length的箱形图
x = sepal_length[:50],sepal_length[51:100],sepal_length[101:150]
labels = 'A','B','C'

plt.boxplot(x,labels=labels,whis=1,sym='bx')
plt.show()

# test whis
import matplotlib.pyplot as plt

x = range(1,100,1)
# Q1=25 MID=50 Q3=75 boxLength=50, 如果whiskers=0.4,则上下都会有5个离群点
plt.boxplot(x,whis=0.4,sym='r.')
plt.show()

颜色和样式

调整颜色、线型、点型

字符表示八种内建颜色：red、green、blue、cyan、magenta、yellow、black、white，均可用首字母替代。还可以十六进制表示颜色，如#FF08AB，分别表示三个颜色通道值。还可以RGB元组表示，如（255,255,255）。还有一种灰度表示，color=‘0.5’，表示图像是一个灰色图像，值表示颜色程度。
点，直接在matplotlib的官网文档中找markers。matplotlib默认在显示不同marker时分配不同颜色（认为是不同的需要显示的对象）。
线：‘–‘虚线，’-‘实线，’-.‘点划线，’:‘点线。
样式字符串：可同时在字符串中包含以上三种样式信息，如’rx–’，表示红色，点为x，线为虚线

编程方式

pyplot、pylab和面向对象的方式

pyplot：简单易用，底层定制能力不够。
pylab：结合matplotlib和numpy的模块，模拟了matlab的环境，不推荐用了
面向对象：matplotlib的精髓，更基础和底层的方式。

推荐13两种方式根据实际情况综合使用

子图subplot

matplotlib绘图的三个层级：FigureCanvas 画布，Figure 图，Axes 坐标系。一张图上画多个对比图像，这其实不是多个Figure，而是一个Figure上建立多个Axes，每个Axes表达一个内容。

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(1,10)

fig = plt.figure()

axe1 = fig.add_subplot(221)
axe2 = fig.add_subplot(222)
axe3 = fig.add_subplot(223)
axe4 = fig.add_subplot(224)

axe1.plot(x,[ i**3 for i in x])
axe2.scatter(x,x)
axe3.hist(x,bins=9)
axe4.plot(x,-x)

plt.show()
#--------------另一种方式----------------
fig, axes = plt.subplots(ncol=2,nrow=2)
ax1,ax2,ax3,ax4 = axes.ravel()
# 再用每个ax再每个图轴上画数据

多图

import matplotlib.pyplot as plt

f1 = plt.figure()
ax1 = f1.add_subplot(111)
ax1.plot([1,2],[1,2])

f2 = plt.figure()
ax2 = f2.add_subplot(222)
ax2.plot([1,2],[2,1])

# 一次弹出两个图框
plt.show()

网格

axe.grid()、plt.grid()

图例

画图的时候指定label，然后plt.legend()自动根据label显示图例

图例可以由plt显示，也可以由axe显示。同样label可以在不同的时机创建

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)
f = plt.figure()
ax = f.add_subplot(111)
ax.plot(x,x,label='$ y = x $',color='b')
ax.plot(x,x**2,label='$ y = x^2 $',color='g')
ax.plot(x,x**3,label='$ y = x^3 $',color='r')

ax.grid(linestyle='-.',color='y')

ax.legend()

# 调整坐标轴范围(x1,x2,y1,y2)
plt.axis([0,10,0,500])

坐标轴范围

plt.axis([x1,x2,y1,y2])
plt.xlim()
plt.ylim()

坐标轴刻度

ax = plt.gca() # get current axe,获取当前的坐标轴
ax.locator_params(nbins=10) # nbins表示需要将轴刻度分成几个格子，可以通过'x'/'y'制定某一个坐标轴

日期作为轴刻度

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

# 导入时间模块
import datetime

# 创建两个时间对象
start = datetime.datetime(2015,11,6)
stop = datetime.datetime(2017,11,6)
# 创建时间间隔对象
delta = datetime.timedelta(days=1)
# 创建时间格式化器
date_format = mpl.dates.DateFormatter('%Y-%m-%d')

# 转换成matplotlib的时间序列对象
dates = mpl.dates.drange(start,stop,delta)

# 生成随机数据
y = np.random.randn(len(dates))

ax = plt.gca()
# 画时间折线图，实线，不给marker（不会突出数据点）
ax.plot_date(dates,y,linestyle='-',marker='')
# 将日期格式化对象应用到x轴上
ax.xaxis.set_major_formatter(date_format)

# 调整x轴日期标签自适应显示
plt.gcf().autofmt_xdate()

plt.show()

添加坐标轴

效果：多重y轴，同一个axe中的两个线采用不用的刻度，这个时候需要两条对应的坐标轴，左右并列分别对应两条数据线。

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0,11)

y1 = x**2
y2 = -3*x+3

plt.plot(x,y1,color='r',label='$y1=x^2$')

# 添加一条并列坐标轴
plt.twinx()
plt.plot(x,y2,color='b',label='$y2=-3*x+3$')

# 此时两条线y1 y2就在同一个axe上对应不同的y轴
plt.legend()
plt.show()

#-----------------OOP方式--------------------------
import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0,11)

y1 = x**2
y2 = -3*x+3

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

l1, = ax.plot(x,y1,color='r',label='$y1=x^2$')

ax2 = ax.twinx()
l2, = ax2.plot(x,y2,color='b',label='$y2=-3*x+3$')

# 这里需要了解axe和figure的范围，若gcf()再legend，图例会滑到整个图的四个角，坐标轴外面
# 若gca()表示获取到轴，再legend，图例画在轴范围内
plt.gca().legend((l1,l2),('A','B'),loc=0)
plt.show()

#---------------------
# 同理，twiny可以获得并列的x轴共用一个y轴

注释

key word：annotate

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(-10,11)
y = x**2

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

# xy表示箭头的位置，xytext表示注释文本的坐标
# arrowprops字典类型的关于箭头的属性设置。
# facecolor颜色，frac箭头百分百，arrowstyle是一个内置样式，查看文档具体的props设置
plt.annotate('this is bottom',xy=(0,1),xytext=(-3,20),
             arrowprops={'arrowstyle':'->'})

plt.show()

画文字

plt.text(x,y,words)，words文字内容自动识别Latex形式的字符串

Latex学习链接

注：因为latex中有大量的反斜杠，推荐用r’……..’的形式创建字符串，表示默认不转义反斜杠

区域填充

区域上色

key words: fill() fill_between()

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0,5*np.pi,1000)

y1 = np.sin(x)
y2 = np.cos(x)
'''

plt.fill(x,y1,'b',alpha=0.3)
plt.fill(x,y2,'r',alpha=0.3)

'''
# 交集填充，where表示填充区域的条件表达式
# interpolate表示是否完全填充，因为数据点是离散的，粒度太粗的时候，会有区域填充不到，这个参数会实现完全填充
plt.fill_between(x,y1,y2,where=(y1>y2),facecolor='r',alpha=0.5,interpolate=True)
plt.fill_between(x,y1,y2,where=(y1<y2),facecolor='b',alpha=0.5)

plt.show()

形状

key words: matplotlib.patches add_patch

import matplotlib.pyplot as plt
import matplotlib.patches as mp

# 构建一个圆对象,xy是圆心位置
circle = mp.Circle(xy=(1,2),radius=1,
                   color='blue',alpha=0.5,fill=True,ls='-.')

# 矩形，xy是左下角坐标
rect = mp.Rectangle(xy=(3,3),width=2,height=1,color='g',ls='-',alpha=0.5)

# 多边形
rp = mp.RegularPolygon(xy=(5,5),numVertices=7,radius=1,alpha=0.3,color='r')

# 椭圆
elp = mp.Ellipse(xy=(1,4),width=3,height=1,color='y',alpha=0.3)

ax = plt.gca()
# 该图轴上添加这个图块，传入图块对象
ax.add_patch(circle)
ax.add_patch(rect)
ax.add_patch(rp)
ax.add_patch(elp)

# 设置轴范围
# ax.set_xlim(0,10)
# ax.set_ylim(0,10)

# 设置坐标轴相等，xy比例相同
plt.axis('equal')
plt.show()

美化-样式

使用多种画图样式

key words：plt.style plt.style.use(‘xx’) plt.style.available

极坐标

import matplotlib.pyplot as plt
import numpy as np

r = np.arange(1,6,1)
theta = np.arange(0,2*np.pi+1,np.pi/2)

# projection透射，表示轴的投射方式，这里采用极坐标polar
ax = plt.subplot(111,projection='polar')
ax.plot(theta,r,color='r',linewidth=3)
ax.grid(True)

# 再画一条
r2 = [5,5,5,5,5]
r2 = np.empty(5) # 5个空元素
r2.fill(5) # 元素填充为5

theta2 = [0,np.pi/2,np.pi,np.pi*3/2,0]
ax.plot(theta2,r2,color='g',lw=3)

plt.show()

# --------------------------------
# 当然也可以直接采用plt的方法
# plt.polar()

matplotlib中文显示问题

#coding:utf-8
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
#有中文出现的情况，需要u'内容'

练习项目一：函数积分图

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Polygon

x = np.linspace(0,10)
y = -(x-2)*(x-8)+40

fig = plt.figure()

ax = fig.add_subplot(111)

# matplotlib提供长参数的简写，linewidth简写为lw，同理linestyle=ls
ax.plot(x,y,'r-',lw=2)

# 设置两个积分起止点
a,b = 2,9

# 调整坐标轴
ax.set_xticks([a,b])              # 设置点，找到点
ax.set_xticklabels(['$a$','$b$'])     # 设置tick的标签
ax.set_yticks([])

# 将右边和上边的框去掉
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.set_xlim(xmin=1)
#ax.xaxis.set_ticks_position('bottom')


# 画坐标轴的显示--这里不太理想，这种方式，可能存在改进
fig.text(0.9,0.05,'x')
fig.text(0.1,0.9,'y')

# 画积分区域，patches，多边形polygon，需要一个二维的数组（x,y）序列作为它的边界
ix = np.linspace(a,b)
iy = -(ix-2)*(ix-8)+40
# 这里构造数组的方法用到了zip函数和list函数
verts = [(a, 0)] + list(zip(ix, iy)) + [(b, 0)]
# 构建Polygon类型的patches对象，颜色设置利用[0,1]内的数字表示灰度
poly = Polygon(verts,facecolor='0.9',edgecolor='0.5')

# 画patch
ax.add_patch(poly)

# 画公式
str = r'$\int_a^b(-(x-2)(x+8)+40)dx$'
sx = (a+b)/2
sy = 35
# 对齐方式可用 ha简写代替 horizontalalignment
ax.text(sx,sy,str,fontsize=10,ha='center')

plt.show()

练习项目二：散点图和直方图的联合

import matplotlib.pyplot as plt
import numpy as np

# 使用其他的画图样式
plt.style.use('ggplot')

# 画图数据（正相关的x和y）
x = np.random.randn(200)
y = x + np.random.randn(200)*0.8

# 定义一些距离：margin_border,width,height,margin_gap
# 分别表示， 图边距，散点图宽(正方形),直方图高，散点图和直方图间距
margin_border,width,height,margin_gap=0.1,0.6,0.2,0.02

# 散点图坐标
s_bottom_x=margin_border
s_bottom_y=margin_border
s_height = s_width = width

# 直方图1坐标
h1_bootom_x = margin_border
h1_bootom_y = s_bottom_y+width+margin_gap
h1_height=height
h1_width = width

# 直方图2坐标
h2_bottom_x = margin_border+width+margin_gap
h2_bottom_y = margin_border
h2_height=width
h2_width=height

# 生成相应的轴
rect = [s_bottom_x,s_bottom_y,s_width,s_height]
ax_scatter = plt.axes(rect)

rect = [h1_bootom_x,h1_bootom_y,h1_width,h1_height]
ax_h1 = plt.axes(rect)

rect = [h2_bottom_x,h2_bottom_y,h2_width,h2_height]
ax_h2 = plt.axes(rect)

# 调整坐标轴，删除一些多余的轴刻度
ax_h1.set_xticks([])
ax_h2.set_yticks([])

# 画图
ax_scatter.scatter(x,y,color='r',alpha=0.5)

# 固定直方图的箱体宽度
bin_width = 0.25
# 计算箱数
maxValue = np.max([np.max(np.fabs(x)),np.max(np.fabs(y))])
nbins = int(maxValue/0.25+1)

# 根据数据范围为散点图设置刻度范围
ax_scatter_lim = nbins*bin_width
ax_scatter.set_xlim(-ax_scatter_lim,ax_scatter_lim)
ax_scatter.set_ylim(-ax_scatter_lim,ax_scatter_lim)

# 画直方图
ax_h1.hist(x,bins=nbins,color='g',alpha=0.5)
ax_h1.set_xlim(ax_scatter.get_xlim())
ax_h1.locator_params('y',nbins=8)

ax_h2.hist(y,bins=nbins,orientation='horizontal',color='b',alpha=0.5)
ax_h2.set_ylim(ax_scatter.get_ylim())
ax_h2.locator_params('x',nbins=8)

plt.show()

hyfine_

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Matplotlib快速应用

Matplotlib初步应用环境搭建Numpy散点图折线图条形图直方图饼状图箱形图颜色和样式编程方式子图subplot多图网格图例坐标轴范围坐标轴刻度添加坐标轴注释画文字区域填充形状美化-样式极坐标matplotlib中文显示问题练习项目一：函数积分图练习项目二：散点图和直方图的联合Matplotlib初步应用环...
复制链接

扫一扫

专栏目录