python-重点工具(Matplotlib)

本文最后更新于：July 14, 2022 pm

下面这些代码均是在学习的过程中做的笔记和练习

1
2
3
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
1
2
3
4
#   图标窗口1      plt.show()
plt.plot(np.random.rand(10))
plt.show()
#直接生成图表

1.png

1
2
3
4
5
6
7
#  图标窗口2  魔法函数，嵌入图表   ######
%matplotlib inline

x = np.random.randn(1000)
y = np.random.randn(1000)
plt.scatter(x,y)
#直接嵌入图表

2.png
1
2
3
4
5
6
#  图标窗口3  魔法函数,弹出可交互的matplotlib窗口

%matplotlib notebook
s = pd.Series(np.random.randn(100))
s.plot(style = 'k-o',figsize=(10,5))
#可做一定调整

3.png
1
2
3
4
5
6
7
8
9
10
#  图标窗口4  魔法函数,弹出matplotlib控制台

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

#plt.close() 关闭窗口
#plt.gcf().clear()  清空

图表的基本元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 图名 ，图例 ， 轴标签 ， 轴边界 ， 轴刻度 ， 轴刻度标签。。。。。

df = pd.DataFrame(np.random.rand(10,2),columns=['A','B'])
f = plt.figure(figsize=(10,10))
fig = df.plot(figsize=(6,4))

#figsize  设置窗口大小

print(fig,type(fig))
print(f,type(f))


plt.title('aa')   #名字
plt.xlabel('x')
plt.ylabel('y')

plt.xlim([0,12])# x轴边界
plt.ylim([0,1.5])
plt.xticks(range(10))  #x刻度
plt.yticks([0,0.2,0.4,0.6,0.8,1.0,1.2])

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

4.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 其他元素可视性

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()  #设置图网

import matplotlib
frame = plt.gca()

frame.axes.get_xaxis().set_visible(False)  # x轴不见
frame.axes.get_yaxis().set_visible(False)  #y轴不见

5.png

图表的样式参数

1
2
3
4
# linestyle参数

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

6.png

1
2
3
4
5
#  marker参数

s = pd.Series(np.random.rand(10).cumsum())
s.plot(linestyle = '--',
      marker = 'x')   #   * o

7.png
1
2
3
4
5
6
7
8
9
10
11
# color参数

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

df = pd.DataFrame(np.random.rand(30,4),columns = list('ABCD'))
df = df.cumsum()
df.plot(style = '--.',alpha = 0.8,colormap = 'GnBu')
#colormap:  颜色板

8.png
1
2
3
4
#  style 参数，可以包含linestyle,marker , color

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

9.png

此后仅仅展示代码，效果可以自行尝试

1
2
3
4
5
6
7
8
9
#  整体风格样式

import matplotlib.style as ps1
print(plt.style.available)
#查看样式列表

ps1.use('ggplot')
ts = pd.Series(np.random.rand(10).cumsum(),index = pd.date_range('1/1/2021',periods = 10))
ts.plot(style = '--g.',grid = True,figsize=(10,6))

刻度、注释、图表输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#  刻度

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)
plt.plot(t,s,'--*')
plt.grid(True,linestyle = "--",color = "gray",linewidth = "0.5",axis = "both")
#网格
#plt.legend()  图例

xmajorLocator = MultipleLocator(10)   #将x的主标签设置为10的倍数
amajorFormatter = FormatStrFormatter('%.0f')
xminorLocator = MultipleLocator(5)  #将想的次标签设置为5的倍数

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

ax.xaxis.grid(True,which ='both')
1
2
3
4
5
6
# 注释

df = pd.DataFrame(np.random.rand(10,2))
df.plot(style = '--o')
plt.text(5,0.5,'hshhhh',fontsize=10)
#注释  （横坐标，纵坐标，注释字符串）
1
2
3
4
5
6
7
8
9
10
11
#   图表输出

df = pd.DataFrame(np.random.rand(100,4),columns = list('ABCD'))
df = df.cumsum()
df.plot(style = '--.',alpha = 0.5)
plt.legend(loc = 'upper left')
plt.savefig('',
           dpi=400,                  #分辨率
           facecolor = 'g',  
           bbox_inches = 'tight',     #图表需要保存的地方，如果设置成‘tight’，则尝试剪除图标周围的空白部分
           edgecolor = 'b')   #图像的背景图，默认为；w  白色

子图

1
2
3
4
5
6
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--')

# figsize设置图标大小
1
2
3
4
5
6
7
8
9
10
11
12
13
#  子图创建1  - 先建立子图然后填充图表
fig = plt.figure(figsize=(10,6),facecolor = 'g')

ax1 = fig.add_subplot(2,2,1)
plt.plot(np.random.rand(50).cumsum(),'k--')
plt.plot(np.random.rand(50).cumsum(),'b--')

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='.')
1
2
3
4
5
6
7
8
9
10
#  子图创建2 - 创建一个新的figure ， 并返回一个subplot对象的numpy数组 --plt.subplot#######

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

