matplotlib.axes.Axes.pcolor #

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

Crie um gráfico de pseudocor com uma grade retangular não regular.

Assinatura de chamada:

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

X e Y podem ser usados para especificar os cantos dos quadriláteros.

Dica

pcolor()pode ser muito lento para matrizes grandes. Na maioria dos casos, você deve usar o semelhante, mas muito mais rápido pcolormesh. Veja Diferenças entre pcolor() e pcolormesh() para uma discussão sobre as diferenças.

Parâmetros :

C 2D semelhante a array

Os valores mapeados por cores. O mapeamento de cores é controlado por cmap , norm , vmin e vmax .

X, Y tipo array, opcional

As coordenadas dos cantos dos quadriláteros de uma 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])

Observe que o índice da coluna corresponde à coordenada x e o índice da linha corresponde a y. Para obter detalhes, consulte a seção Notas abaixo.

Se shading='flat'as dimensões de X e Y devem ser maiores que as de C , e o quadrilátero é colorido devido ao valor em . Se X , Y e C tiverem dimensões iguais, um aviso será gerado e a última linha e coluna de C serão ignoradas.C[i, j]

Se shading='nearest', as dimensões de X e Y devem ser iguais às de C (caso contrário, será gerado um ValueError). A cor será centralizada em .C[i, j](X[i, j], Y[i, j])

Se X e/ou Y forem matrizes 1-D ou vetores de coluna, eles serão expandidos conforme necessário nas matrizes 2D apropriadas, criando uma grade retangular.

sombreamento {'plano', 'mais próximo', 'automático'}, padrão: rcParams["pcolor.shading"](padrão: 'auto')

O estilo de preenchimento para o quadrilátero. Valores possíveis:

'flat': Uma cor sólida é usada para cada quadrante. A cor do quadrado (i, j), (i+1, j), (i, j+1), (i+1, j+1) é dada por . As dimensões de X e Y devem ser maiores que as de C ; se forem iguais a C , um aviso de descontinuação será emitido e a última linha e coluna de C serão descartadas.C[i, j]
'mais próximo': Cada ponto da grade terá uma cor centralizada nele, estendendo-se a meio caminho entre os centros da grade adjacentes. As dimensões de X e Y devem ser as mesmas de C .
'auto': Escolha 'flat' se as dimensões de X e Y forem maiores que C . Escolha 'mais próximo' se as dimensões forem as mesmas.

Consulte grades e sombreamento pcolormesh para obter mais descrições.

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

A instância do Colormap ou nome do mapa de cores registrado usado para mapear dados escalares para cores.

norma str ou Normalize, opcional

O método de normalização usado para dimensionar dados escalares para o intervalo [0, 1] antes de mapear para cores usando cmap . Por padrão, uma escala linear é usada, mapeando o valor mais baixo para 0 e o mais alto para 1.

Se fornecido, pode ser um dos seguintes:

Uma instância Normalizeou uma de suas subclasses (consulte Normalização do mapa de cores ).
Um nome de escala, ou seja, um de "linear", "log", "symlog", "logit", etc. Para obter uma lista de escalas disponíveis, chame matplotlib.scale.get_scale_names(). Nesse caso, uma Normalizesubclasse adequada é gerada e instanciada dinamicamente.

vmin, vmax flutuante, opcional

Ao usar dados escalares e nenhuma norma explícita , vmin e vmax definem o intervalo de dados que o mapa de cores cobre. Por padrão, o mapa de cores cobre toda a faixa de valores dos dados fornecidos. É um erro usar vmin / vmax quando uma instância de norma é fornecida (mas usar um nome de norma junto com vmin / vmax é aceitável).str

edgecolors {'nenhum', nenhum, 'face', cor, sequência de cores}, opcional

A cor das bordas. O padrão é 'nenhum'. Valores possíveis:

'nenhum' ou '': Sem borda.
Nenhum : rcParams["patch.edgecolor"](padrão: 'black') será usado. Observe que atualmente rcParams["patch.force_edgecolor"](padrão: False) deve ser True para que isso funcione.
'face': Use a cor da face adjacente.
Uma cor ou sequência de cores definirá a cor da borda.

A forma singular edgecolor funciona como um alias.

float alfa , padrão: nenhum

