Matplotlib - Guia Rápido

Matplotlib é um dos pacotes Python mais populares usados para visualização de dados. É uma biblioteca de plataforma cruzada para fazer gráficos 2D de dados em matrizes. Matplotlib é escrito em Python e usa NumPy, a extensão matemática numérica do Python. Ele fornece uma API orientada a objetos que ajuda a incorporar gráficos em aplicativos usando kits de ferramentas Python GUI, como PyQt, WxPythonotTkinter. Ele pode ser usado em shells Python e IPython, notebook Jupyter e servidores de aplicativos da web também.

Matplotlib tem uma interface procedural chamada Pylab, que foi projetada para se assemelhar ao MATLAB, uma linguagem de programação proprietária desenvolvida pela MathWorks. Matplotlib junto com NumPy pode ser considerado o equivalente de código aberto do MATLAB.

Matplotlib foi originalmente escrito por John D. Hunter em 2003. A versão estável atual é 2.2.0 lançada em janeiro de 2018.

Matplotlib e seus pacotes de dependência estão disponíveis na forma de pacotes wheel nos repositórios de pacotes Python padrão e podem ser instalados em sistemas Windows, Linux e MacOS usando o gerenciador de pacotes pip.

pip3 install matplotlib

As versões Incase Python 2.7 ou 3.4 não são instaladas para todos os usuários, os pacotes redistribuíveis Microsoft Visual C ++ 2008 (64 bits ou 32 bits para Python 2.7) ou Microsoft Visual C ++ 2010 (64 bits ou 32 bits para Python 3.4) precisam ser instalados.

Se você estiver usando o Python 2.7 em um Mac, execute o seguinte comando -

xcode-select –install

Após a execução do comando acima, o subprocesso32 - uma dependência, pode ser compilado.

Em versões extremamente antigas do Linux e Python 2.7, você pode precisar instalar a versão master do subprocess32.

Matplotlib requer um grande número de dependências -

Python (> = 2.7 ou> = 3.4)
NumPy
setuptools
dateutil
pyparsing
libpng
pytz
FreeType
cycler
six

Opcionalmente, você também pode instalar vários pacotes para habilitar melhores kits de ferramentas de interface do usuário.

tk
PyQt4
PyQt5
pygtk
wxpython
pycairo
Tornado

Para melhor suporte de formato de saída de animação e formatos de arquivo de imagem, LaTeX, etc., você pode instalar o seguinte -

_mpeg/avconv
ImageMagick
Travesseiro (> = 2,0)
LaTeX e GhostScript (para renderizar texto com LaTeX).
LaTeX e GhostScript (para renderizar texto com LaTeX).

Anaconda é uma distribuição gratuita e de código aberto das linguagens de programação Python e R para processamento de dados em grande escala, análise preditiva e computação científica. A distribuição torna o gerenciamento e implantação de pacotes simples e fácil. Matplotlib e muitas outras ferramentas úteis de ciência (dados) fazem parte da distribuição. As versões dos pacotes são gerenciadas pelo sistema de gerenciamento de pacotes Conda. A vantagem do Anaconda é que você tem acesso a mais de 720 pacotes que podem ser facilmente instalados com o Conda do Anaconda, um gerenciador de pacote, dependência e ambiente.

A distribuição do Anaconda está disponível para instalação em https://www.anaconda.com/download/. Para instalação no Windows, binários de 32 e 64 bits estão disponíveis -

https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86.exe

https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86_64.exe

A instalação é um processo baseado em assistente bastante simples. Você pode escolher entre adicionar o Anaconda na variável PATH e registrar o Anaconda como seu Python padrão.

Para instalação no Linux, baixe instaladores para instaladores de 32 e 64 bits da página de downloads -

https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86.sh

https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86_64.sh

Agora, execute o seguinte comando no terminal Linux -

$ bash Anaconda3-5.0.1-Linux-x86_64.sh

Canopy e ActiveState são as opções mais procuradas para plataformas Windows, macOS e Linux comuns. Os usuários do Windows podem encontrar uma opção no WinPython.

Jupyter é um acrônimo vago que significa Julia, Python e R. Essas linguagens de programação foram as primeiras linguagens de destino do aplicativo Jupyter, mas hoje em dia, a tecnologia de notebook também suporta muitas outras linguagens.

Em 2001, Fernando Pérez começou a desenvolver o Ipython. IPython é um shell de comando para computação interativa em várias linguagens de programação, originalmente desenvolvido para Python.

Considere os seguintes recursos fornecidos pelo IPython -

Shells interativos (baseados em terminal e Qt).
Um notebook baseado em navegador com suporte para código, texto, expressões matemáticas, plotagens embutidas e outras mídias.
Suporte para visualização de dados interativos e uso de kits de ferramentas GUI.
Intérpretes flexíveis e incorporáveis para carregar em seus próprios projetos.

Em 2014, Fernando Pérez anunciou um projeto spin-off do IPython chamado Projeto Jupyter. O IPython continuará a existir como um shell Python e um kernel para Jupyter, enquanto o notebook e outras partes independentes de linguagem do IPython serão movidas sob o nome Jupyter. Jupyter adicionou suporte para Julia, R, Haskell e Ruby.

Para iniciar o notebook Jupyter, abra o navegador Anaconda (uma interface gráfica do usuário da área de trabalho incluída no Anaconda que permite iniciar aplicativos e gerenciar facilmente os pacotes Conda, ambientes e canais sem a necessidade de usar comandos de linha de comando).

O Navigator exibe os componentes instalados na distribuição.

Inicie o Jupyter Notebook no Navigator -

Você verá a abertura do aplicativo no navegador da web no seguinte endereço - http://localhost:8888.

Você provavelmente deseja começar fazendo um novo caderno. Você pode fazer isso facilmente clicando no "botão Novo" na "guia Arquivos". Você vê que tem a opção de criar um arquivo de texto normal, uma pasta e um terminal. Por último, você também verá a opção de fazer um bloco de notas Python 3.

Um novo caderno sem título com o .ipynbextensão (significa bloco de notas IPython) é exibida na nova guia do navegador.

