matplotlib.axes.Axes.pcolor #

Assi. pcolor ( * args , shading = None , alpha = None , norm = None , cmap = None , vmin = None , vmax = None , data = None , ** kwargs ) [fonte] #

Crea un grafico pseudocolore con una griglia rettangolare non regolare.

Firma chiamata:

pcolor([X, Y,] C, **kwargs)

X e Y possono essere usati per specificare gli angoli dei quadrilateri.

Suggerimento

pcolor()può essere molto lento per array di grandi dimensioni. Nella maggior parte dei casi dovresti usare pcolormeshinvece il simile ma molto più veloce. Vedere Differenze tra pcolor() e pcolormesh() per una discussione sulle differenze.

Parametri :

C simile a un array 2D

I valori mappati a colori. La mappatura dei colori è controllata da cmap , norm , vmin e vmax .

X, Y simile a un array, facoltativo

Le coordinate degli angoli dei quadrilateri di un pcolormesh:

(X[i+1, j], Y[i+1, j])       (X[i+1, j+1], Y[i+1, j+1])
                      +-----+
                      |     |
                      +-----+
    (X[i, j], Y[i, j])       (X[i, j+1], Y[i, j+1])

Si noti che l'indice di colonna corrisponde alla coordinata x e l'indice di riga corrisponde a y. Per i dettagli, vedere la sezione Note di seguito.

Se shading='flat'le dimensioni di X e Y dovessero essere maggiori di una di quelle di C , e il quadrilatero è colorato a causa del valore in . Se X , Y e C hanno dimensioni uguali, verrà generato un avviso e l'ultima riga e colonna di C verrà ignorata.C[i, j]

Se shading='nearest', le dimensioni di X e Y dovrebbero essere le stesse di C (in caso contrario, verrà sollevato un ValueError). Il colore sarà centrato su .C[i, j](X[i, j], Y[i, j])

Se X e/o Y sono array 1-D o vettori colonna, verranno espansi secondo necessità negli array 2D appropriati, creando una griglia rettangolare.

shading {'flat', 'nearest', 'auto'}, default: rcParams["pcolor.shading"](default: 'auto')

Lo stile di riempimento per il quadrilatero. Possibili valori:

'flat': viene utilizzato un colore a tinta unita per ogni quad. Il colore del quadrato (i, j), (i+1, j), (i, j+1), (i+1, j+1) è dato da . Le dimensioni di X e Y dovrebbero essere maggiori di una di quelle di C ; se sono uguali a C , viene generato un avviso di deprecazione e l'ultima riga e colonna di C vengono eliminate.C[i, j]
'più vicino': ogni punto della griglia avrà un colore centrato su di esso, che si estende a metà strada tra i centri della griglia adiacenti. Le dimensioni di X e Y devono essere le stesse di C .
'auto': scegli 'piatto' se le dimensioni di X e Y sono maggiori di una unità rispetto a C . Scegli "più vicino" se le dimensioni sono le stesse.

Vedere le griglie pcolormesh e l'ombreggiatura per ulteriori descrizioni.

cmap str o Colormap, predefinito: rcParams["image.cmap"](predefinito: 'viridis')

L'istanza Colormap o il nome registrato della mappa colori utilizzato per mappare i dati scalari ai colori.

norm str o Normalize, facoltativo

Il metodo di normalizzazione utilizzato per ridimensionare i dati scalari nell'intervallo [0, 1] prima della mappatura ai colori utilizzando cmap . Per impostazione predefinita, viene utilizzato un ridimensionamento lineare, mappando il valore più basso su 0 e il più alto su 1.

Se indicato, può essere uno dei seguenti:

Un'istanza di Normalizeo una delle sue sottoclassi (vedere Normalizzazione della mappa dei colori ).
Un nome di scala, ad esempio "linear", "log", "symlog", "logit", ecc. Per un elenco delle scale disponibili, chiamare matplotlib.scale.get_scale_names(). NormalizeIn tal caso, una sottoclasse adatta viene generata dinamicamente e istanziata.

vmin, vmax float, facoltativo

Quando si utilizzano dati scalari e nessuna norma esplicita , vmin e vmax definiscono l'intervallo di dati coperto dalla mappa dei colori. Per impostazione predefinita, la mappa dei colori copre l'intero intervallo di valori dei dati forniti. È un errore utilizzare vmin / vmax quando viene fornita un'istanza di norma (ma l'utilizzo di un nome di norma insieme a vmin / vmax è accettabile).str

edgecolors {'none', None, 'face', color, color sequence}, facoltativo

Il colore dei bordi. Il valore predefinito è 'nessuno'. Possibili valori:

'none' o '': nessun bordo.
Nessuno : rcParams["patch.edgecolor"](predefinito: 'black') verrà utilizzato. Si noti che attualmente rcParams["patch.force_edgecolor"](default: False) deve essere True affinché funzioni.
'faccia': usa il colore della faccia adiacente.
Un colore o una sequenza di colori imposterà il colore del bordo.

La forma singolare edgecolor funziona come alias.

alfa float, predefinito: Nessuno

Il valore di fusione alfa del colore del viso, compreso tra 0 (trasparente) e 1 (opaco). Nota: il colore del bordo non è attualmente influenzato da questo.

snap bool, predefinito: falso

Se agganciare la mesh ai limiti dei pixel.

Resi :

matplotlib.collections.Collection

Altri parametri :

antialiaseds bool, default: False

L' antialias predefinito è False se viene utilizzato il valore predefinito edgecolors ="none". Ciò elimina le linee artificiali ai confini della patch e funziona indipendentemente dal valore di alpha. Se edgecolors non è "none", l' antialias predefinito viene preso da rcParams["patch.antialiased"](default: True). Accarezzare i bordi può essere preferito se alpha è 1, ma in caso contrario causerà artefatti.

oggetto indicizzabile dei dati , facoltativo

Se fornito, tutti i parametri accettano anche una stringa s, che viene interpretata come data[s](a meno che ciò non sollevi un'eccezione).

**kwargs

Inoltre, sono consentiti i seguenti argomenti. Vengono passati al PolyCollectioncostruttore:

Proprietà	Descrizione
`agg_filter`	una funzione di filtro, che accetta un array float (m, n, 3) e un valore dpi e restituisce un array (m, n, 3) e due offset dall'angolo in basso a sinistra dell'immagine
`alpha`	tipo array o scalare o None
`animated`	bool
`antialiased`o aa o antialias	bool o elenco di bool
`array`	tipo array o Nessuno
`capstyle`	`CapStyle`o {'culo', 'sporgente', 'rotondo'}
`clim`	(vmin: float, vmax: float)
`clip_box`	`Bbox`
`clip_on`	bool
`clip_path`	Patch o (Percorso, Trasforma) o Nessuno
`cmap`	`Colormap`o str o Nessuno
`color`	colore o elenco di tuple rgba
`edgecolor`o ec o edgecolors	colore o elenco di colori o 'volto'
`facecolor`o facecolors o fc	colore o elenco di colori
`figure`	`Figure`
`gid`	str
`hatch`	{'/', '\', '\|', '-', '+', 'x', 'o', 'O', '.', '*'}
`in_layout`	bool
`joinstyle`	`JoinStyle`o {'mitre', 'round', 'bevel'}
`label`	oggetto
`linestyle`o trattini o stili di linea o ls	str o tuple o loro elenchi
`linewidth`o linewidths o lw	float o lista di float
`mouseover`	bool
`norm`	`Normalize`o str o Nessuno
`offset_transform`o transOffset	sconosciuto
`offsets`	(N, 2) o (2,) simile a un array
`path_effects`	`AbstractPathEffect`
`paths`	elenco di tipo array
`picker`	Nessuno o bool o float o richiamabile
`pickradius`	sconosciuto
`rasterized`	bool
`sizes`	ndarray o Nessuno
`sketch_params`	(scala: float, lunghezza: float, casualità: float)
`snap`	bool o Nessuno
`transform`	`Transform`
`url`	str
`urls`	elenco di str o Nessuno
`verts`	elenco di tipo array
`verts_and_codes`	sconosciuto
`visible`	bool
`zorder`	galleggiante

Guarda anche

pcolormesh: per una spiegazione delle differenze tra pcolor e pcolormesh.
imshow: Se X e Y sono equidistanti, imshowpuò essere un'alternativa più veloce.

Appunti

Matrici mascherate

X , Y e C possono essere array mascherati. Se uno o uno dei vertici circostanti ( X o Y at ) è mascherato, non viene tracciato nulla.C[i, j]C[i, j][i, j], [i+1, j], [i, j+1], [i+1, j+1]

Orientamento della griglia

L'orientamento della griglia segue la convenzione standard della matrice: un array C con forma (nrows, ncolumns) viene tracciato con il numero di colonna come X e il numero di riga come Y .

Esempi che utilizzano `matplotlib.axes.Axes.pcolor`#

Demo Pcolor

Controllo dei limiti di visualizzazione utilizzando margins e sticky_edges

matplotlib.axes.Axes.pcolor #

Esempi che utilizzano matplotlib.axes.Axes.pcolor#

Esempi che utilizzano `matplotlib.axes.Axes.pcolor`#