Créer propre palette de couleurs à l'aide de matplotlib et de l'intrigue échelle de couleurs

Il est un exemple illustratif de la apprendre à créer des colormaps ici.
La docstring est essentiel pour comprendre le sens de
cdict. Une fois que vous obtenir ce sous votre ceinture, vous pouvez utiliser un cdict comme ceci:

cdict = {'red':   ((0.0, 1.0, 1.0), 
                   (0.1, 1.0, 1.0),  # red 
                   (0.4, 1.0, 1.0),  # violet
                   (1.0, 0.0, 0.0)), # blue

         'green': ((0.0, 0.0, 0.0),
                   (1.0, 0.0, 0.0)),

         'blue':  ((0.0, 0.0, 0.0),
                   (0.1, 0.0, 0.0),  # red
                   (0.4, 1.0, 1.0),  # violet
                   (1.0, 1.0, 0.0))  # blue
          }

Bien que le cdict format vous donne beaucoup de flexibilité, je trouve que pour de simples
les gradients de son format est assez peu intuitive. Voici une fonction d'utilité à l'aide
de générer de simples LinearSegmentedColormaps:

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


def make_colormap(seq):
    """Return a LinearSegmentedColormap
    seq: a sequence of floats and RGB-tuples. The floats should be increasing
    and in the interval (0,1).
    """
    seq = [(None,) * 3, 0.0] + list(seq) + [1.0, (None,) * 3]
    cdict = {'red': [], 'green': [], 'blue': []}
    for i, item in enumerate(seq):
        if isinstance(item, float):
            r1, g1, b1 = seq[i - 1]
            r2, g2, b2 = seq[i + 1]
            cdict['red'].append([item, r1, r2])
            cdict['green'].append([item, g1, g2])
            cdict['blue'].append([item, b1, b2])
    return mcolors.LinearSegmentedColormap('CustomMap', cdict)


c = mcolors.ColorConverter().to_rgb
rvb = make_colormap(
    [c('red'), c('violet'), 0.33, c('violet'), c('blue'), 0.66, c('blue')])
N = 1000
array_dg = np.random.uniform(0, 10, size=(N, 2))
colors = np.random.uniform(-2, 2, size=(N,))
plt.scatter(array_dg[:, 0], array_dg[:, 1], c=colors, cmap=rvb)
plt.colorbar()
plt.show()

Par le chemin, la for-loop

for i in range(0, len(array_dg)):
  plt.plot(array_dg[i], markers.next(),alpha=alpha[i], c=colors.next())

parcelles d'un point pour chaque appel à plt.plot. Cela fonctionne pour un petit nombre de points, mais devient très lente pour de nombreux points. plt.plot ne peut tirer qu'en une seule couleur, mais plt.scatter pouvez attribuer une couleur différente à chaque point. Ainsi, plt.scatter est le chemin à parcourir.

Si vous souhaitez automatiser la création d'une coutume divergentes de la palette de couleurs utilisée couramment pour des parcelles de surface, ce module combiné avec @unutbu méthode a bien fonctionné pour moi.

def diverge_map(high=(0.565, 0.392, 0.173), low=(0.094, 0.310, 0.635)):
    '''
    low and high are colors that will be used for the two
    ends of the spectrum. they can be either color strings
    or rgb color tuples
    '''
    c = mcolors.ColorConverter().to_rgb
    if isinstance(low, basestring): low = c(low)
    if isinstance(high, basestring): high = c(high)
    return make_colormap([low, c('white'), 0.5, c('white'), high])

Les valeurs haute et basse peut être soit la chaîne de caractères des noms de couleur rvb ou des n-uplets. C'est le résultat de l'utilisation de la surface de la parcelle de démonstration: