Excel中，顏色是通過界面展示及按鈕選擇確定的，在python代碼環境下，自然是沒有這種條件的，那么，matplotlib中顏色是如何構建與使用的呢？
matplotlib提供了強大的顏色介面，供使用者定制顏色、使用顏色、使用色板，主要包括以下幾個部分：
1、 matplotlib.colors 介面中定義的顏色空間，每一個顏色通過字典的形式進行保存，字典名為顏色名稱，字典值為顏色對應的RGB元組或十六進制字串，例如顏色名稱可以為 darkred，字典值為 #8B0000，凡是顏色命名空間中定義了的顏色，均可以通過顏色名字直接參考，
2、 命名空間解決了顏色怎么稱呼的問題，但并沒有建立好顏色與資料的映射關系，使用者往往希望序列（或資料）按照指定的顏色規則自動賦值，比如，我們希望較小的值被賦值為藍色，中間大小的值被賦值為白色，較大的值被賦值為黑色，但我們不可能為每一個數值一一指定顏色（1000個不唯一資料指定1000種顏色的難度可想而知），為此，開發者提出了色板colormap，通過plt.cm介面實作，主要通過兩種原理：一種是指定有限的N種顏色，回圈使用；另一種是將顏色映射到一個線性空間，將最大和最小的數值與顏色空間的兩端做對應，中間的資料采取差值的方法計算與之相對應的顏色，
本文將對上述部分做詳細介紹，

本文所用到的庫包括

%matplotlib inline
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib as mpl

顏色命名空間

mpl.colors模塊下可以看到，matplotlib定制了5個大的顏色空間，有matplotlib默認采用的BASE_COLORS，包含了可視化軟體TableAu顏色命名空間的TABLEAU_COLORS等，各個顏色空間，命名的顏色個數如下，

mpl.colors

print(
    'mpl.colors.BASE_COLORS nums:', len(mpl.colors.BASE_COLORS), '\n',
    'mpl.colors.TABLEAU_COLORS nums:', len(mpl.colors.TABLEAU_COLORS), '\n',
    'mpl.colors.cnames nums:', len(mpl.colors.cnames), '\n',
    'mpl.colors.CSS4_COLORS nums:', len(mpl.colors.CSS4_COLORS), '\n',
    'mpl.colors.XKCD_COLORS nums:', len(mpl.colors.XKCD_COLORS))

sns.color_palette可以對包含N個顏色的串列進行可視化，以下對主要命名空間的顏色字典和顏色進行了展示和可視化，

mpl.colors.BASE_COLORS

colors = mpl.colors.BASE_COLORS
print(colors)

pal = [color for name, color in colors.items()]
pal = sns.color_palette(palette=pal)
sns.palplot(pal)

輸出

{'b': (0, 0, 1), 'g': (0, 0.5, 0), 'r': (1, 0, 0), 'c': (0, 0.75, 0.75), 'm': (0.75, 0, 0.75), 'y': (0.75, 0.75, 0), 'k': (0, 0, 0), 'w': (1, 1, 1)}

mpl.colors.TABLEAU_COLORS

colors = mpl.colors.TABLEAU_COLORS
print(colors)

pal = [color for name, color in colors.items()]
pal = sns.color_palette(palette=pal)
sns.palplot(pal)

輸出

OrderedDict([('tab:blue', '#1f77b4'), ('tab:orange', '#ff7f0e'), ('tab:green', '#2ca02c'), ('tab:red', '#d62728'), ('tab:purple', '#9467bd'), ('tab:brown', '#8c564b'), ('tab:pink', '#e377c2'), ('tab:gray', '#7f7f7f'), ('tab:olive', '#bcbd22'), ('tab:cyan', '#17becf')])

mpl.colors.cnames

colors = mpl.colors.cnames
print(list(colors.items())[:10])

pal = [color for name, color in colors.items()][:20]
pal = sns.color_palette(palette=pal)
sns.palplot(pal)

輸出

[('aliceblue', '#F0F8FF'), ('antiquewhite', '#FAEBD7'), ('aqua', '#00FFFF'), ('aquamarine', '#7FFFD4'), ('azure', '#F0FFFF'), ('beige', '#F5F5DC'), ('bisque', '#FFE4C4'), ('black', '#000000'), ('blanchedalmond', '#FFEBCD'), ('blue', '#0000FF')]

mpl.colors.CSS4_COLORS

colors = mpl.colors.CSS4_COLORS
print(list(colors.items())[:10])

pal = [color for name, color in colors.items()][:20]
pal = sns.color_palette(palette=pal)
sns.palplot(pal)

輸出

[('aliceblue', '#F0F8FF'), ('antiquewhite', '#FAEBD7'), ('aqua', '#00FFFF'), ('aquamarine', '#7FFFD4'), ('azure', '#F0FFFF'), ('beige', '#F5F5DC'), ('bisque', '#FFE4C4'), ('black', '#000000'), ('blanchedalmond', '#FFEBCD'), ('blue', '#0000FF')]

mpl.colors.XKCD_COLORS

colors = mpl.colors.XKCD_COLORS
print(list(colors.items())[:10])

pal = [color for name, color in colors.items()][:20]
pal = sns.color_palette(palette=pal)
sns.palplot(pal)

輸出

[('xkcd:cloudy blue', '#acc2d9'), ('xkcd:dark pastel green', '#56ae57'), ('xkcd:dust', '#b2996e'), ('xkcd:electric lime', '#a8ff04'), ('xkcd:fresh green', '#69d84f'), ('xkcd:light eggplant', '#894585'), ('xkcd:nasty green', '#70b23f'), ('xkcd:really light blue', '#d4ffff'), ('xkcd:tea', '#65ab7c'), ('xkcd:warm purple', '#952e8f')]

從以上案例可以看到，一些命名空間的顏色是通過十六進制字串形式表示的，另一些是通過0-1的長度為3的元組形式表示的，這兩種有什么區別呢？
本例展示了他們的數學原理，你會看到他們的本質并沒有什么不同，

RGB元組與十六進制字符

def color16_to_rgb(color16):
    # 分別獲得FF，63，47三個十六進制數字
    R16, G16, B16 = color16[1:3], color16[3:5], color16[5:7]
    # 將十六進制轉成十進制
    R10, G10, B10 = int(R16, 16), int(G16, 16), int(B16, 16)  
    # 將十進制轉成歸一化
    R, G, B = R10/255.0, G10/255.0, B10/255.0  
    return (R, G, B), (R10, G10, B10)

color16_to_rgb('#FF6347')

輸出

((1.0, 0.38823529411764707, 0.2784313725490196), (255, 99, 71))

函式color16_to_rgb決議：先將十六進制字串 # 符號后的6個字符分裂為3個，每兩個代表一個十六進制數字，通過int(num,16)可實作將其轉換為十進制，
從回傳值來看，’#FF6347’被轉換成十進制元組——(255, 99, 71)，事實上，電腦顯示帶顏色的圖片就是通過三通道的陣列（寬×高×3）實作的，電腦螢屏在不同解析度下被劃分為M×N的小格，每個小格包含3個數字，分別代表紅色通道（R），綠色通道（G），藍色通道（B）的明暗，0表示最暗，255表示最亮，3通道排列組合一共將產生256×256×256=16777216種顏色組合，這便是理論上總的顏色個數，
matplotlib并沒有保存十進制RGB元組，保存的是十進制元組歸一化后的元組，即十進制元組/255.0后的浮點數，
十六進制和RGB元組都能表示顏色，不同的是前者是離散的，后者是連續的，在使用程序中，可充分利用離散資料的唯一性和連續資料的連續性進行相對應的配色，

可通過matplotlib自帶的mpl.colors.to_rgb 介面實作了上述功能，如下圖可知，兩種方式輸出的歸一化后元組完全相同，

mpl.colors.to_rgb('#FF6347')

輸出

(1.0, 0.38823529411764707, 0.2784313725490196)

以下代碼展示了’#FF6347’的顯色效果（左上角子圖）和分通道的顯色效果，

(R, G, B), (R10, G10, B10)=color16_to_rgb('#FF6347')
img=np.zeros(shape=[15,15,3],dtype=np.int)  # 均為0的3通道陣列
imgR,imgG,imgB=img.copy(),img.copy(),img.copy() # 復制為3個，后續分別用來給每個通道賦值

fig,axs=plt.subplots(2,2,figsize=(8,8))
axs=axs.ravel() # 將axs拉平成一維串列

# 去掉所有子圖坐標系
for ax in axs:
    ax.axis('off')

# R，G，B channels —— ax0
img[:,:,0]=R10
img[:,:,1]=G10
img[:,:,2]=B10
axs[0].imshow(img)
axs[0].set_title('img R,G,B channels\nvalues: %d,%d,%d '% (R10,G10,B10),fontsize=20)

# R channel —— ax1
imgR[:,:,0]=R10
axs[1].imshow(imgR)
axs[1].set_title('img R channel\nvalue: %d'%R10,fontsize=20)

# G channel —— ax2
imgG[:,:,1]=G10
axs[2].imshow(imgG)
axs[2].set_title('img G channel\nvalue: %d'%G10,fontsize=20)

# B channel —— ax3
imgB[:,:,2]=B10
axs[3].imshow(imgB)
axs[3].set_title('img B channel\nvalue: %d'%B10,fontsize=20)

可視化CSS4_COLORS

以下代碼可視化地展示了CSS4_COLORS命名空間各顏色的名稱及顯色效果，根據顯色效果，使用者可根據十六進制字串或顏色名稱進行相應呼叫，

fig, axs = plt.subplots(37, 8, figsize=(12, 20))
axs = axs.ravel()  # 將axs拉平成一維串列

colors = mpl.colors.CSS4_COLORS  # 字典，包含148個元素

for i, (name, color) in enumerate(colors.items()):
    ax_color = axs[2*i]  # 偶數子圖填充顏色并列印顏色十六進制字符
    ax_name = axs[2*i+1]  # 奇數子圖列印顏色名稱

    # 去除x，y軸標簽
    for ax in [ax_color, ax_name]:
        ax.set_xticks([])
        ax.set_yticks([])

    ax_color.set(facecolor=color)  # 顏色子圖填充該顏色

    # 將十六進制顏色字符列印至子圖ax_color
    ax_color.text(0.5, 0.5, color, va='center', ha='center',
                  fontsize=12, transform=ax_color.transAxes)
    # 將顏色名稱字符列印至子圖ax_name
    ax_name.text(0.5, 0.5, name, va='center', ha='center',
                 fontsize=12, transform=ax_name.transAxes)

plt.tight_layout(pad=0)
plt.subplots_adjust(wspace=0,hspace=0)  # 子圖水平與垂直方向間距均調成0

繪制N條漸變線

利用RGB元組的資料連續性，可以很快的繪制線性變化的顏色序列，本圖繪制了顏色在R通道上從150-255線性均勻的變化程序，

N = 6
x = np.linspace(-4, 4, 100)
ys = [i+np.sin(x) for i in range(N)]
cs = np.linspace(150, 255, N)

for i, y in enumerate(ys):
    plt.plot(x, y, c=(cs[i]/255.0, 0, 0), lw=10, label='R-%d' % int(cs[i]))
plt.legend(bbox_to_anchor=(1.02, 0.8), fontsize=15, frameon=False)
# plt.xticks([])
# plt.yticks([])

不難看出元組表示的顏色更適合連續資料的映射，十六進制表示的顏色更適合精確命名顏色，

自定義顏色空間

mpl.colors.ListedColormap

ListedColormap定制的是離散型色板，顏色會根據色板串列回圈，
本例在r,g,b三個通道上，線性地生成了20個資料，并通過串列推導式，生成了包含此20個顏色的串列，并將顏色與資料y的大小進行了映射，
從圖中可以看出，y值比較小的時候，顏色為翠綠色，當y值比較大的時候，顏色為亮紫色，