matplotlib.pyploté uma coleção de funções de estilo de comando que fazem o Matplotlib funcionar como o MATLAB. Cada função Pyplot faz alguma alteração em uma figura. Por exemplo, uma função cria uma figura, uma área de plotagem em uma figura, plota algumas linhas em uma área de plotagem, decora a plotagem com rótulos, etc.

Tipos de parcelas

Sr. Não	Descrição da função
1	Bar Faça um gráfico de barras.
2	Barh Faça um gráfico de barra horizontal.
3	Boxplot Faça um gráfico de caixa e bigode.
4	Hist Trace um histograma.
5	hist2d Faça um gráfico de histograma 2D.
6	Pie Faça um gráfico de pizza.
7	Plot Plote linhas e / ou marcadores para os eixos.
8	Polar Faça um gráfico polar ..
9	Scatter Faça um gráfico de dispersão de x vs y.
10	Stackplot Desenha um gráfico de área empilhado.
11	Stem Crie um gráfico de haste.
12	Step Faça um gráfico de etapas.
13	Quiver Trace um campo 2-D de flechas.

Funções de imagem

Sr. Não	Descrição da função
1	Imread Leia uma imagem de um arquivo em um array.
2	Imsave Salve um array como um arquivo de imagem.
3	Imshow Exibe uma imagem nos eixos.

Funções de eixo

Sr. Não	Descrição da função
1	Axes Adicione eixos à figura.
2	Text Adicione texto aos eixos.
3	Title Defina um título dos eixos atuais.
4	Xlabel Defina o rótulo do eixo x do eixo atual.
5	Xlim Obtenha ou defina os limites x dos eixos atuais.
6	Xscale .
7	Xticks Obtenha ou defina os limites x dos locais e rótulos atuais dos ticks.
8	Ylabel Defina o rótulo do eixo y do eixo atual.
9	Ylim Obtenha ou defina os limites y dos eixos atuais.
10	Yscale Defina a escala do eixo y.
11	Yticks Obtenha ou defina os limites y dos locais e rótulos atuais dos ticks.

Funções de figura

Sr. Não	Descrição da função
1	Figtext Adicione texto à figura.
2	Figure Cria uma nova figura.
3	Show Mostre uma figura.
4	Savefig Salve a figura atual.
5	Close Feche uma janela de figura.

Neste capítulo, aprenderemos como criar um gráfico simples com Matplotlib.

Devemos agora exibir um gráfico de linha simples de ângulo em radianos vs. seu valor de seno em Matplotlib. Para começar, o módulo Pyplot do pacote Matplotlib é importado, com um alias plt por uma questão de convenção.

import matplotlib.pyplot as plt

Em seguida, precisamos de uma matriz de números para traçar. Várias funções de array são definidas na biblioteca NumPy que é importada com o alias np.

import numpy as np

Agora obtemos o objeto ndarray de ângulos entre 0 e 2π usando a função arange () da biblioteca NumPy.

x = np.arange(0, math.pi*2, 0.05)

O objeto ndarray serve como valores no eixo x do gráfico. Os valores de seno correspondentes dos ângulos em x a serem exibidos no eixo y são obtidos pela seguinte declaração -

y = np.sin(x)

Os valores de duas matrizes são plotados usando a função plot ().

plt.plot(x,y)

Você pode definir o título do gráfico e os rótulos dos eixos xey.

You can set the plot title, and labels for x and y axes.
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')

A janela do visualizador de Plot é chamada pela função show () -

plt.show()

O programa completo é o seguinte -

from matplotlib import pyplot as plt
import numpy as np
import math #needed for definition of pi
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
plt.plot(x,y)
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')
plt.show()

Quando a linha de código acima é executada, o seguinte gráfico é exibido -

Agora, use o notebook Jupyter com Matplotlib.

Inicie o bloco de notas Jupyter a partir do navegador Anaconda ou da linha de comando conforme descrito anteriormente. Na célula de entrada, insira declarações de importação para Pyplot e NumPy -

from matplotlib import pyplot as plt
import numpy as np

Para exibir as saídas do gráfico dentro do próprio notebook (e não no visualizador separado), insira a seguinte declaração mágica -

%matplotlib inline

Obtenha x como o objeto ndarray contendo ângulos em radianos entre 0 e 2π ey como o valor do seno de cada ângulo -

import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)

Defina rótulos para os eixos xey, bem como o título do gráfico -

plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')

Finalmente execute a função plot () para gerar a exibição da onda senoidal no notebook (não há necessidade de executar a função show ()) -

plt.plot(x,y)

Após a execução da linha final do código, a seguinte saída é exibida -

PyLab é uma interface procedural para a biblioteca de plotagem orientada a objetos Matplotlib. Matplotlib é o pacote completo; matplotlib.pyplot é um módulo em Matplotlib; e o PyLab é um módulo que é instalado junto com o Matplotlib.

PyLab é um módulo de conveniência que importa em massa matplotlib.pyplot (para plotagem) e NumPy (para matemática e trabalho com matrizes) em um único namespace. Embora muitos exemplos usem PyLab, ele não é mais recomendado.

Plotagem Básica

A plotagem de curvas é feita com o comando plot. É necessário um par de matrizes (ou sequências) do mesmo comprimento -

from numpy import *
from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y)
show()

A linha de código acima gera a seguinte saída -

Para plotar símbolos em vez de linhas, forneça um argumento de string adicional.

símbolos	-, -, -.,,. ,,, o, ^, v, <,>, s, +, x, D, d, 1, 2, 3, 4, h, H, p, \| , _
cores	b, g, r, c, m, y, k, w

Agora, considere executar o seguinte código -

from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y, 'r.')
show()

Ele plota os pontos vermelhos conforme mostrado abaixo -

Os gráficos podem ser sobrepostos. Basta usar os vários comandos de plotagem. Use clf () para limpar o gráfico.

from pylab import *
plot(x, sin(x))
plot(x, cos(x), 'r-')
plot(x, -sin(x), 'g--')
show()

A linha de código acima gera a seguinte saída -

Embora seja fácil gerar gráficos rapidamente com o matplotlib.pyplotmódulo, o uso de abordagem orientada a objetos é recomendado, pois dá mais controle e personalização de seus gráficos. A maioria das funções também estão disponíveis nomatplotlib.axes.Axes classe.

A ideia principal por trás do uso do método orientado a objetos mais formal é criar objetos de figura e, em seguida, apenas chamar métodos ou atributos desse objeto. Essa abordagem ajuda melhor a lidar com uma tela que contém vários gráficos.

Na interface orientada a objetos, Pyplot é usado apenas para algumas funções, como criação de figura, e o usuário cria explicitamente e mantém o controle da figura e dos objetos de eixo. Neste nível, o usuário utiliza o Pyplot para criar figuras, e através dessas figuras, um ou mais objetos de eixos podem ser criados. Esses objetos de eixos são então usados para a maioria das ações de plotagem.

Para começar, criamos uma instância de figura que fornece uma tela vazia.

fig = plt.figure()

Agora adicione eixos à figura. oadd_axes()método requer um objeto de lista de 4 elementos correspondentes à esquerda, parte inferior, largura e altura da figura. Cada número deve estar entre 0 e 1 -

ax=fig.add_axes([0,0,1,1])

Defina rótulos para os eixos xey, bem como para o título -

ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')

Invoque o método plot () do objeto de eixos.

ax.plot(x,y)

Se você estiver usando o notebook Jupyter, a diretiva inline% matplotlib deve ser emitida; a função otherwistshow () do módulo pyplot exibe o gráfico.

Considere executar o seguinte código -

from matplotlib import pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.plot(x,y)
ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')
plt.show()

Resultado

A linha de código acima gera a seguinte saída -

O mesmo código quando executado no notebook Jupyter mostra a saída conforme mostrado abaixo -

o matplotlib.figuremódulo contém a classe Figure. É um contêiner de nível superior para todos os elementos do gráfico. O objeto Figura é instanciado chamando ofigure() função do módulo pyplot -

fig = plt.figure()

A tabela a seguir mostra os parâmetros adicionais -

Figsize	(largura, altura) tupla em polegadas
Dpi	Pontos por polegada
Facecolor	Figura patch facecolor
Edgecolor	Figura patch cor da borda
Espessura da linha	Largura da linha da borda

O objeto Axes é a região da imagem com o espaço de dados. Uma determinada figura pode conter muitos eixos, mas um determinado objeto Axes só pode estar em uma figura. Os eixos contém dois (ou três, no caso de 3D) objetos de eixo. A classe Axes e suas funções de membro são o principal ponto de entrada para trabalhar com a interface OO.

O objeto Axes é adicionado à figura chamando o método add_axes (). Ele retorna o objeto de eixos e adiciona eixos na posição rect [esquerda, parte inferior, largura, altura] onde todas as quantidades estão em frações da largura e altura da figura.

Parâmetro

A seguir está o parâmetro para a classe Axes -

rect - uma sequência de 4 comprimentos de quantidades [esquerda, inferior, largura, altura].

ax=fig.add_axes([0,0,1,1])

As seguintes funções-membro da classe de eixos adicionam diferentes elementos ao gráfico -

lenda

o legend()o método da classe de eixos adiciona uma legenda à figura do gráfico. Leva três parâmetros -

ax.legend(handles, labels, loc)

Onde labels é uma sequência de strings e lida com uma sequência de instâncias Line2D ou Patch. loc pode ser uma string ou um inteiro especificando a localização da legenda.

String de localização	Código de localização
Melhor	0
canto superior direito	1
superior esquerdo	2
inferior esquerdo	3
inferior direito	4
Direito	5
Centro esquerdo	6
Centro à direita	7
centro inferior	8
centro superior	9
Centro	10

axes.plot ()

Este é o método básico da classe de eixos que plota valores de uma matriz versus outra como linhas ou marcadores. O método plot () pode ter um argumento de string de formato opcional para especificar a cor, o estilo e o tamanho da linha e do marcador.

Códigos de cores

Personagem	Cor
'b'	Azul
'g'	Verde
'r'	Vermelho
'b'	Azul
'c'	Ciano
'm'	Magenta
'você'	Amarelo
'k'	Preto
'b'	Azul
'W'	Branco

Códigos marcadores

Personagem	Descrição
'.'	Marcador de ponto
'o'	Marcador de círculo
'x'	Marcador X
'D'	Marcador de diamante
'H'	Marcador hexágono
's'	Marcador quadrado
'+'	Marcador positivo

Estilos de linha

Personagem	Descrição
'-'	Linha sólida
'-'	Linha tracejada
'-.'	Linha traço-ponto
':'	Linha pontilhada
'H'	Marcador hexágono

O exemplo a seguir mostra as despesas de publicidade e os números de vendas de TV e smartphone na forma de gráficos de linha. A linha que representa a TV é uma linha sólida com a cor amarela e marcadores quadrados, enquanto a linha do smartphone é uma linha tracejada com a cor verde e um marcador circular.

import matplotlib.pyplot as plt
y = [1, 4, 9, 16, 25,36,49, 64]
x1 = [1, 16, 30, 42,55, 68, 77,88]
x2 = [1,6,12,18,28, 40, 52, 65]
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
l1 = ax.plot(x1,y,'ys-') # solid line with yellow colour and square marker
l2 = ax.plot(x2,y,'go--') # dash line with green colour and circle marker
ax.legend(labels = ('tv', 'Smartphone'), loc = 'lower right') # legend placed at lower right
ax.set_title("Advertisement effect on sales")
ax.set_xlabel('medium')
ax.set_ylabel('sales')
plt.show()

Quando a linha de código acima é executada, ela produz o seguinte gráfico -

Neste capítulo, aprenderemos como criar vários subtramas na mesma tela.

o subplot()função retorna o objeto de eixos em uma determinada posição da grade. A assinatura de chamada desta função é -

