python 条形图填充疏密_Python数据分析 4：图表绘制工具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 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.subplottitle为图像标题，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=,**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.

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=['%dyear'%x for x in (100,50,20,10,5)]

df=pd.DataFrame(data,columns=('Freeze','Wind','Flood','Quake','hail'),

index=['%dyear'%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 map\n') # 创建标题

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 map\n') # 创建标题

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