python matplotlib 加一条横线 matplotlib 绘制横线

一、Matplotlib简介及图表窗口

Matplotlib是一个python版的matlab绘图接口，以2D为主，支持python、numpy、pandas基本数据结构，其特点为运营高效且具有丰富的图表库。

1、利用plt.show()来生成图表

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

# 图表窗口1 → plt.show()
plt.plot(np.random.rand(10))
plt.show()
# 直接生成图表

2、魔法函数

# 图表窗口2 → 魔法函数，嵌入图表
% matplotlib inline
x=np.random.randn(1000)
y=np.random.rand(1000)
plt.scatter(x,y)
# plt.show()
# 直接嵌入图表，不用plt.show()
# <matplotlib.collections.PathCollection at ...>代表该图表对象

使用了matplotlib inline之后就不需要再输入plt.show()了

3、可交互窗口

# 图表窗口3 → 魔法函数，弹出可交互的matplotlib窗口

%matplotlib notebook
s=pd.Series(np.random.rand(100))
s.plot(style='k--o',figsize=(10,5))
# 可交互的matplotlib窗口，不用plt。show()
# 可以做一定的调整

左右箭头的意思是可以切换左右的窗口，十字箭头的功能是移动视图，方形按钮是用来放大某一块图片区域的，最后一个功能是保存图片

4、可交互性控制台

# 图表窗口4 → 魔法函数，弹出matplotlib控制台

%matplotlib qt5
df=pd.DataFrame(np.random.rand(50,2),columns=['A','B'])
df.hist(figsize=(12,5),color='g',alpha=0.8)
# 可交互性控制台
# 如果已经设置了显示方式（比如notebook），需要重启然后运行魔法函数
# 网页嵌入的交互性窗口 和 控制台，只能显示一个

# plt.close()
# 每次清空图标内内容

二、图表的基本元素

1、图名，图例，轴标签，轴边界，轴刻度，轴刻度标签等

df=pd.DataFrame(np.random.rand(10,2),columns=['A','B'])
f=plt.figure(figsize=(10,10))
fig=df.plot(figsize=(6,4))
# figsize:创建图表窗口，设置窗口大小
# 创建图标对象，并赋值给fig
print(fig,type(fig))
print(f,type(f))

# title 表名
plt.title('xupeng')

# x轴y轴标签
plt.xlabel('x1')
plt.ylabel('y1')

# 图例的显示方式以及显示位置
plt.legend(loc='upper right')
# 'best':0,(only implemented for axes legends)(自适应方式)
# 'upper right':1
# 'upper left': 2
# 'lower left': 3
# 'lower right': 4
# 'right': 5
# 'center right': 6
# 'lower center': 8
# 'upper center': 9
# 'center': 10

plt.xlim([0,12]) # x轴边界
plt.ylim([0,1.5]) # y轴边界
plt.xticks(range(10)) # 设置x刻度
plt.yticks([0,0.2,0.4,0.6,0.8,1.0,1.2]) # 设置y刻度
fig.set_xticklabels("%.1f"%i for i in range(10)) # x轴刻度标签
fig.set_yticklabels("%.2f"%i for i in [0,0.2,0.4,0.6,0.8,1.0,1.2]) # y轴刻度标签
# 范围只限定图表的长度，刻度则是决定显示的标尺 → 这里x轴的范围是0~12，但刻度只有0~9，刻度标签使得其显示一位小数
# 轴标签则是显示刻度的标签

2、其他元素可视性

x=np.linspace(-np.pi,np.pi,256,endpoint=True)
c,s=np.cos(x),np.sin(x)
plt.plot(x,c)
plt.plot(x,s)
# 通过ndarry创建图表

# 创建格网
# plt.grid()
plt.grid(True,linestyle='--',color='gray',linewidth='0.5',axis='x')
# 显示网格
# linestyle: 线型
# color: 颜色
# linewidth: 宽度
# axis:x,y,both,显示x/y两者的格网

plt.tick_params(bottom='on',top='off',left='on',right='off')
# 刻度显示

import matplotlib
matplotlib.rcParams['xtick.direction']='in'
matplotlib.rcParams['ytick.direction']='inout'
# 设置刻度的方向,in,out,inout，即刻度是在图里面，外面还是中间
# 这里需要导入matplotlib，而不是仅仅导入matplotlib.pyplot

# frame=plt.gca()
# plt.axis('off')
# 关闭坐标这
# frame.axes.get_xaxis().set_visible(False)
# frame.axes.get_yaxis().set_visible(False)
# x/y不可见

三、图表的样式参数

1、linestyle参数

# linestyle参数

plt.plot([i**2 for i in range(100)],
        linestyle='-.')

# '-' solid line style
# '--' dashed line style
# '-.' dash-dot line style
# ':' dotted line style

2、marker参数

# marker 参数
s= pd.Series(np.random.randn(100).cumsum()) # cumsum() 累计求和
s.plot(linestyle='--',
      marker='.')

# '.' point marker
# ',' pixel marker
# 'o' circle marker
# 'v' triangle_down marker
# '^' triangle_up marker
# '<' triangle_left marker
# '>' triangle_right marker
# '1' tri_down marker
# '2' tri_up marker
# '3' tri_left marker
# '4' tri_right marker
# 's'  square marker
# 'p' pentagon marker
# '*' star marker
# 'h' hexagonl marker
# 'H' hexagon2 marker
# '+' plus marker
# 'x' x marker
# 'D' diamond marker
# 'd' thin_diamond marker
# '/' vline marker
# '_' hline marker

3、color参数

# color 参数

plt.hist(np.random.randn(100),
        color='g',alpha=0.8)
# alpha:0-1,透明度
# 常用颜色简写：red-r，green-g，black-b，yellow-y

df=pd.DataFrame(np.random.randn(1000,4),columns=list('ABCD'))
df=df.cumsum()
df.plot(style='--.',alpha=0.8,colormap='GnBu')
# colormap:颜色板，包括很多选项
# 颜色参数自行查找

4、style参数

# style 参数，可以包含linestyle,marker,color

ts=pd.Series(np.random.randn(1000).cumsum(),index=pd.date_range('1/1/2000',periods=1000))
ts.plot(style='--g.',grid=True)

# style → 风格字符串，这里包含了linestyle(-)，marker(.)，color(g)
# plot()内也有grid参数

5、整体风格样式

# 整体风格样式

import matplotlib.style as psl
print(plt.style.available)
# 查看样式列表
psl.use('ggplot')
ts = pd.Series(np.random.randn(1000).cumsum(),index=pd.date_range('1/1/2000',periods=1000))
ts.plot(style='--g.',grid=True,figsize=(10,6))
# 一旦选用样式后，所有图表都会有样式，重启后才能关掉

四、刻度，注解，图表输出

1、刻度

from matplotlib.ticker import MultipleLocator, FormatStrFormatter
t=np.arange(0.0,100.0,1)
s=np.sin(0.1*np.pi*t)*np.exp(-t*0.01)
ax=plt.subplot(111) # 注意：一般都在ax种设置，不在plot中设置
plt.plot(t,s,'--*')
plt.grid(True,linestyle='--',color='gray',linewidth='0.5',axis='both')
# 网格
# plt.legend() # 图例

# 主刻度会显示数字，但是次刻度不会显示数字
xmajorLocator=MultipleLocator(10) # 将x主刻度标签设置为10的倍数
xmajorFormatter=FormatStrFormatter('%.0f') # 设置x轴标签文本的格式
xminorLocator=MultipleLocator(5) # 将x轴次刻度标签设置为5的倍数
ymajorLocator=MultipleLocator(0.5) # 将y主刻度标签设置为0.5的倍数
ymajorFormatter=FormatStrFormatter('%.1f') # 设置y轴标签文本的格式
yminorLocator=MultipleLocator(0.1) # 将此y轴次刻度标签设置为0.1的倍数

ax.xaxis.set_major_locator(xmajorLocator) # 设置x轴主刻度
ax.xaxis.set_major_formatter(xmajorFormatter) # 设置x轴标签文本格式
ax.xaxis.set_minor_locator(xminorLocator) # 设置x轴次刻度

ax.yaxis.set_major_locator(ymajorLocator) # 设置y轴主刻度
ax.yaxis.set_major_formatter(ymajorFormatter) # 设置y轴标签文本格式
ax.yaxis.set_minor_locator(yminorLocator) # 设置y轴次刻度

ax.xaxis.grid(True,which='both') # x坐标轴的网格使用主刻度
ax.yaxis.grid(True,which='minor') # y坐标轴的网格使用次刻度
# which: 格网显示


# 删除坐标轴的刻度显示
# ax.yaxis.set_major_location(plt.NullLocator())
# ax.xaxis.set_major_formatter(plt.NullFormatter())

2、注解

# 注解

df=pd.DataFrame(np.random.randn(10,2))
df.plot(style='--o')
plt.text(5,0.5,'xupeng',fontsize=10)
# 注解 → 横坐标，纵坐标，注解字符串

3、图表输出

# 图标输出

df=pd.DataFrame(np.random.randn(1000,4),columns=list('ABCD'))
df=df.cumsum()
df.plot(style='--',alpha=0.5)
plt.legend(loc='upper left')
plt.savefig('C:/Users/Hjx/Desktop/pic.png',
           dpi=400,
           bbox_inches='tight',
           facecolor='g',
           edgecolor='b')
# 可支持png,pdf,svg,ps,eps……，以后缀名来指定
# dpi是分辨率的意思
# bbox_inches：图表需要保存的部分，如果设置为“tight”，则尝试剪除图表周围的空白部分
# facecolor,edgecolor：图表的背景色，默认为'w'（白色）

五、子图

在matplotlib中，整个图像为一个Figure对象

在Figure对象中可以包含一个或者多个Axes对象

每个Axes(ax)对象都是一个拥有自己坐标系统的绘图区域

plt.figure，plt.subplot

title为图像标题，Axis为坐标轴，Label为坐标轴标注，Tick为刻度线，Tick Lvbel为刻度注释

1、plt.figure() 绘图对象

# plt.figure() 绘图对象
# plt.figure(num=None,figsize=None,dpi=None,facecolor=None,edgecolor=None,
# frameon=True,FigureClass=<class'matplotlib.figure.Figure'>,**kwargs)

fig1=plt.figure(num=1,figsize=(4,2))
plt.plot(np.random.rand(50).cumsum(),'k--')
fig2=plt.figure(num=2,figsize=(4,2))
plt.plot(50-np.random.rand(50).cumsum(),'k--')
# num：图表序号，可以试试不写或者都为同一个数字的情况，看下图表这时会如何显示
# 如果num数字相同，两个图会显示在一起
# figsize：图表大小
# 当我们调用plot时，如果设置plt.figure()，则会自动调用figure()生成一个figure，严格来说，是生成subplots(111)

2、子图创建方式1：先建立子图然后填充图表

# 子图创建1 - 先建立子图然后填充图表
fig=plt.figure(figsize=(10,6),facecolor='gray')
# 先创建一个大图表，然后添加子图
ax1=fig.add_subplot(2,2,1) # 第一行的左图
plt.plot(np.random.rand(50).cumsum(),'k--')
plt.plot(np.random.randn(50).cumsum(),'b--')
# 先创建图表figure，然后生成子图，（2，2，1）代表创建2*2的矩阵表格，然后选择第一个，顺序是从左到右从上到下
# 创建子图后绘制图表，会绘制到最后一个子图

ax2=fig.add_subplot(2,2,2) # 第一行的右图
ax2.hist(np.random.rand(50),alpha=0.5)

ax4=fig.add_subplot(2,2,4) # 第二行的右图
df2=pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d'])
ax4.plot(df2,alpha=0.5,linestyle='--',marker='.')
# 也可以直接在子图后用图表创建函数直接生成

3、子图创建方式2：创建一个新的figure，并返回一个subplot对象的numpy数组

# 子图创建2 - 创建一个新的figure，并返回一个subplot对象的numpy数组 → plt.subplot

fig,axes=plt.subplots(2,3,figsize=(10,4))
ts=pd.Series(np.random.randn(1000).cumsum())
print(axes,axes.shape,type(axes))
# 生成图表对象的数组

ax1=axes[0,1] # 第一行第二列
ax1.plot(ts)
axes[0,0].plot(np.random.rand(100)) # 第一行第一列

4、子图创建方式3：分别绘制多系列图

# 子图创建3 - 多系列图，分别绘制

df=pd.DataFrame(np.random.randn(1000,4),index=ts.index,columns=list('ABCD'))
df=df.cumsum()
df.plot(style='--.',alpha=0.4,grid=True,figsize=(8,8),
       subplots=True,
       layout=(2,3),
       sharex=False)
plt.subplots_adjust(wspace=0,hspace=0.2)
# plt.plot()基本图表绘制函数 → subplots, 是否分别绘制系列（子图）
# layout：绘制子图矩阵，按顺序填充

5、参数调整：plt.subplots

# plt.subplots，参数调整

fig,axes=plt.subplots(2,2,sharex=True,sharey=True)
# sharex,sharey:是否共享x，y刻度

for i in range(2):
    for j in range(2):
        axes[i,j].hist(np.random.randn(500),color='k',alpha=0.5)
plt.subplots_adjust(wspace=0,hspace=0)
# wspace,hspace：用于控制宽度和高度的百分比，比如subplot之间的间距

六、基本图表绘制

1、Series直接生成图表

# Series 直接生成图表
ts=pd.Series(np.random.randn(1000),index=pd.date_range('1/1/2000',periods=1000))
ts=ts.cumsum()
ts.plot(kind='line', # kind是设置图表种类，line为折线图，kde是密度图，bar是柱状图
       label='xupeng',
       style='--g.',
       alpha=0.4,
       use_index=True, # 是否以index作为坐标轴
       rot=45,  # 横坐标旋转的角度
       grid=True, # 添加网格
       ylim=[-50,50],
       yticks=list(range(-50,50,10)),
       figsize=(8,4),
       title='test',
       legend=True)

# plt.grid(True,linestyle='--',color='gray',linewidth='0.5',axis='x') # 网格
plt.legend()
# Series.plot():series的index为横坐标，value为纵坐标
# kind → line,bar,barh……（折线图，柱状图，柱状图-横……）
# label → 图例标签，DataFrame格式以列名为label
# style → 风格字符串，这里包括了linestyle(-)，marker（.），color（g）
# color → 颜色，有color指定时，以color颜色为准
# alpha → 透明度：0-1
# use_index → 将索引用为刻度标签，默认为True
# rot → 旋转刻度标签，0-360
# grid → 显示网格，一般直接用plt.grid
# xlim.ylim → x，y轴界限
# xticks，yticks → x，y轴刻度值
# figsize → 图像大小
# title → 图名
# legend → 是否显示图例，一般直接用plt.legend()
# 也可以用plt.plot()

2、DataFrame直接生成图表

# DataFrame直接生成图表

df=pd.DataFrame(np.random.randn(1000,4),index=ts.index,columns=list('ABCD'))
df=df.cumsum()
df.plot(kind='line',
       style='--.',
       alpha=0.4,
       use_index=True,
       rot=45,
       grid=True,
       figsize=(8,4),
       title='test',
       legend=True,
       subplots=False,
       colormap='Greens') # 选择色系
# subplots → 是否将各个列绘制到不同图表，默认为False
# 也可以用 plt.plot(df)

七、柱状图、堆叠图

有两种方法可以生成柱状图/堆叠图，第一种方式是plt.plot(kind='bar/barh')，第二种方式是plt.bar()。

1、柱状图与堆叠图的一般生成方法

# 柱状图与堆叠图
fig,axes=plt.subplots(4,1,figsize=(10,10))
s=pd.Series(np.random.randint(0,10,16),index=list('abcdefghijklmnop'))
df=pd.DataFrame(np.random.rand(10,3),columns=['a','b','c'])

s.plot(kind='bar',color='k',grid=True,alpha=0.5,ax=axes[0])# ax参数→选择第几个子图
# 单系列柱状图方法一：plt.plot(kind='bar/barh')

df=pd.DataFrame(np.random.rand(10,3),columns=['a','b','c'])
df.plot(kind='bar',ax=axes[1],grid=True,colormap='Reds_r')
# 多系列柱状图

df.plot(kind='bar',ax=axes[2],grid=True,colormap='Blues_r',stacked=True)
# 多系列堆叠图
# stacked → 堆叠

df.plot.barh(ax=axes[3],grid=True,stacked=True,colormap='BuGn_r')
# 新版本 plt.plot.<kind>

2、柱状图的第二种生成方法：plt.bar()

# 柱状图 plt.bar()

plt.figure(figsize=(10,4))
x=np.arange(10)
y1=np.random.rand(10)
y2=np.random.rand(10)

plt.bar(x,y1,width=1,facecolor='yellowgreen',edgecolor='white',yerr=y1*0.1)
plt.bar(x,y2,width=1,facecolor='lightskyblue',edgecolor='white',yerr=y2*0.1)

# x,y参数：x，y值
# width：宽度比例
# facecolor柱状图里填充的颜色、edgecolor是边框的颜色
# left-每个柱x轴左边界，bottom-每个柱y轴下边界 → bottom扩展即可化为甘特图 Gantt Chart
# align：决定整个bar图分布，默认left表示默认从左边界开始绘制，center会将图绘制在中间位置
# xerr/yerr：x/y方向error bar，即误差线

for i,j in zip(x,y1): # zip可以将i，j变成数组
    plt.text(i+0.3,j-0.15,'%.2f'%j,color='white') # i,j可以用来控制注释的位置
for i,j in zip(x,y2):
    plt.text(i+0.3,j+0.05,'%.2f'%-j,color='white')
# 给图添加text
# zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回这些元组组成的列表

3、外嵌图表plt.table()

# 外嵌图表plt.table()
# 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)

data=[[66386,174296,75131,577908,32015],
     [58230,381139,78045,99308,160454],
     [89135,80552,152558,497981,603535],
     [78415,81858,150656,193263,69638],
     [139361,331509,343164,781380,52269]]