plt.subplot(subplot(nrows, ncols, index)

Na figura atual, a função cria e retorna um objeto Axes, no índice de posição de uma grade de nrows por ncolsaxes. Os índices vão de 1 a nrows * ncols, incrementando na ordem da linha principal. Se nrows, ncols e índice são todos menores que 10. Os índices também podem ser fornecidos como um único, concatenado, número de três dígitos.

Por exemplo, a subtrama (2, 3, 3) e a subtrama (233) criam um eixo no canto superior direito da figura atual, ocupando metade da altura da figura e um terço da largura da figura.

A criação de uma subtrama excluirá qualquer subtrama pré-existente que se sobrepõe a ela, além de compartilhar um limite.

import matplotlib.pyplot as plt
# plot a line, implicitly creating a subplot(111)
plt.plot([1,2,3])
# now create a subplot which represents the top plot of a grid with 2 rows and 1 column.
#Since this subplot will overlap the first, the plot (and its axes) previously 
created, will be removed
plt.subplot(211)
plt.plot(range(12))
plt.subplot(212, facecolor='y') # creates 2nd subplot with yellow background
plt.plot(range(12))

A linha de código acima gera a seguinte saída -

A função add_subplot () da classe de figura não sobrescreverá o gráfico existente -

import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.plot([1,2,3])
ax2 = fig.add_subplot(221, facecolor='y')
ax2.plot([1,2,3])

Quando a linha de código acima é executada, ela gera a seguinte saída -

Você pode adicionar um gráfico de inserção na mesma figura, adicionando outro objeto de eixos na mesma tela de figura.

import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig=plt.figure()
axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
axes2 = fig.add_axes([0.55, 0.55, 0.3, 0.3]) # inset axes
y = np.sin(x)
axes1.plot(x, y, 'b')
axes2.plot(x,np.cos(x),'r')
axes1.set_title('sine')
axes2.set_title("cosine")
plt.show()

Após a execução da linha de código acima, a seguinte saída é gerada -

A API Matplotlib'spyplot tem uma função de conveniência chamada subplots () que atua como um wrapper de utilitário e ajuda a criar layouts comuns de subplots, incluindo o objeto de figura envolvente, em uma única chamada.

Plt.subplots(nrows, ncols)

Os dois argumentos inteiros para esta função especificam o número de linhas e colunas da grade do subplot. A função retorna um objeto de figura e uma tupla contendo objetos de eixos iguais a nrows * ncols. Cada objeto de eixos é acessível por seu índice. Aqui, criamos um subplot de 2 linhas por 2 colunas e exibimos 4 gráficos diferentes em cada subplot.

import matplotlib.pyplot as plt
fig,a =  plt.subplots(2,2)
import numpy as np
x = np.arange(1,5)
a[0][0].plot(x,x*x)
a[0][0].set_title('square')
a[0][1].plot(x,np.sqrt(x))
a[0][1].set_title('square root')
a[1][0].plot(x,np.exp(x))
a[1][0].set_title('exp')
a[1][1].plot(x,np.log10(x))
a[1][1].set_title('log')
plt.show()

A linha de código acima gera a seguinte saída -

Esta função oferece mais flexibilidade na criação de um objeto de eixos em um local específico da grade. Também permite que o objeto de eixos seja estendido por várias linhas ou colunas.

Plt.subplot2grid(shape, location, rowspan, colspan)

No exemplo a seguir, uma grade 3X3 do objeto de figura é preenchida com objetos de eixos de tamanhos variados em linhas e colunas, cada um mostrando um gráfico diferente.

import matplotlib.pyplot as plt
a1 = plt.subplot2grid((3,3),(0,0),colspan = 2)
a2 = plt.subplot2grid((3,3),(0,2), rowspan = 3)
a3 = plt.subplot2grid((3,3),(1,0),rowspan = 2, colspan = 2)
import numpy as np
x = np.arange(1,10)
a2.plot(x, x*x)
a2.set_title('square')
a1.plot(x, np.exp(x))
a1.set_title('exp')
a3.plot(x, np.log(x))
a3.set_title('log')
plt.tight_layout()
plt.show()

Após a execução do código de linha acima, a seguinte saída é gerada -

A função grid () do objeto de eixos define a visibilidade da grade dentro da figura como ligada ou desligada. Você também pode exibir os tiques principais / secundários (ou ambos) da grade. Além disso, as propriedades de cor, estilo de linha e largura de linha podem ser definidas na função grid ().

import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1,3, figsize = (12,4))
x = np.arange(1,11)
axes[0].plot(x, x**3, 'g',lw=2)
axes[0].grid(True)
axes[0].set_title('default grid')
axes[1].plot(x, np.exp(x), 'r')
axes[1].grid(color='b', ls = '-.', lw = 0.25)
axes[1].set_title('custom grid')
axes[2].plot(x,x)
axes[2].set_title('no grid')
fig.tight_layout()
plt.show()

Às vezes, um ou alguns pontos são muito maiores do que a maioria dos dados. Nesse caso, a escala de um eixo precisa ser definida como logarítmica, em vez da escala normal. Esta é a escala logarítmica. No Matplotlib, é possível definindo a propriedade xscale ou vscale do objeto de eixos como 'log'.

Às vezes, também é necessário mostrar alguma distância adicional entre os números dos eixos e o rótulo do eixo. A propriedade do rótulo de qualquer eixo (x ou y ou ambos) pode ser definida para o valor desejado.

Ambos os recursos acima são demonstrados com a ajuda do exemplo a seguir. A subtrama à direita tem uma escala logarítmica e uma à esquerda tem seu eixo x com rótulo a mais distância.

import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1, 2, figsize=(10,4))
x = np.arange(1,5)
axes[0].plot( x, np.exp(x))
axes[0].plot(x,x**2)
axes[0].set_title("Normal scale")
axes[1].plot (x, np.exp(x))
axes[1].plot(x, x**2)
axes[1].set_yscale("log")
axes[1].set_title("Logarithmic scale (y)")
axes[0].set_xlabel("x axis")
axes[0].set_ylabel("y axis")
axes[0].xaxis.labelpad = 10
axes[1].set_xlabel("x axis")
axes[1].set_ylabel("y axis")
plt.show()

As espinhas do eixo são as linhas que conectam as marcas dos eixos que demarcam os limites da área de plotagem. O objeto de eixos possui espinhos localizados na parte superior, inferior, esquerda e direita.

Cada lombada pode ser formatada especificando-se a cor e a largura. Qualquer aresta pode ficar invisível se sua cor for definida como nenhuma.

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.spines['bottom'].set_color('blue')
ax.spines['left'].set_color('red')
ax.spines['left'].set_linewidth(2)
ax.spines['right'].set_color(None)
ax.spines['top'].set_color(None)
ax.plot([1,2,3,4,5])
plt.show()

Matplotlib chega automaticamente aos valores mínimo e máximo das variáveis a serem exibidas ao longo dos eixos x, y (e z no caso de gráfico 3D) de um gráfico. No entanto, é possível definir os limites explicitamente usandoset_xlim() e set_ylim() funções.

No gráfico a seguir, os limites de escalonamento automático dos eixos xey são mostrados -

import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x))
a1.set_title('exp')
plt.show()

Agora formataremos os limites do eixo x para (0 a 10) ey (0 a 10000) -

import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x),'r')
a1.set_title('exp')
a1.set_ylim(0,10000)
a1.set_xlim(0,10)
plt.show()

Carrapatos são os marcadores que denotam pontos de dados nos eixos. O Matplotlib até agora - em todos os nossos exemplos anteriores - assumiu automaticamente a tarefa de espaçar os pontos no eixo. Os localizadores e formatadores de ticks padrão do Matplotlib são projetados para serem geralmente suficientes em muitas situações comuns. A posição e os rótulos dos carrapatos podem ser mencionados explicitamente para atender a requisitos específicos.

o xticks() e yticks()função recebe um objeto de lista como argumento. Os elementos na lista denotam as posições na ação correspondente onde os tiques serão exibidos.

ax.set_xticks([2,4,6,8,10])

Este método marcará os pontos de dados nas posições fornecidas com marcações.

Da mesma forma, os rótulos correspondentes às marcas de escala podem ser definidos por set_xlabels() e set_ylabels() funções respectivamente.

ax.set_xlabels([‘two’, ‘four’,’six’, ‘eight’, ‘ten’])

Isso exibirá os rótulos de texto abaixo dos marcadores no eixo x.

O exemplo a seguir demonstra o uso de marcas e rótulos.

import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
y = np.sin(x)
ax.plot(x, y)
ax.set_xlabel(‘angle’)
ax.set_title('sine')
ax.set_xticks([0,2,4,6])
ax.set_xticklabels(['zero','two','four','six'])
ax.set_yticks([-1,0,1])
plt.show()

É considerado útil ter eixos duais x ou y em uma figura. Mais ainda, ao traçar curvas com unidades diferentes juntas. Matplotlib suporta isso com as funções twinx e twiny.

No exemplo a seguir, o gráfico tem eixos y duplos, um mostrando exp (x) e o outro mostrando log (x) -

import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
x = np.arange(1,11)
a1.plot(x,np.exp(x))
a1.set_ylabel('exp')
a2 = a1.twinx()
a2.plot(x, np.log(x),'ro-')
a2.set_ylabel('log')
fig.legend(labels = ('exp','log'),loc='upper left')
plt.show()

Um gráfico de barras ou gráfico de barras é um gráfico ou gráfico que apresenta dados categóricos com barras retangulares com alturas ou comprimentos proporcionais aos valores que representam. As barras podem ser traçadas verticalmente ou horizontalmente.

Um gráfico de barras mostra comparações entre categorias discretas. Um eixo do gráfico mostra as categorias específicas sendo comparadas e o outro eixo representa um valor medido.

API Matplotlib fornece o bar()função que pode ser usada no estilo MATLAB, bem como API orientada a objetos. A assinatura da função bar () a ser usada com o objeto de eixos é a seguinte -

ax.bar(x, height, width, bottom, align)

A função faz um gráfico de barra com o retângulo limitado de tamanho (x −width = 2; x + largura = 2; parte inferior; parte inferior + altura).

Os parâmetros da função são -

x	sequência de escalares que representam as coordenadas x das barras. alinhe os controles se x for o centro da barra (padrão) ou a borda esquerda.
altura	escalar ou sequência de escalares representando a (s) altura (s) das barras.
largura	escalar ou semelhante a matriz, opcional. a (s) largura (s) das barras padrão 0,8
inferior	escalar ou semelhante a matriz, opcional. a (s) coordenada (s) y das barras padrão Nenhum.
alinhar	{'center', 'edge'}, opcional, padrão 'center'

A função retorna um objeto contêiner Matplotlib com todas as barras.

A seguir está um exemplo simples do gráfico de barra Matplotlib. Mostra o número de alunos matriculados em vários cursos oferecidos em um instituto.

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.bar(langs,students)
plt.show()

Ao comparar várias quantidades e ao alterar uma variável, podemos querer um gráfico de barras onde temos barras de uma cor para um valor de quantidade.

Podemos plotar vários gráficos de barras brincando com a espessura e as posições das barras. A variável de dados contém três séries de quatro valores. O script a seguir mostrará três gráficos de quatro barras. As barras terão espessura de 0,25 unidades. Cada gráfico de barras será deslocado 0,25 unidades do anterior. O objeto de dados é um multidito contendo o número de alunos aprovados em três ramos de uma faculdade de engenharia nos últimos quatro anos.

import numpy as np
import matplotlib.pyplot as plt
data = [[30, 25, 50, 20],
[40, 23, 51, 17],
[35, 22, 45, 19]]
X = np.arange(4)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(X + 0.00, data[0], color = 'b', width = 0.25)
ax.bar(X + 0.25, data[1], color = 'g', width = 0.25)
ax.bar(X + 0.50, data[2], color = 'r', width = 0.25)

O gráfico de barras empilhadas empilha barras que representam grupos diferentes uns sobre os outros. A altura da barra resultante mostra o resultado combinado dos grupos.

O parâmetro opcional inferior do pyplot.bar()função permite que você especifique um valor inicial para uma barra. Em vez de ir de zero a um valor, ele irá do fundo ao valor. A primeira chamada para pyplot.bar () plota as barras azuis. A segunda chamada para pyplot.bar () plota as barras vermelhas, com a parte inferior das barras azuis no topo das barras vermelhas.

import numpy as np
import matplotlib.pyplot as plt
N = 5
menMeans = (20, 35, 30, 35, 27)
womenMeans = (25, 32, 34, 20, 25)
ind = np.arange(N) # the x locations for the groups
width = 0.35
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(ind, menMeans, width, color='r')
ax.bar(ind, womenMeans, width,bottom=menMeans, color='b')
ax.set_ylabel('Scores')
ax.set_title('Scores by group and gender')
ax.set_xticks(ind, ('G1', 'G2', 'G3', 'G4', 'G5'))
ax.set_yticks(np.arange(0, 81, 10))
ax.legend(labels=['Men', 'Women'])
plt.show()

Um histograma é uma representação precisa da distribuição de dados numéricos. É uma estimativa da distribuição de probabilidade de uma variável contínua. É uma espécie de gráfico de barras.

Para construir um histograma, siga estas etapas -

Bin o intervalo de valores.
Divida todo o intervalo de valores em uma série de intervalos.
Conte quantos valores caem em cada intervalo.

Os bins são geralmente especificados como intervalos consecutivos e não sobrepostos de uma variável.

o matplotlib.pyplot.hist()função plota um histograma. Ele calcula e desenha o histograma de x.

Parâmetros

A tabela a seguir lista os parâmetros para um histograma -

x	array ou sequência de arrays
caixas	inteiro ou sequência ou 'auto', opcional
parâmetros opcionais
alcance	A faixa inferior e superior das caixas.
densidade	Se for Verdadeiro, o primeiro elemento da tupla de retorno será a contagem normalizada para formar uma densidade de probabilidade
cumulativo	Se True, então um histograma é calculado onde cada caixa fornece as contagens naquele bin mais todas as caixas para valores menores.
tipo de história	O tipo de histograma a ser desenhado. O padrão é 'bar' 'bar' é um histograma tradicional do tipo barra. Se vários dados forem fornecidos, as barras serão organizadas lado a lado. 'barstacked' é um histograma do tipo barra em que vários dados são empilhados uns sobre os outros. 'step' gera um gráfico de linha que por padrão não é preenchido. 'stepfilled' gera um gráfico de linha que é preenchido por padrão.

O exemplo a seguir plota um histograma de notas obtidas pelos alunos em uma classe. Quatro compartimentos, 0-25, 26-50, 51-75 e 76-100 são definidos. O histograma mostra o número de alunos que estão nessa faixa.

from matplotlib import pyplot as plt
import numpy as np
fig,ax = plt.subplots(1,1)
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
ax.hist(a, bins = [0,25,50,75,100])
ax.set_title("histogram of result")
ax.set_xticks([0,25,50,75,100])
ax.set_xlabel('marks')
ax.set_ylabel('no. of students')
plt.show()

O gráfico aparece como mostrado abaixo -

Um gráfico de pizza só pode exibir uma série de dados. Os gráficos de pizza mostram o tamanho dos itens (chamados de cunha) em uma série de dados, proporcional à soma dos itens. Os pontos de dados em um gráfico de pizza são mostrados como uma porcentagem de toda a pizza.

API Matplotlib tem um pie()função que gera um diagrama de pizza que representa os dados em uma matriz. A área fracionária de cada cunha é dada porx/sum(x). Se sum (x) <1, então os valores de x fornecem a área fracionária diretamente e a matriz não será normalizada. A torta resultante terá uma fatia vazia de tamanho 1 - soma (x).

O gráfico de pizza parece melhor se a figura e os eixos forem quadrados ou se o aspecto dos eixos for igual.

Parâmetros

A tabela a seguir lista os parâmetros para um gráfico de pizza -

x	como matriz. Os tamanhos de cunha.
rótulos	Lista. Uma sequência de strings que fornece os rótulos para cada cunha.
Cores	Uma sequência de matplotlibcolorargs através dos quais o gráfico de pizza percorrerá. Se nenhum, usará as cores no ciclo atualmente ativo.
Autopct	string, usada para rotular as fatias com seu valor numérico. A etiqueta será colocada dentro da cunha. A string de formato será fmt% pct.

O código a seguir usa a função pie () para exibir o gráfico de pizza da lista de alunos matriculados em vários cursos de informática. A porcentagem proporcional é exibida dentro da respectiva cunha com a ajuda deautopct parâmetro definido para% 1.2f%.

from matplotlib import pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.axis('equal')
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.pie(students, labels = langs,autopct='%1.2f%%')
plt.show()

Gráficos de dispersão são usados para plotar pontos de dados nos eixos horizontal e vertical na tentativa de mostrar o quanto uma variável é afetada por outra. Cada linha na tabela de dados é representada por um marcador, a posição depende de seus valores nas colunas definidas nos eixos X e Y. Uma terceira variável pode ser definida para corresponder à cor ou tamanho dos marcadores, adicionando assim outra dimensão ao gráfico.

O script abaixo representa um diagrama de dispersão da faixa de notas vs notas de meninos e meninas em duas cores diferentes.

import matplotlib.pyplot as plt
girls_grades = [89, 90, 70, 89, 100, 80, 90, 100, 80, 34]
boys_grades = [30, 29, 49, 48, 100, 48, 38, 45, 20, 30]
grades_range = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
fig=plt.figure()
ax=fig.add_axes([0,0,1,1])
ax.scatter(grades_range, girls_grades, color='r')
ax.scatter(grades_range, boys_grades, color='b')
ax.set_xlabel('Grades Range')
ax.set_ylabel('Grades Scored')
ax.set_title('scatter plot')
plt.show()

Os gráficos de contorno (às vezes chamados de gráficos de nível) são uma maneira de mostrar uma superfície tridimensional em um plano bidimensional. Ele representa graficamente duas variáveis preditoras XY no eixo y e uma variável de resposta Z como contornos. Esses contornos são às vezes chamados de fatias z ou valores de iso-resposta.

Um gráfico de contorno é apropriado se você quiser ver como o valor Z muda em função de duas entradas X e Y, de modo que Z = f (X, Y). Uma linha de contorno ou isolinha de uma função de duas variáveis é uma curva ao longo da qual a função tem um valor constante.

As variáveis independentes xey são geralmente restritas a uma grade regular chamada meshgrid. O numpy.meshgrid cria uma grade retangular a partir de uma matriz de valores xe uma matriz de valores y.

A API Matplotlib contém funções contour () e contourf () que desenham linhas de contorno e contornos preenchidos, respectivamente. Ambas as funções precisam de três parâmetros x, y e z.

import numpy as np
import matplotlib.pyplot as plt
xlist = np.linspace(-3.0, 3.0, 100)
ylist = np.linspace(-3.0, 3.0, 100)
X, Y = np.meshgrid(xlist, ylist)
Z = np.sqrt(X**2 + Y**2)
fig,ax=plt.subplots(1,1)
cp = ax.contourf(X, Y, Z)
fig.colorbar(cp) # Add a colorbar to a plot
ax.set_title('Filled Contours Plot')
#ax.set_xlabel('x (cm)')
ax.set_ylabel('y (cm)')
plt.show()

Um gráfico de quiver exibe os vetores de velocidade como setas com componentes (u, v) nos pontos (x, y).

quiver(x,y,u,v)

O comando acima plota vetores como setas nas coordenadas especificadas em cada par correspondente de elementos em xe y.

Parâmetros

A tabela a seguir lista os diferentes parâmetros para o gráfico Quiver -

x	Matriz 1D ou 2D, sequência. As coordenadas x das localizações das setas
y	Matriz 1D ou 2D, sequência. As coordenadas y das localizações das setas
você	Matriz 1D ou 2D, sequência. Os x componentes dos vetores de seta
v	Matriz 1D ou 2D, sequência. Os componentes y dos vetores de seta
c	Matriz 1D ou 2D, sequência. As cores das setas

O código a seguir desenha um gráfico simples de quiver -

import matplotlib.pyplot as plt
import numpy as np
x,y = np.meshgrid(np.arange(-2, 2, .2), np.arange(-2, 2, .25))
z = x*np.exp(-x**2 - y**2)
v, u = np.gradient(z, .2, .2)
fig, ax = plt.subplots()
q = ax.quiver(x,y,u,v)
plt.show()

Um gráfico de caixa, também conhecido como gráfico de bigode, exibe um resumo de um conjunto de dados contendo o mínimo, o primeiro quartil, a mediana, o terceiro quartil e o máximo. Em um gráfico de caixa, desenhamos uma caixa do primeiro quartil ao terceiro quartil. Uma linha vertical atravessa a caixa na mediana. Os bigodes vão de cada quartil para o mínimo ou máximo.

Vamos criar os dados para os boxplots. Nós usamos onumpy.random.normal()função para criar os dados falsos. Leva três argumentos, média e desvio padrão da distribuição normal e o número de valores desejados.

np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)

A lista de arrays que criamos acima é a única entrada necessária para criar o boxplot. Usando odata_to_plot linha de código, podemos criar o boxplot com o seguinte código -

fig = plt.figure()
# Create an axes instance
ax = fig.add_axes([0,0,1,1])
# Create the boxplot
bp = ax.boxplot(data_to_plot)
plt.show()

A linha de código acima irá gerar a seguinte saída -

Os gráficos de violino são semelhantes aos gráficos de caixa, exceto que também mostram a densidade de probabilidade dos dados em valores diferentes. Esses gráficos incluem um marcador para a mediana dos dados e uma caixa indicando o intervalo interquartil, como nos gráficos de caixa padrão. Sobreposto a este gráfico de caixa está uma estimativa da densidade do kernel. Como os gráficos de caixa, os gráficos de violino são usados para representar a comparação de uma distribuição de variável (ou distribuição de amostra) em diferentes "categorias".

Um enredo de violino é mais informativo do que um enredo de caixa simples. Na verdade, enquanto um gráfico de caixa mostra apenas estatísticas resumidas, como média / mediana e intervalos interquartis, o gráfico de violino mostra a distribuição completa dos dados.

import matplotlib.pyplot as plt

np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)

## combine these different collections into a list
data_to_plot = [collectn_1, collectn_2, collectn_3, collectn_4]

# Create a figure instance
fig = plt.figure()

# Create an axes instance
ax = fig.add_axes([0,0,1,1])

# Create the boxplot
bp = ax.violinplot(data_to_plot)
plt.show()

Embora o Matplotlib tenha sido projetado inicialmente com apenas plotagem bidimensional em mente, alguns utilitários de plotagem tridimensional foram construídos sobre a exibição bidimensional do Matplotlib em versões posteriores, para fornecer um conjunto de ferramentas para visualização de dados tridimensionais. Os gráficos tridimensionais são habilitados importando omplot3d toolkit, incluído no pacote Matplotlib.

Os eixos tridimensionais podem ser criados passando a palavra-chave projection = '3d' para qualquer uma das rotinas normais de criação de eixos.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
ax.plot3D(x, y, z, 'gray')
ax.set_title('3D line plot')
plt.show()

Agora podemos plotar uma variedade de tipos de plotagem tridimensional. O gráfico tridimensional mais básico é um3D line plotcriado a partir de conjuntos de (x, y, z) triplos. Isso pode ser criado usando a função ax.plot3D.

3D scatter plot é gerado usando o ax.scatter3D função.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
c = x + y
ax.scatter(x, y, z, c=c)
ax.set_title('3d Scatter plot')
plt.show()

o ax.contour3D()função cria plotagem de contorno tridimensional. Requer que todos os dados de entrada estejam na forma de grades regulares bidimensionais, com os dados Z avaliados em cada ponto. Aqui, mostraremos um diagrama de contorno tridimensional de uma função sinusoidal tridimensional.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
   return np.sin(np.sqrt(x ** 2 + y ** 2))
	
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
ax.set_title('3D contour')
plt.show()

O gráfico de estrutura de arame pega uma grade de valores e a projeta na superfície tridimensional especificada, e pode tornar as formas tridimensionais resultantes muito fáceis de visualizar. oplot_wireframe() função é usada para o propósito -

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
   return np.sin(np.sqrt(x ** 2 + y ** 2))
	
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_wireframe(X, Y, Z, color='black')
ax.set_title('wireframe')
plt.show()

A linha de código acima irá gerar a seguinte saída -

O gráfico de superfície mostra uma relação funcional entre uma variável dependente designada (Y) e duas variáveis independentes (X e Z). A trama é uma trama que acompanha a trama de contorno. Uma plotagem de superfície é como uma plotagem de wireframe, mas cada face da wireframe é um polígono preenchido. Isso pode ajudar na percepção da topologia da superfície visualizada. oplot_surface() função x, y e z como argumentos.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
x = np.outer(np.linspace(-2, 2, 30), np.ones(30))
y = x.copy().T # transpose
z = np.cos(x ** 2 + y ** 2)

fig = plt.figure()
ax = plt.axes(projection='3d')

ax.plot_surface(x, y, z,cmap='viridis', edgecolor='none')
ax.set_title('Surface plot')
plt.show()

A linha de código acima irá gerar a seguinte saída -

Matplotlib tem amplo suporte de texto, incluindo suporte para expressões matemáticas, TrueTypesuporte para saídas raster e vetoriais, texto separado por nova linha com rotações arbitrárias e suporte a Unicode. Matplotlib inclui seu próprio matplotlib.font_manager que implementa uma plataforma cruzada, algoritmo de localização de fontes compatível com W3C.

O usuário tem muito controle sobre as propriedades do texto (tamanho e peso da fonte, localização e cor do texto, etc.). Matplotlib implementa um grande número de símbolos e comandos matemáticos do TeX.

A lista de comandos a seguir é usada para criar texto na interface Pyplot -

texto	Adicione texto em uma localização arbitrária dos eixos.
anotar	Adicione uma anotação, com uma seta opcional, em um local arbitrário dos Eixos.
xlabel	Adicione um rótulo ao eixo x dos eixos.
Ylabel	Adicione um rótulo ao eixo y dos eixos.
título	Adicione um título aos eixos.
figtext	Adicione texto em um local arbitrário da Figura.
Suptitle	Adicione um título à Figura.

Todas essas funções criam e retornam um matplotlib.text.Text() instância.

Os scripts a seguir demonstram o uso de algumas das funções acima -

import matplotlib.pyplot as plt
fig = plt.figure()

ax = fig.add_axes([0,0,1,1])

ax.set_title('axes title')
ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')
ax.text(3, 8, 'boxed italics text in data coords', style='italic', 
bbox = {'facecolor': 'red'})
ax.text(2, 6, r'an equation: $E = mc^2$', fontsize = 15)
ax.text(4, 0.05, 'colored text in axes coords',
verticalalignment = 'bottom', color = 'green', fontsize = 15)
ax.plot([2], [1], 'o')
ax.annotate('annotate', xy = (2, 1), xytext = (3, 4),
arrowprops = dict(facecolor = 'black', shrink = 0.05))
ax.axis([0, 10, 0, 10])
plt.show()

A linha de código acima irá gerar a seguinte saída -

Você pode usar um subconjunto TeXmarkup em qualquer string de texto Matplotlib colocando-o dentro de um par de cifrões ($).

# math text
plt.title(r'$\alpha > \beta$')

Para fazer subscritos e sobrescritos, use os símbolos '_' e '^' -

r'$\alpha_i> \beta_i$'

import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 2.0, 0.01)
s = np.sin(2*np.pi*t)

plt.plot(t,s)
plt.title(r'$\alpha_i> \beta_i$', fontsize=20)

plt.text(0.6, 0.6, r'$\mathcal{A}\mathrm{sin}(2 \omega t)$', fontsize = 20)
plt.text(0.1, -0.5, r'$\sqrt{2}$', fontsize=10)
plt.xlabel('time (s)')
plt.ylabel('volts (mV)')
plt.show()

A linha de código acima irá gerar a seguinte saída -

O módulo de imagem no pacote Matplotlib fornece funcionalidades necessárias para carregar, redimensionar e exibir a imagem.

O carregamento de dados de imagem é suportado pela biblioteca Pillow. Nativamente, Matplotlib suporta apenas imagens PNG. Os comandos mostrados abaixo recaem no Pillow se a leitura nativa falhar.

A imagem usada neste exemplo é um arquivo PNG, mas mantenha esse requisito de travesseiro em mente para seus próprios dados. oimread() função é usada para ler dados de imagem em um ndarray objeto do tipo float32.

import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
img = mpimg.imread('mtplogo.png')

Supondo que a seguinte imagem nomeada como mtplogo.png está presente no diretório de trabalho atual.

Qualquer array contendo dados de imagem pode ser salvo em um arquivo de disco executando o imsave()função. Aqui, uma versão invertida verticalmente do arquivo png original é salva, dando o parâmetro de origem inferior.

plt.imsave("logo.png", img, cmap = 'gray', origin = 'lower')

A nova imagem aparece como abaixo, se aberta em qualquer visualizador de imagens.

Para desenhar a imagem no visualizador Matplotlib, execute o imshow() função.

imgplot = plt.imshow(img)

O pacote matplotlib é construído em cima de uma estrutura de transformação para mover facilmente entre sistemas de coordenadas. Quatro sistemas de coordenadas podem ser usados. Os sistemas são descritos resumidamente na tabela abaixo -

Coordenada	Objeto de Transformação	Descrição
Dados	ax.transData	O sistema de coordenadas dos dados do terreno do usuário. controlado pelo xlim e ylim
Eixos	ax.transAxes	O sistema de coordenadas dos eixos. (0,0) é a parte inferior esquerda e (1,1) é a parte superior direita dos eixos.
Figura	fig.transFigure	O sistema de coordenadas da Figura. (0,0) é a parte inferior esquerda e (1,1) é a parte superior direita da figura
exibição	Nenhum	Este é o sistema de coordenadas de pixel da tela. (0,0) é a parte inferior esquerda e (largura, altura) é a parte superior direita da exibição em pixels. Como alternativa, (matplotlib.transforms.IdentityTransform ()) pode ser usado em vez de None.

Considere o seguinte exemplo -

axes.text(x,y,"my label")

O texto é colocado na posição teórica de um ponto de dados (x, y). Assim, falaríamos de "dados coords".

Usando outros objetos de transformação, o posicionamento pode ser controlado. Por exemplo, se o teste acima deve ser colocado no centro do sistema de coordenadas dos eixos, execute a seguinte linha de código -

axes.text(0.5, 0.5, "middle of graph", transform=axes.transAxes)

Essas transformações podem ser usadas para qualquer tipo de objeto Matplotlib. A transformação padrão paraax.text é ax.transData e a transformação padrão para fig.text é fig.transFigure.

O sistema de coordenadas dos eixos é extremamente útil ao colocar texto em seus eixos. Muitas vezes, você pode querer um balão de texto em um local fixo; por exemplo, no canto superior esquerdo do painel de eixos e manter essa localização fixa ao aplicar panorâmica ou zoom.