N=20
colors=[(r,g,b) for (r,g,b) in zip(np.linspace(0,1,N),np.linspace(1,0,N),np.linspace(0,1,N))]
my_cmap=mpl.colors.ListedColormap(colors)
plt.cm.register_cmap(name='mycmp',cmap=my_cmap)

x=np.linspace(-np.pi,np.pi,N)
y=np.sin(x)

plt.scatter(x,y,s=200,c=y,cmap=plt.cm.get_cmap('mycmp'))

輸出定制色板的前五種顏色，如下：

plt.cm.get_cmap('mycmp').colors[:5]

輸出

[(0.0, 1.0, 0.0),
 (0.05263157894736842, 0.9473684210526316, 0.05263157894736842),
 (0.10526315789473684, 0.8947368421052632, 0.10526315789473684),
 (0.15789473684210525, 0.8421052631578947, 0.15789473684210525),
 (0.21052631578947367, 0.7894736842105263, 0.21052631578947367)]

mpl.colors.LinearSegmentedColormap.from_list

LinearSegmentedColormap定制的是一個色板演算法，其原理是通過線性的給出3個顏色點，其余顏色通過插值的方式獲得，
本例將色板與y值大小進行了資料映射，從圖中可以看出y較小時為黑色，較大時為白色，中間為藍色，與我們傳入的startcolor、midcolor、endcolor實作了對應，

startcolor=(0.0,0.0,0.0)  # 全白
midcolor=(0.0,0.0,1.0)  # 全藍
endcolor=(1.0,1.0,1.0)  # 全黑
my_cmap1=mpl.colors.LinearSegmentedColormap.from_list(name='mycmp1',colors=[startcolor,midcolor,endcolor])
plt.cm.register_cmap(name='mycmp1',cmap=my_cmap1)

x=np.linspace(-np.pi,np.pi,N)
y=np.sin(x)

plt.scatter(x,y,s=200,c=y,cmap=plt.cm.get_cmap('mycmp1'))  

顏色地圖colormap

可通過plt.cm直接呼叫已在matplotlib中定制好的色板，
以下兩個案例分別將y、x資料與色板進行了資料映射，效果如下，

plt.cm

N=40
np.random.seed(123)
x=np.random.randn(N)
y=np.random.randn(N)
s=np.linspace(100,1000,N)

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

mappable=ax.scatter(x,y,c=y,s=s,alpha=0.6,cmap=plt.cm.RdBu)
# 添加顏色條
cb=plt.colorbar(mappable=mappable,ax=ax)

N=40
np.random.seed(123)
x=np.random.randn(N)
y=np.random.randn(N)
s=np.linspace(100,1000,N)

fig=plt.figure(figsize=(6,5))
ax=fig.add_subplot(111)

mappable=ax.scatter(x,y,c=x,s=s,alpha=0.6,cmap=plt.cm.RdBu)
# 添加水平方向顏色條
cb=plt.colorbar(mappable=mappable,ax=ax,orientation='horizontal')

plt.cm — listed_cmap

plt.cm包含很多默認色板，如下：

cmap_all='''Accent = <matplotlib.colors.ListedColormap object>
Accent_r = <matplotlib.colors.ListedColormap object>
Blues = <matplotlib.colors.LinearSegmentedColormap object>
………………
hot = <matplotlib.colors.LinearSegmentedColormap object>
hot_r = <matplotlib.colors.LinearSegmentedColormap object>
hsv = <matplotlib.colors.LinearSegmentedColormap object>
hsv_r = <matplotlib.colors.LinearSegmentedColormap object>
inferno = <matplotlib.colors.ListedColormap object>
inferno_r = <matplotlib.colors.ListedColormap object>
jet = <matplotlib.colors.LinearSegmentedColormap object>
…………………
winter = <matplotlib.colors.LinearSegmentedColormap object>
winter_r = <matplotlib.colors.LinearSegmentedColormap object>'''