columns=('Freeze','Wind','Flood','Quake','Hail')
rows=['%d year'%x for x in (100,50,20,10,5)]
df=pd.DataFrame(data,columns=('Freeze','Wind','Flood','Quake','hail'),
               index=['%d year'%x for x in (100,50,20,10,5)])
df.plot(kind='bar',grid=True,colormap='Blues_r',stacked=True,figsize=(8,3))
# 创建堆叠图

plt.table(cellText=data,
         cellLoc='center',
         cellColours=None,
         rowLabels=rows,
         rowColours=plt.cm.BuPu(np.linspace(0,0.5,5))[::-1], # BuPu可以替换成其他的colormap
         colLabels=columns,
         colColours=plt.cm.Reds(np.linspace(0,0.5,5))[::-1],
         rowLoc='right',
         loc='bottom')
# cellText:表格文本
# cellLoc:cell内文本对齐位置
# rowLabels:行标签
# colLabels:列标签
# rowLoc:行标签对齐位置
# loc:表格位置 → left，right，top，bottom

plt.xticks([])

八、面积图，饼图和填图

1、面积图

# 面积图

fig,axes=plt.subplots(2,1,figsize=(8,6))
df1=pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d'])
df2=pd.DataFrame(np.random.randn(10,4),columns=['a','b','c','d'])

df1.plot.area(colormap='Greens_r',alpha=0.5,ax=axes[0])
df2.plot.area(stacked=False,colormap='Set2',alpha=0.5,ax=axes[1])
# 使用Series.plot.area()和DataFrame.plot.area()创建面积图
# stacked:是否堆叠，默认情况下，区域图被堆叠
# 为了产生堆积面积图，每列必须是正值或全部负值
# 当数据有NaN的时候，自动填充0，所以图标签需要清洗掉缺失值

2、填图

# 填图

fig,axes=plt.subplots(2,1,figsize=(8,6))

x=np.linspace(0,1,500)
y1=np.sin(4*np.pi*x)*np.exp(-5*x)
y2=-np.sin(4*np.pi*x)*np.exp(-5*x)
axes[0].fill(x,y1,'r',alpha=0.5,label='y1')
axes[0].fill(x,y2,'g',alpha=0.5,label='y2')
# 对函数与坐标轴之间的区域进行填充，使用fill函数
# 也可以携程：plt.fill(x,y1,'r',x,y2,'g',alpha=0.5)

x=np.linspace(0,5*np.pi,1000)
y1=np.sin(x)
y2=np.sin(2*x)
axes[1].fill_between(x,y1,y2,color='b',alpha=0.5,label='area')
# 填充两个函数之间的区域，使用fill_between函数

for i in range(2):
    axes[i].legend()
    axes[i].grid()
# 添加图例、格网

3、饼图

# 饼图 plt.pie()
# plt.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,hold=None,data=None)

s=pd.Series(3*np.random.rand(4),index=['a','b','c','d'],name='series')
plt.axis('equal') # 保证长宽相等
plt.pie(s,
       explode=[0.1,0,0,0],
       labels=s.index,
       colors=['r','g','b','c'],
       autopct='%.2f%%',
       pctdistance=0.6,
       labeldistance=1.2,
       shadow=True,
       startangle=0,
       radius=1.5,
       frame=False)
print(s)
# 第一个参数:数据
# explode: 指定每部分的偏移量
# labels: 标签
# colors: 颜色
# autopct: 饼图上的数据标签显示方式
# pctdistance: 每个饼切片的中心和通过autopct生成的文本开始之间的比例
# labeldistance: 被画饼标记的直径，默认值为1.1
# shadow: 阴影
# startangle: 开始角度
# radius: 半径
# frame: 图框
# counterclock: 指定指针方向，顺时针或者逆时针

九、直方图

1、直方图+密度图

# 直方图+密度图

s=pd.Series(np.random.randn(1000))
s.hist(bins=20,
      histtype='bar',
      align='mid',
      orientation='vertical',
      alpha=0.5,
      normed=True)
# bin: 箱子的宽度
# normed 标准化
# histtype 风格: bar, barstacked,step,stepfilled
# orientation水平还是垂直('horizontal','vertical')
# align:('left','mid','right'),optional(对齐方式)

s.plot(kind='kde',style='k--')
# 密度图

2、堆叠直方图

# 堆叠直方图

plt.figure(num=1)
df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),
                'c':np.random.randn(1000)-1,'d':np.random.randn(1000)-2},
               columns=['a','b','c','d'])
df.plot.hist(stacked=True,
            bins=20,
            colormap='Greens_r',
            alpha=0.5,
            grid=True)
# 使用DataFrame.plot.hist()和Series.plot.hist(）方法绘制
# stacked:是否堆叠

df.hist(bins=50)
# 生成多个直方图

十、散点图，矩阵散点图

1、散点图

# plt.scatter() 散点图
# plt.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,hold=None,data=None,**kwargs)

plt.figure(figsize=(8,6))
x=np.random.randn(1000)
y=np.random.randn(1000)
plt.scatter(x,y,marker='.',
           s=np.random.randn(1000)*100,
           cmap='Reds',
           c=y,
           alpha=0.8,)
plt.grid()

# s:散点的大小
# c:散点的颜色
# vmin,vmax: 亮度设置，标量
# cmap: colormap

2、散点矩阵

# pd.scatter_matrix()散点矩阵
# pd.scatter_matrix(frame,alpha=0.5,figsize=None,ax=None,
# grid=False,diagonal='hist',marker='.',density_kwds=None,hist_kwds=None,range_padding=0.05,**kwds)

df=pd.DataFrame(np.random.randn(100,4),columns=['a','b','c','d'])
pd.scatter_matrix(df,figsize=(10,6),
                 marker='o',
                 diagonal='kde',
                 alpha=0.5,
                 range_padding=0.1)
#diagonal:({'hist','kde'})，必须且只能在{'hist','kde'}中选择1个 → 每个指标的频率图
# range_padding: (float,可选)，图像在x轴，y轴原点附近的留白(padding)，该值越大，留白距离越大，图像越远离坐标原点

十一、极坐标图

调用subplot()创建子图时通过设置projection='polar'，便可以创建一个极坐标子图，然后通过调用plot()在极坐标子图中绘制图表。

1、创建极坐标轴

# 创建极坐标轴

s=pd.Series(np.arange(20))
theta=np.arange(0,2*np.pi,0.02)
print(s.head())
print(theta[:10])
# 创建数据

fig=plt.figure(figsize=(8,4))
ax1=plt.subplot(121,projection='polar')
ax2=plt.subplot(122)
# 创建极坐标子图
# 还可以写： ax=fig.add_subplot(111,polar=True)

ax1.plot(theta,theta*3,linestyle='--',lw=1)
ax1.plot(s,linestyle='--',marker='.',lw=2)
ax2.plot(theta,theta*3,linestyle='--',lw=1)
ax2.plot(s)
plt.grid()
# 创建极坐标图，参数1为角度（弧度制），参数2为value
# lw → 线宽

2、极坐标轴的参数设置

# 极坐标参数设置

theta=np.arange(0,2*np.pi,0.02)
plt.figure(figsize=(8,4))
ax1=plt.subplot(121,projection='polar')
ax2=plt.subplot(122,projection='polar')
ax1.plot(theta,theta/6,'--',lw=2)
ax2.plot(theta,theta/6,'--',lw=2)
# 创建极坐标子图ax

ax2.set_theta_direction(-1)
# set_theta_direction():坐标轴正方向，默认逆时针
ax2.set_thetagrids(np.arange(0.0,360.0,90),['a','b','c','d'])
ax2.set_rgrids(np.arange(0.2,2,0.4))
# set_thetagrids():设置极坐标角度网格线显示及标签 → 网格和标签数量一致
# set_rgrids():设置极径网格线显示，其中参数必须是正数

ax2.set_theta_offset(np.pi/2)
# set_theta_offset():设置角度偏移，逆时针，弧度制

ax2.set_rlim(0.2,1.2)
ax2.set_rmax(2)
ax2.set_rticks(np.arange(0.1,1.5,0.2))
# set_rlim(): 设置显示的极径范围
# set_rmax(): 设置显示的极径最大值
# set_rticks(): 设置极径网格线的显示范围

3、雷达图1——极坐标的折线图/填图，plt.plot()

# 雷达图1——极坐标的折线图/填图，plt.plot()

plt.figure(figsize=(8,4))

ax1=plt.subplot(111,projection='polar')
ax1.set_title('radar mapn') # 创建标题
ax1.set_rlim(0,12)

data1=np.random.randint(1,10,10)
data2=np.random.randint(1,10,10)
data3=np.random.randint(1,10,10)
theta=np.arange(0,2*np.pi,2*np.pi/10)
# 创建数据

ax1.plot(theta,data1,'.--',label='data1')
ax1.fill(theta,data1,alpha=0.2)
ax1.plot(theta,data2,'.--',label='data2')
ax1.fill(theta,data2,alpha=0.2)
ax1.plot(theta,data3,'.--',label='data3')
ax1.fill(theta,data3,alpha=0.2)
# 绘制雷达线

4、雷达图2——极坐标的折线图/填图，plt.polar()

# 雷达图2——极坐标的折线图/填图，plt.polar()
# 首尾闭合

labels=np.array(['a','b','c','d','e','f']) # 标签
dataLenth=6 # 数据长度
data1=np.random.randint(0,10,6)
data2=np.random.randint(0,10,6) # 数据

angles=np.linspace(0,2*np.pi,dataLenth,endpoint=False) # 分割圆周长
data1=np.concatenate((data1,[data1[0]]))# 闭合
data2=np.concatenate((data2,[data2[0]]))# 闭合
angles=np.concatenate((angles,[angles[0]]))# 闭合

plt.polar(angles,data1,'o-',linewidth=1)# 做极坐标系
plt.fill(angles,data1,alpha=0.25)# 填充
plt.polar(angles,data2,'o-',linewidth=1)# 做极坐标系
plt.fill(angles,data2,alpha=0.25)# 填充

plt.thetagrids(angles*180/np.pi,labels)# 设置网格、标签
plt.ylim(0,10)# polar的极值设置为ylim

5、极轴图——极坐标的柱状图

极轴图——极坐标的柱状图
plt.figure(figsize=(8,4))
ax1=plt.subplot(111,projection='polar')
ax1.set_title('radar mapn') # 创建标题
ax1.set_rlim(0,12)

data=np.random.randint(1,10,10)
theta=np.arange(0,2*np.pi,2*np.pi/10)
# 创建数据

bar=ax1.bar(theta,data,alpha=0.5)
for r,bar in zip(data,bar):
    bar.set_facecolor(plt.cm.jet(r/10.))# 设置颜色
plt.thetagrids(np.arange(0.0,360.0,90),[])# 设置网格、标签（这里是空标签，则不显示内容）

十二、箱型图

箱型图又被称为盒须图、盒式图、盒状图或者箱线图，是一种用作显示一组数据分散情况资料的统计图，其中包含如下数据：最大值、最小值、中位数、上四分位数（Q1）、下四分位数（Q3）、异常值。

• 中位数 → 一组数据平均分成两份，处于中间的数
• 上四分位数Q1 → 是将序列平均分成四份，计算(n+1)/4与(n-1)/4两种，一般使用(n+1)/4
• 下四分位数Q3 → 是将序列平均分成四份，计算(1+n)/4*3=6.75
• 内限 → T形的盒须就是内限，最大值区间Q3+1.5IQR，最小值区间Q1-1.5IQR，其中IQR=Q3-Q1
• 外限 → T形的盒须就是外限，最大值区间Q3+3IQR，最小值区间Q1-3IQR，其中IQR=Q3-Q1
• 异常值 → 内限之外——中度异常，外限之外——极度异常

plt.plot.box()，plt.boxplot()

1、plt.plot.box()绘制

# plt.plot.box()绘制

fig,axes=plt.subplots(2,1,figsize=(10,6))
df=pd.DataFrame(np.random.rand(10,5),columns=['A','B','C','D','E'])
color=dict(boxes='DarkGreen',whiskers='DarkOrange',medians='DarkBlue',caps='Gray')
# 箱型图着色
# boxes → 箱线
# whiskers → 分位数与error bar横线之间竖线的颜色
# medians → 中位数线颜色
# caps → error bar横线颜色

df.plot.box(ylim=[0,1.2],
           grid=True,
           color=color,
           ax=axes[0])
# color 样式填充

df.plot.box(vert=False,
           positions=[1,4,5,6,8],
           ax=axes[1],
           grid=True,
           color=color)
# vert:是否垂直，默认True
# position: 箱型图占位

2、plt.boxplot()绘制

df=pd.DataFrame(np.random.rand(10,5),columns=['A','B','C','D','E'])
plt.figure(figsize=(10,4))
# 创建图表，数据
f=df.boxplot(sym='o', # 异常点形状，参考marker
             vert=True, # 是否垂直
             whis=1.5, # IQR，默认1.5，也可以设置区间比如[5,95]，代表强制上下边缘为95%和5%的位置
             patch_artist=True, # 上下四分位框内是否填充，True为填充
             meanline=False,showmeans=True, # 是否有均值线以及形状
             showbox=True, # 是否显示箱线
             showcaps=True, # 是否显示边缘线
             showfliers=True, # 是否显示异常值
             notch=False, # 中间箱体是否缺口
             return_type='dict' # 返回类型为字典
            )