O valor de mistura alfa da cor da face, entre 0 (transparente) e 1 (opaco). Nota: A cor da borda não é afetada por isso.

snap bool, padrão: False

Se deve ajustar a malha aos limites de pixel.

Devoluções :

matplotlib.collections.Collection

Outros Parâmetros :

antialiaseds bool, padrão: False

O antialiased padrão é False se o padrão edgecolors ="none" for usado. Isso elimina linhas artificiais nos limites do patch e funciona independentemente do valor de alfa. Se edgecolors não for "nenhum", então o antialiased padrão é obtido rcParams["patch.antialiased"](padrão: True). Traçar as bordas pode ser preferível se alfa for 1, mas, caso contrário, causará artefatos.

objeto indexável de dados , opcional

Se fornecido, todos os parâmetros também aceitam uma string s, que é interpretada como data[s](a menos que isso gere uma exceção).

** kwargs

Além disso, os seguintes argumentos são permitidos. Eles são passados para o PolyCollectionconstrutor:

Propriedade	Descrição
`agg_filter`	uma função de filtro, que usa uma matriz flutuante (m, n, 3) e um valor de dpi e retorna uma matriz (m, n, 3) e dois deslocamentos do canto inferior esquerdo da imagem
`alpha`	tipo array ou escalar ou Nenhum
`animated`	bool
`antialiased`ou aa ou antialiaseds	bool ou lista de bools
`array`	tipo array ou nenhum
`capstyle`	`CapStyle`ou {'bunda', 'projetando', 'redondo'}
`clim`	(vmin: flutuante, vmax: flutuante)
`clip_box`	`Bbox`
`clip_on`	bool
`clip_path`	Patch ou (Caminho, Transformação) ou Nenhum
`cmap`	`Colormap`ou str ou Nenhum
`color`	cor ou lista de tuplas rgba
`edgecolor`ou ec ou cores de borda	cor ou lista de cores ou 'face'
`facecolor`ou facecolors ou fc	cor ou lista de cores
`figure`	`Figure`
`gid`	str
`hatch`	{'/', '\', '\|', '-', '+', 'x', 'o', 'O', '.', '*'}
`in_layout`	bool
`joinstyle`	`JoinStyle`ou {'esquadria', 'redondo', 'chanfrado'}
`label`	objeto
`linestyle`ou traços ou estilos de linha ou ls	str ou tupla ou lista dos mesmos
`linewidth`ou larguras de linha ou lw	flutuador ou lista de flutuadores
`mouseover`	bool
`norm`	`Normalize`ou str ou Nenhum
`offset_transform`ou transOffset	desconhecido
`offsets`	(N, 2) ou (2,) tipo matriz
`path_effects`	`AbstractPathEffect`
`paths`	lista de tipo array
`picker`	None ou bool ou float ou callable
`pickradius`	desconhecido
`rasterized`	bool
`sizes`	ndarray ou nenhum
`sketch_params`	(escala: flutuante, comprimento: flutuante, aleatoriedade: flutuante)
`snap`	bool ou nenhum
`transform`	`Transform`
`url`	str
`urls`	lista de str ou None
`verts`	lista de tipo array
`verts_and_codes`	desconhecido
`visible`	bool
`zorder`	flutuador

Veja também

pcolormesh: para uma explicação das diferenças entre pcolor e pcolormesh.
imshow: Se X e Y forem equidistantes, imshowpode ser uma alternativa mais rápida.

Notas

Matrizes mascaradas

X , Y e C podem ser arrays mascarados. Se , ou um dos vértices circundantes ( X ou Y em ) for mascarado, nada será plotado.C[i, j]C[i, j][i, j], [i+1, j], [i, j+1], [i+1, j+1]

Orientação da grade

A orientação da grade segue a convenção de matriz padrão: uma matriz C com forma (nrows, ncolumns) é plotada com o número da coluna como X e o número da linha como Y .

Exemplos usando `matplotlib.axes.Axes.pcolor`#

Demonstração Pcolor

Controlando os limites de exibição usando margens e sticky_edges

matplotlib.axes.Axes.pcolor #

Exemplos usando matplotlib.axes.Axes.pcolor#

Exemplos usando `matplotlib.axes.Axes.pcolor`#