ax1 = axes[0,2]
ax1.plot(ts)
axes[0,0].plot(np.random.rand(100))
1
2
3
4
5
6
7
8
#  plt.subplot  参数调整
fig,axes = plt.subplots(2,2,sharex=True,sharey=True)  #是否共享x，y刻度

for i in range(2):
    for j in range(2):
        axes[i,j].hist(np.random.rand(50),color='k',alpha=0.5)
plt.subplots_adjust(wspace=0,hspace=0)
#控制宽度和高度的百分比
1
2
3
4
5
6
7
8
9
# 创建图表3 - 多系列图，分别绘画

df = pd.DataFrame(np.random.randn(100,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)

基本图表绘制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#  Series  直接生成图表

ts = pd.Series(np.random.rand(20),index = pd.date_range('1/1/2021',periods=20))
ts = ts.cumsum()
ts.plot(kind='kde',      #  line,bar,barth.....(折线图 ， 柱状图 ， 柱状图-横)
       label ='hehe',
       style ='--g.',
       alpha = 0.4,     #透明度  0--1
        use_index = True,
       rot = 45,            #旋转刻度标签
       grid = True,
       #ylim = [-50,50],
       #yticks = list(range(-50,50,10)),
       figsize = (8,4),
       title = 'test',
       legend = True)    #是否显示图例，一般直接用plt.legend(),也可以用    plt.plot()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#  DataFrame直接生成图表

df = pd.DataFrame(np.random.rand(100,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,
       yticks = list(range(-50,50,10)),
       figsize = (12,8),
       title = 'test',
       legend = True,   
       subplots = True,   #####   这个会分开多个图表，而且颜色会越来越浅
       colormap = 'Greens')

柱状图、堆叠图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 柱状图、 堆叠图
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'])
#print(s)
#print(df)

#单系列柱状图
s.plot(kind='bar',ax=axes[0])

#多系列柱状图
df.plot(kind='bar',ax=axes[1])

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

df.plot.barh(ax = axes[3])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 = y1*0.1)

#  width  宽度比例
#xerrr/yerr   :  x/y方向的error

 
for i,j in zip(x,y1):
        plt.text(i+0.09,j-0.4,'%.2f' %j, color = 'white')
for i,j in zip(x,y1):
        plt.text(i+0.1,j+0.5,'%.2f' %-j, color = 'white')
        
#给图添加text（）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 外联图表plt.table()
data = [[5555,23143,44234,3424,44243],
       [5555,23143,44234,3424,44243],
       [5555,23143,44234,3424,44243],
       [5555,23143,44234,3424,44243],
       [5555,23143,44234,3424,44243],]
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

df.plot(kind ='bar',grid = True,colormap='Blues_r',stacked = True,figsize=(8,3))
#创建堆叠图

plt.table(cellText = data,          #表格文本
         cellLoc = 'center',          #cell内的文本对齐位置
         cellColours = None,      
         rowLabels = rows,       #行标签
         rowColours = plt.cm.BuPu(np.linspace(0,0.5,5))[::1],         
         colLabels = columns,                                            #列标签
         colColours = plt.cm.BuPu(np.linspace(0,0.5,5))[::1],
         rowLoc = 'right',     #行标签对齐位置
         loc = 'bottom')      #表格位置

plt.xticks([])

面积图、填图、饼图

1
2
3
4
5
6
7
8
#  面积图
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.rand(10,4),columns=['a','b','c','d'])

df1.plot.area(colormap = 'Greens_r',alpha = 0.5,ax = axes[0])
df1.plot.area(stacked=True,colormap = 'Set2',alpha = 0.5,ax = axes[1])   #stacked是否堆叠，默认是堆叠
#当数据出现NaN时，自动填充0，所以图标签需要清洗掉缺失值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#  填图

fig,axes = plt.subplots(3,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函数

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()
#  添加图例，网格
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#  饼图  plt.pie()
s = pd.Series(3 * np.random.rand(4),index= ['a','b','c','d'],name='series')
plt.axis('equal')  #保证长宽相等
plt.pie(s,
       explode = [0,0,0,0],    #指定每部分的偏移量
       labels = s.index,
        colors = ['r','g','b','c'],
       autopct = '%.2f%%',        #饼图上的数据标签显示方式
        pctdistance = 0.6,      
        labeldistance = 1.1,     #被画饼图标记的直径，默认为1.1    
        shadow = True,          #  阴影
        startangle=10,       #开始角度
        radius = 1.2,      #半径
        frame = False)    #图框
print(s)

直方图

1
2
3
4
5
6
7
8
9
10
11
12
#  直方图+ 密度图
s = pd.Series(np.random.randn(100))
s.hist(bins = 20,         #箱子的宽度
      histtype = 'bar',     #风格 ， bar barstacked  step  stepfilled
      align = 'mid',     
      orientation = 'vertical',    #水平还是垂直('horizontal'   'vertical')
      alpha = 0.5)   # normed = True
#align  对齐方式

s.plot(kind='kde',style='k--')
plt.grid()
#密度图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#  堆叠直方图
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)
#stacked  是否堆叠

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

散点图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#  plt.scatter()  散点图
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 = 'Blues_r',
           c = y,
           alpha = 0.8)
plt.grid()

#  s 散点图的大小
#  c 散点图的颜色
#  vmin ，vmax   亮度设置，标量
#cmap  colormap
1
2
3
4
5
6
7
8
9
10
11
#  pd.scatter_matrix(散点矩阵)


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})  只能其中选一个  确定频率
#   图像在x轴 ，y轴远点附近的留白，该值越大，图像离坐标远点越远

极坐标（雷达图）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 创建极坐标图
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)     #theta: x   theta*3 : y
ax1.plot(s,linestyle = '--',marker='.',lw=2)
ax2.plot(theta,theta*3,linestyle = '--',lw=1)
ax2.plot(s)
plt.grid()
#  创建极坐标图，参数1为角度  ，参数2为value
#  lw  线宽
1
2
3
4
5
6
7
8
9
10
# 参数
ax2.set_theta_direction(-1)   #坐标轴正方向，默认为逆方向
ax2.set_thetagrids(np.arange(0.0,360,90))    #设置极坐标角度网格线显示
ax2.set_rgrids(np.arange(0.2,2,0.4))    #  设置极径网格线显示，其中参数必须为正数

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

ax2.set_rlim(0.2,1.2)   # 显示的极径范围
ax2.set_rmax(2)      #设置显示的极径最大值
ax2.set_rticks(np.arange(0.1,1.5,0.2))   #  设置极径网格线的显示范围
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#  雷达图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)
ax2.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)
# 绘制雷达线
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#  雷达图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*150/np.pi,labels)   #设置网格 标签
plt.ylim(0,10) # polar的极值设置为ylim
1
2
3
4
5
6
7
8
9
10
11
plt.figure(figsize=(8,4))

ax1 = plt.subplot(111,projection='polar')
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))   #设置颜色

箱型图

1、 上四分位数 - - 将序列分为四份，一般使用（n+1）/4
2、 下四分位数 - - 将序列分为四份，一般使用（n+1）/4*3=6.75
3、 内限 - -T形的盒须就是内限，最大值区间Q3+1.5IQR，最小区间是Q1-1.5IQR (IQR = Q3-Q1)
4、 外限 - -T形的盒须就是内限，最大值区间Q3+3IQR，最小区间是Q1-3IQR
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#  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')
# boxs 箱线
#  whiskers:  分位数与error bar横线之间竖线的颜色
#mediians  :  中位数线颜色
#  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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
              patch_artist = True,     # 上下四分位框内是否填充
              meanline = False,showmeans=True,    #是否有均值线及其形状
              showbox = True,     # 是否显示箱线
              showcaps = True,    # 是否显示边缘线
              showfliers = True,   # 是否显示异常值
              notch = False,     #  中间箱体是否有缺口
              return_type = 'dict')    # 返回类型为字典
plt.title('boxplot')
1
2
3
4
5
6
7
8
9
10
11
12
13
#  plt.boxplot()绘制
#  分组汇总

df = pd.DataFrame(np.random.rand(10,2),columns = ['col1','col2'])
df['X'] = pd.Series(['A','A','A','A','A','B','B','B','B','B'])
df['Y'] = pd.Series(['A','B','A','B','A','B','A','B','A','B'])
#print(df.head())
df.boxplot(by = 'X')    #  汇总
df.boxplot(column=['col1','col2'],by = ['X','Y'])


#  column:  按照数据的列分子图
#  by ； 按照列分组做的箱型图

样式表格创建

1
2
3
4
5
6
#  样式
df = pd.DataFrame(np.random.rand(10,4),columns = ['a','b','c','d'])
df
#sty = df.style
#print(sty,type(sty))
sty
1
2
3
4
5
6
7
8
9
#  按元素处理样式：  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) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#  按行/列 处理样式：  style.apply()

def highlight_max(s):
    is_max = s == s.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:  索引
1
2
3
4
#  样式索引、切片

df.style.apply(highlight_max,axis = 1,
              subset = pd.IndexSlice[2:5,['b','d']])

表格显示控制

1
2
3
4
5
# 按照百分数显示

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

df.head().style.format("{:.4%}")
1
2
3
#   显示正负数

df.head().style.format("{:+.2f}")
1
2
3
# 分列显示

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

表格样式调用

1
2
3
4
5
#  定位空值

df = pd.DataFrame(np.random.rand(5,4),columns=list('ABCD'))
df['A'][2] = np.nan
df.style.highlight_null(null_color = 'red')
1
2
3
4
5
6
#  色彩映射

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

df = pd.DataFrame(np.random.rand(10,4),columns=list('ABCD'))
df.style.bar(subset=['A','B'],color='#d65f5f',width=100)
# width 最长长度在格子的占比
1
2
3
4
5
6
#  分段式构建样式
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')