plt.title('boxplot')
print(f)

for box in f['boxes']:
    box.set(color='b',linewidth=1) # 箱体边框颜色
    box.set(facecolor='b',alpha=0.5)  # 箱体内部填充颜色
for whisker in f['whiskers']:
    whisker.set(color='k',linewidth=0.5,linestyle='-')
for cap in f['caps']:
    cap.set(color='gray',linewidth=2)
for median in f['medians']:
    median.set(color='DarkBlue',linewidth=2)
for flier in f['fliers']:
    flier.set(marker='o',color='y',alpha=0.5)
# boxes: 箱线
# median: 中位值的横线
# whiskers: 从box到error bar之间的竖线
# fliers: 异常值
# caps: error bar横线
# means: 均值的横线

3、分组汇总

# plt.boxplot()绘制
# 分组汇总

df=pd.DataFrame(np.random.rand(10,2),columns=['Col1','Col2'])
df['X']=pd.Series(['A','A','A','B','B','B'])
df['Y']=pd.Series(['A','A','B','A','B','A'])
print(df.head())
df.boxplot(by='X')
df.boxplot(column=['Col1','Col2'],by=['X','Y'])
# columns: 按照数据的列分子图
# by: 按照列分组做箱型图

十三、表格样式创建

表格视觉样式：DataFrame.style → 返回pandas.Style对象的属性，具有格式化和显示DataFrame的有用方法。

样式创建：

• Styler.applymap:elementwise → 按元素方式处理DataFrame
• Styler.apply:column-/row-/table-wise → 按行/列处理DataFrame

1、样式

# 样式

df=pd.DataFrame(np.random.randn(10,4),columns=['a','b','c','d'])
sty=df.style
print(sty,type(sty))
# 查看样式类型

sty
# 显示样式

2、按元素处理样式：style.applymap()

# 按元素处理样式：style.applymap()

def color_neg_red(val):
    if val<0:
        color='red'
    else:
        color='black'
    return('color:%s'%color)
df.style.applymap(color_neg_red)
# 创建样式方法：使得小于0的数变成红色
# style.applymap() → 自动调用其中的函数

3、按行/列处理样式：style.apply()

# 按行/列处理样式：style.apply()

def highlight_max(s):
    is_max= s ==s.max()
    # print(is_max)
    lst=[]
    for v in is_max:
        if v:
            lst.append('background-color:yellow')
        else:
            lst.append('')
        return(lst)
df.style.apply(highlight_max,axis=0,subset=['b','c'])
# 创建样式方法，每列最大值填充黄色
# axis:0 为列，1为行，默认为0
# subset:索引

4、样式索引，切片

# 样式索引，切片
df.style.apply(highlight_max,axis=1,
              subset=pd.IndexSlice[2:5,['b','d']])
# 通过pd.IndexSlice[]调用切片
# 也可以用：df[2:5].style.apply(highlight_max,subset=['b','d']) → 先索引行再做样式

十四、表格显示控制

1、按照百分数显示

# 按照百分数显示

df=pd.DataFrame(np.random.randn(10,4),columns=['a','b','c','d'])
# print(df.head())
df.head().style.format("{:.2%}")

2、显示小数点数

# 显示小数点数

df.head().style.format("{:.4f}")

3、显示正负数

# 显示正负数

df.head().style.format("{:+.2f}")

4、分列显示

# 分列显示

df.head().style.format({'b':"{:.2%}",'c':"{:+.3f}",'d':"{:.3f}"})

十五、表格样式调用

本小节主要涉及Styler内置样式的调用。

1、定位空值

# 定位空值

df=pd.DataFrame(np.random.rand(5,4),columns=list('ABCD'))
df['A'][2]=np.nan
df.style.highlight_null(null_color='red')

2、色彩映射

# 色彩映射

df=pd.DataFrame(np.random.rand(10,4),columns=list('ABCD'))
df.style.background_gradient(cmap='Greens',axis=1,low=0,high=1)
# cmap: 颜色
# axis: 映射参考，0为行，1为列

3、条形图

# 条形图

df=pd.DataFrame(np.random.rand(10,4),columns=list('ABCD'))
df.style.bar(subset=['A','B'],color='#d65f5f',width=100)
# width: 最长长度在格子的占比

4、分段式构建样式

# 分段式构建样式

df=pd.DataFrame(np.random.rand(10,4),columns=list('ABCD'))
df['A'][[3,2]]=np.nan
df.style.
   bar(subset=['A','B'],color='#d65f5f',width=100).
   highlight_null(null_color='yellow')