提取資訊

def get_cmap_names(string):
    import re
    match=re.match(pattern=r'(.*) = <matplotlib.colors.(.*) object>',string=string)
    return match.group(1),match.group(2)
cmap_dict={}
for cmap_ in cmap_all.split('\n'):
    cmap_name,cmap_cat=get_cmap_names(cmap_)
    cmap_dict[cmap_name]=cmap_cat

listed_cmap_list=[k for k,v in cmap_dict.items() if v=='ListedColormap']
listed_Seg_cmap_list=[k for k,v in cmap_dict.items() if v=='LinearSegmentedColormap']

cmap_dict,listed_cmap_list,listed_Seg_cmap_list
len(listed_cmap_list),len(listed_Seg_cmap_list)

plt.cm共包含38個ListedColormap色板和126個LinearSegmentedColormap

(38, 126)

可視化listed_cmap

將38個ListedColormap色板可視化，如下：

from matplotlib.gridspec import GridSpec
nrows = len(listed_cmap_list)
gs = GridSpec(nrows=nrows, ncols=2, width_ratios=[
              6, 15], left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
fig = plt.figure(figsize=(8, 12))
plt.xticks([])
plt.yticks([])
x = np.linspace(0, 1, 20)
y = x.reshape(-1, 1)
xv, yv = np.meshgrid(x, y)
for i, listed_map in enumerate(listed_cmap_list):
    # 奇數子圖顯示colormap名稱
    ax = fig.add_subplot(gs[i, 0], frameon=True)
    ax.text(0.5, 0.5, listed_map, fontdict={
            'size': 17}, ha='center', va='center', transform=ax.transAxes)
    ax.set_xticks([])
    ax.set_yticks([])
    # 偶數子圖繪制colormap漸變顏色
    ax = fig.add_subplot(gs[i, 1], frameon=True)
    ax.imshow(xv, cmap=plt.cm.get_cmap(listed_map), aspect='auto'  # auto 自動調節以充滿整個ax
              , extent=(0, 1, 0, 1))  # 通過增加extent，從而充滿整個ax坐標軸
    ax.set_xticks([])
    ax.set_yticks([])

可視化listed_Seg_cmap

將126個LinearSegmentedColormap色板可視化，如下：

nrows = len(listed_Seg_cmap_list)
gs = GridSpec(nrows=nrows, ncols=2, width_ratios=[
              6, 15], left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
fig = plt.figure(figsize=(12, 35))
plt.xticks([])
plt.yticks([])
x = np.linspace(0, 1, 20)
y = x.reshape(-1, 1)
xv, yv = np.meshgrid(x, y)

for i, listed_map in enumerate(listed_Seg_cmap_list):
    index = i
    ax = fig.add_subplot(gs[index, 0], frameon=True)
    ax.set_xticks([])
    ax.set_yticks([])
    ax.text(0.5, 0.5, listed_map, fontdict={
            'size': 17}, ha='center', va='center', transform=ax.transAxes)

    ax = fig.add_subplot(gs[index, 1], frameon=True)
    ax.set_xticks([])
    ax.set_yticks([])
    ax.imshow(xv, cmap=plt.cm.get_cmap(listed_map), aspect='auto'  # auto 自動調節以充滿整個ax
              , extent=(0, 1, 0, 1))  # 通過增加extent，從而充滿整個ax坐標軸

色板 palette

seaborn是在matplolib基礎上封裝的高級可視化庫，其色板主要通過palette引數設定

色板命名空間

seaborn默認6種色板命名空間：deep,muted, pastel, bright, dark, colorblind
各色板顏色變化順序如下：

pal = sns.color_palette(palette='deep')
sns.palplot(pal)

pal = sns.color_palette(palette='muted')
sns.palplot(pal)

pal = sns.color_palette(palette='pastel')
sns.palplot(pal)

pal = sns.color_palette(palette='bright')
sns.palplot(pal)

pal = sns.color_palette(palette='dark')
sns.palplot(pal)

pal = sns.color_palette(palette='colorblind')
sns.palplot(pal)

定制色板

有多種方式定制seaborn的palette，

基于plt.cm

pal=pal_from_cmap=sns.color_palette('hot')
sns.palplot(pal)

基于顏色串列

colors=[(r,g,b) for r,g,b in zip(np.linspace(0,1,5),np.linspace(0.2,0.7,5),np.linspace(0,1,5))]
pal=pal_from_colors=sns.color_palette(colors)
sns.palplot(pal)

基于HLS色彩空間生成的離散型色盤

pal=sns.hls_palette(n_colors=10, h=0.5, l=0.6, s=0.3)
sns.palplot(pal)

基于球形空間

# 基于球形空間生成的線性色盤
pal=sns.cubehelix_palette(n_colors=10,
                            start=1,
                            rot=0.4,
                            gamma=1.0,
                            hue=0.8,
                            light=0.85,
                            dark=0.15,)
sns.palplot(pal)

基于色系

pal=sns.dark_palette(color='red',n_colors=10,)
sns.palplot(pal)

pal=sns.light_palette(color='red',n_colors=10,)
sns.palplot(pal)

色板最直接、最明顯的應用繪圖物件包括：散點圖、面積圖、填充圖、等高線圖、等高面圖、熱力圖等，前三個已經本系列第二部分做了詳細介紹，以下對剩下幾個繪圖物件做案例介紹，細節處請詳細閱讀代碼注釋：

等高線

等高線

N = 10
x = np.linspace(-10, 10, N)
y = np.linspace(-10, 10, N)
X, Y = np.meshgrid(x, y)  # return X，Y， shape 100*100，100*100
# 這里的X，Y可以這么理解，相當于把x軸上的點，和y軸上的點投影到了 2D平面

# 針對2D平面的每一個坐標點，計算Z的值， Z shape 100*100
Z = np.power(X/0.8, 2)+np.power(Y/0.6, 2)

fig = plt.figure()
ax = fig.add_subplot(111)
# levels 顯示指定的Z值 比如 x=0,y=-10,此時 Z=100
CS = ax.contour(X, Y, Z, levels=[20, 40, 70,
                                 100, 150], cmap=plt.cm.RdBu, linewidths=5)
ax.clabel(CS, fontsize=16, fmt='%.0f')

cb = plt.colorbar(mappable=CS)

等高面

N = 1000
x = np.linspace(0, 10, N)
y = np.linspace(-10, 10, N)
X, Y = np.meshgrid(x, y)  # return X，Y， shape 100*100，100*100
# 這里的X，Y可以這么理解，相當于把x軸上的點，和y軸上的點投影到了 2D平面

Z = np.power(X, 2)-np.power(Y, 2)  # 針對2D平面的每一個坐標點，計算Z的值， Z shape 100*100
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_xlim(-1, 11)
ax.set_ylim(-12, 12)

CS = ax.contourf(X, Y, Z  # ,levels=[-100,-50,50,100]
                 , cmap=plt.cm.Blues
                 )  # levels 顯示指定的Z值 比如 x=0,y=-10,此時 Z=100
ax.clabel(CS, fontsize=16, fmt='%.0f', inline=False, colors='black')

cb = plt.colorbar(mappable=CS)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.plot(x, x, c=(0.75, 0, 0), lw=4, ls='--')

熱力圖

grid_kws = {"height_ratios": (0.9, 0.1)}  # 熱力圖與顏色條高度比值為 0.9：0.1
fig, (ax, cbar_ax) = plt.subplots(
    2, 1, gridspec_kw=grid_kws)  # 2行1列，第一行為熱力圖，第二行為顏色條

data = np.random.randn(64).reshape(8, -1)
sns.heatmap(data,
            ax=ax,
            cbar_ax=cbar_ax,
            cbar=True,
            cbar_kws={"orientation": "horizontal"})  # 將顏色條方向調為水平方向

總結

顏色命名空間 mpl.colors 總結

plt.cm 總結

希望對你有所幫助和啟發！