matplotlib
färgkartor

Grundläggande användning

Att använda inbyggda färgkartor är lika enkelt som att skicka namnet på den nödvändiga kolormappen (som anges i kolumapsreferensen ) till plottningsfunktionen (t.ex. pcolormesh eller contourf ) som förväntar sig den, vanligtvis i form av ett cmap :

import matplotlib.pyplot as plt
import numpy as np

plt.figure()
plt.pcolormesh(np.random.rand(20,20),cmap='hot')
plt.show()

Colormaps är särskilt användbara för att visualisera tredimensionella data på tvådimensionella tomter, men en bra kolormap kan också göra en riktig tredimensionell plot mycket tydligare:

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.ticker import LinearLocator

# generate example data
import numpy as np
x,y = np.meshgrid(np.linspace(-1,1,15),np.linspace(-1,1,15))
z = np.cos(x*np.pi)*np.sin(y*np.pi)

# actual plotting example
fig = plt.figure()
ax1 = fig.add_subplot(121, projection='3d')
ax1.plot_surface(x,y,z,rstride=1,cstride=1,cmap='viridis')
ax2 = fig.add_subplot(122)
cf = ax2.contourf(x,y,z,51,vmin=-1,vmax=1,cmap='viridis')
cbar = fig.colorbar(cf)
cbar.locator = LinearLocator(numticks=11)
cbar.update_ticks()
for ax in {ax1, ax2}:
    ax.set_xlabel(r'$x$')
    ax.set_ylabel(r'$y$')
    ax.set_xlim([-1,1])
    ax.set_ylim([-1,1])
    ax.set_aspect('equal')

ax1.set_zlim([-1,1])
ax1.set_zlabel(r'$\cos(\pi x) \sin(\p    i y)$')

plt.show()

Använda anpassade färgkartor

Bortsett från de inbyggda kolormappar som definieras i kolormapsreferensen (och deras omvända kartor, med '_r' bifogat deras namn), kan anpassade kolormapper också definieras. Nyckeln är matplotlib.cm modulen.

Exemplet nedan definierar en mycket enkel färgform med hjälp av cm.register_cmap , som innehåller en enda färg, med opaciteten (alfa-värdet) för färgen som interpolerar mellan helt ogenomskinligt och helt genomskinligt i dataområdet. Observera att de viktiga linjerna ur kolormapets synvinkel är importen av cm , samtalet till register_cmap och överföringen av färgformen till plot_surface .

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.cm as cm

# generate data for sphere
from numpy import pi,meshgrid,linspace,sin,cos
th,ph = meshgrid(linspace(0,pi,25),linspace(0,2*pi,51))
x,y,z = sin(th)*cos(ph),sin(th)*sin(ph),cos(th)

# define custom colormap with fixed colour and alpha gradient
# use simple linear interpolation in the entire scale
cm.register_cmap(name='alpha_gradient',
                 data={'red':   [(0.,0,0),
                                 (1.,0,0)],

                       'green': [(0.,0.6,0.6),
                                 (1.,0.6,0.6)],

                       'blue':  [(0.,0.4,0.4),
                                 (1.,0.4,0.4)],

                       'alpha': [(0.,1,1),
                                 (1.,0,0)]})

# plot sphere with custom colormap; constrain mapping to between |z|=0.7 for enhanced effect
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(x,y,z,cmap='alpha_gradient',vmin=-0.7,vmax=0.7,rstride=1,cstride=1,linewidth=0.5,edgecolor='b')
ax.set_xlim([-1,1])
ax.set_ylim([-1,1])
ax.set_zlim([-1,1])
ax.set_aspect('equal')

plt.show()

I mer komplicerade scenarier kan man definiera en lista med R / G / B (/ A) -värden i vilka matplotlib interpolerar linjärt för att bestämma färgerna som används i motsvarande diagram.

Perceptuellt enhetliga kolormaps

Det ursprungliga standardfärgkarta för MATLAB (ersatt i version R2014b) som kallas jet är allestädes när det gäller den höga kontrasten och kännedom (och var standard för matplotlib av kompatibilitetsskäl). Trots sin popularitet har traditionella färgkartor ofta brister när det gäller att exakt representera data. Förändrad förändring i dessa färgkartor motsvarar inte förändringar i data; och en konvertering av kolumnen till gråskala (genom att till exempel skriva ut en siffra med en svartvit skrivare) kan orsaka förlust av information.

Perceptuellt enhetliga kolormaps har införts för att göra datavisualisering så exakt och tillgänglig som möjligt. Matplotlib introducerade fyra nya, perceptuellt enhetliga färgkartor i version 1.5, med en av dem (benämnd viridis ) som standard från version 2.0. Dessa fyra kolormappar ( viridis , inferno , plasma och magma ) är alla optimala ur uppfattningens synvinkel, och dessa bör användas som standard för datavisualisering såvida det inte finns mycket goda skäl att inte göra det. Dessa färgkartor introducerar så lite partiskhet som möjligt (genom att inte skapa funktioner där det inte finns några till att börja med), och de är lämpliga för en publik med nedsatt färguppfattning.

Som ett exempel för visuellt förvrängande data bör du tänka på följande två ovanifrån av pyramidliknande objekt:

Vilken av de två är en riktig pyramid? Svaret är naturligtvis att båda är det, men det är långt ifrån uppenbart från handlingen med jet Colormap:

Denna funktion är kärnan i perceptuell enhetlighet.

Anpassad diskret färgform

Om du har fördefinierade intervall och vill använda specifika färger för dessa intervall kan du förklara anpassad färgform. Till exempel:

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

x = np.linspace(-2,2,500)
y = np.linspace(-2,2,500)
XX, YY = np.meshgrid(x, y)
Z = np.sin(XX) * np.cos(YY)

cmap = colors.ListedColormap(['red', '#000000','#444444', '#666666', '#ffffff', 'blue', 'orange'])
boundaries = [-1, -0.9, -0.6, -0.3, 0, 0.3, 0.6, 1]
norm = colors.BoundaryNorm(boundaries, cmap.N, clip=True)

plt.pcolormesh(x,y,Z, cmap=cmap, norm=norm)
plt.colorbar()
plt.show()

producerar

Färg i kommer att användas för värden mellan gränsen i och i + 1 . Färger kan anges med namn ( 'red' , 'green' ), HTML-koder ( '#ffaa44' , '#441188' ) eller RGB-tuples ( (0.2, 0.9, 0.45) ).