Pyplot tutorial

Uma introdução à interface pyplot. Consulte também o Guia de início rápido para obter uma visão geral de como o Matplotlib funciona e as Interfaces de aplicativo (APIs) do Matplotlib para obter uma explicação das vantagens e desvantagens entre as APIs de usuário suportadas.

Introdução ao pyplot

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

Em matplotlib.pyplotvários estados são preservados nas chamadas de função, para que ele acompanhe coisas como a figura atual e a área de plotagem, e as funções de plotagem são direcionadas para os eixos atuais (observe que "eixos" aqui e na maioria dos lugares na documentação referem-se à parte dos eixos de uma figura e não o termo matemático estrito para mais de um eixo).

Observação

a API pyplot implícita geralmente é menos detalhada, mas também não é tão flexível quanto a API explícita. A maioria das chamadas de função que você vê aqui também podem ser chamadas como métodos de um Axesobjeto. Recomendamos navegar pelos tutoriais e exemplos para ver como isso funciona. Consulte Interfaces de aplicativo (APIs) do Matplotlib para obter uma explicação sobre a compensação das APIs de usuário com suporte.

Gerar visualizações com pyplot é muito rápido:

import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()

Você pode estar se perguntando por que o eixo x varia de 0 a 3 e o eixo y de 1 a 4. Se você fornecer uma única lista ou array para plot, matplotlib assume que é uma sequência de valores y e gera automaticamente os valores x para você. Como os intervalos do python começam com 0, o vetor x padrão tem o mesmo comprimento que y, mas começa com 0. Portanto, os dados x são .[0, 1, 2, 3]

ploté uma função versátil e terá um número arbitrário de argumentos. Por exemplo, para plotar x versus y, você pode escrever:

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])

[<matplotlib.lines.Line2D object at 0x7f2cf9d23b20>]

Formatando o estilo do seu gráfico

Para cada par de argumentos x, y, existe um terceiro argumento opcional que é a string de formato que indica a cor e o tipo de linha do gráfico. As letras e símbolos da string de formato são do MATLAB, e você concatena uma string colorida com uma string de estilo de linha. A string de formato padrão é 'b-', que é uma linha azul sólida. Por exemplo, para plotar o acima com círculos vermelhos, você emitiria

plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis([0, 6, 0, 20])
plt.show()

Consulte a plotdocumentação para obter uma lista completa de estilos de linha e strings de formato. A axisfunção no exemplo acima pega uma lista e especifica a viewport dos eixos.[xmin, xmax, ymin, ymax]

Se matplotlib fosse limitado a trabalhar com listas, seria bastante inútil para processamento numérico. Geralmente, você usará arrays numpy . Na verdade, todas as sequências são convertidas internamente em matrizes numpy. O exemplo abaixo ilustra a plotagem de várias linhas com diferentes estilos de formato em uma chamada de função usando matrizes.

import numpy as np

# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)

# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

Plotando com strings de palavra-chave

Existem algumas instâncias em que você tem dados em um formato que permite acessar variáveis ​​específicas com strings. Por exemplo, com numpy.recarrayou pandas.DataFrame.

Matplotlib permite que você forneça tal objeto com o dataargumento de palavra-chave. Se fornecido, você pode gerar gráficos com as strings correspondentes a essas variáveis.

data = {'a': np.arange(50),
        'c': np.random.randint(0, 50, 50),
        'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100

plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()

Plotando com variáveis ​​categóricas

Também é possível criar um gráfico usando variáveis ​​categóricas. Matplotlib permite que você passe variáveis ​​categóricas diretamente para muitas funções de plotagem. Por exemplo:

names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]

plt.figure(figsize=(9, 3))

plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

Propriedades da linha de controle

As linhas têm muitos atributos que você pode definir: largura de linha, estilo de traço, antialiased, etc; ver matplotlib.lines.Line2D. Existem várias maneiras de definir as propriedades da linha

• Use argumentos de palavra-chave:

  plt.plot(x, y, linewidth=2.0)
  

• Use os métodos setter de uma Line2Dinstância. plotretorna uma lista de Line2Dobjetos; por exemplo, . No código abaixo vamos supor que temos apenas uma linha para que a lista retornada seja de comprimento 1. Usamos tuple unpacking with para obter o primeiro elemento dessa lista:line1, line2 = plot(x1, y1, x2, y2)line,

  line, = plt.plot(x, y, '-')
  line.set_antialiased(False) # turn off antialiasing
  

• Use setp. O exemplo abaixo usa uma função de estilo MATLAB para definir várias propriedades em uma lista de linhas. setpfunciona de forma transparente com uma lista de objetos ou um único objeto. Você pode usar argumentos de palavra-chave python ou pares de string/valor no estilo MATLAB:

  lines = plt.plot(x1, y1, x2, y2)
  # use keyword arguments
  plt.setp(lines, color='r', linewidth=2.0)
  # or MATLAB style string value pairs
  plt.setp(lines, 'color', 'r', 'linewidth', 2.0)
  

Aqui estão as Line2Dpropriedades disponíveis.

Propriedade	Tipo de valor
alfa	flutuador
animado	[Verdadeiro | Falso]
antialiased ou aa	[Verdadeiro | Falso]
clip_box	uma instância matplotlib.transform.Bbox
grampear	[Verdadeiro | Falso]
clip_path	uma instância Path e uma instância Transform, um Patch
cor ou c	qualquer cor matplotlib
contém	a função de teste de clique
traço_capstyle	[ 'butt'| 'round'| 'projecting']
dash_joinstyle	[ 'miter'| 'round'| 'bevel']
traços	sequência de ligar/desligar a tinta em pontos
dados	(np.array xdata, np.array ydata)
figura	uma instância matplotlib.figure.Figure
etiqueta	qualquer string
estilo de linha ou ls	[ '-'| '--'| '-.'| ':'| 'steps'| ...]
largura de linha ou lw	valor flutuante em pontos
marcador	[ '+'| ','| '.'| '1'| '2'| '3'| '4']
marcadoredgecolor ou mec	qualquer cor matplotlib
marcadoredgewidth ou mew	valor flutuante em pontos
marcadorfacecolor ou mfc	qualquer cor matplotlib
tamanho do marcador ou ms	flutuador
markevery	[ Nenhum | inteiro | (começar, andar)]
selecionador	usado na seleção de linha interativa
pickradius	o raio de seleção de seleção de linha
solid_capstyle	[ 'butt'| 'round'| 'projecting']
solid_joinstyle	[ 'miter'| 'round'| 'bevel']
transformar	uma instância matplotlib.transforms.Transform
visível	[Verdadeiro | Falso]
xdata	np.array
ydata	np.array
zorder	qualquer número

Para obter uma lista de propriedades de linha configuráveis, chame a setpfunção com uma linha ou linhas como argumento

In [69]: lines = plt.plot([1, 2, 3])

In [70]: plt.setp(lines)
  alpha: float
  animated: [True | False]
  antialiased or aa: [True | False]
  ...snip

Trabalhando com várias figuras e eixos

MATLAB e pyplot, têm o conceito de figura atual e os eixos atuais. Todas as funções de plotagem se aplicam aos eixos atuais. A função gcaretorna os eixos atuais (uma matplotlib.axes.Axesinstância) e gcfretorna a figura atual (uma matplotlib.figure.Figureinstância). Normalmente, você não precisa se preocupar com isso, porque tudo é resolvido nos bastidores. Abaixo está um script para criar duas subtramas.

def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

plt.figure()
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()

A figurechamada aqui é opcional porque uma figura será criada se não existir, assim como um Axes será criado (equivalente a uma subplot()chamada explícita) se não existir. A subplotchamada especifica onde varia de 1 a . As vírgulas na chamada são opcionais se . Então é idêntico a .numrows, numcols, plot_numberplot_numbernumrows*numcolssubplotnumrows*numcols<10subplot(211)subplot(2, 1, 1)

Você pode criar um número arbitrário de subparcelas e eixos. Se você deseja colocar um eixo manualmente, ou seja, não em uma grade retangular, use axes, que permite especificar o local onde todos os valores estão em coordenadas fracionárias (0 a 1). Veja Axes Demo para um exemplo de como colocar os eixos manualmente e Multiple subplots para um exemplo com muitos subplots.axes([left, bottom, width, height])

Você pode criar várias figuras usando várias figurechamadas com um número de figura crescente. Claro, cada figura pode conter quantos eixos e subtramas desejar:

import matplotlib.pyplot as plt
plt.figure(1)                # the first figure
plt.subplot(211)             # the first subplot in the first figure
plt.plot([1, 2, 3])
plt.subplot(212)             # the second subplot in the first figure
plt.plot([4, 5, 6])


plt.figure(2)                # a second figure
plt.plot([4, 5, 6])          # creates a subplot() by default

plt.figure(1)                # figure 1 current; subplot(212) still current
plt.subplot(211)             # make subplot(211) in figure1 current
plt.title('Easy as 1, 2, 3') # subplot 211 title

Você pode limpar a figura atual com clf e os eixos atuais com cla. Se você achar irritante que os estados (especificamente a imagem, figura e eixos atuais) estejam sendo mantidos para você nos bastidores, não se desespere: este é apenas um fino wrapper de estado em torno de uma API orientada a objetos, que você pode usar em vez disso (veja o tutorial do Artista )

Se você estiver fazendo muitas figuras, precisa estar ciente de mais uma coisa: a memória necessária para uma figura não é totalmente liberada até que a figura seja explicitamente fechada com close. Excluir todas as referências à figura e/ou usar o gerenciador de janelas para matar a janela em que a figura aparece na tela não é suficiente, porque o pyplot mantém as referências internas até close ser chamado.

Trabalhando com o texto

textpodem ser usados ​​para adicionar texto em um local arbitrário e xlabel, ylabele titlesão usados ​​para adicionar texto nos locais indicados (consulte Text in Matplotlib Plots para obter um exemplo mais detalhado)

mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 50, density=True, facecolor='g', alpha=0.75)


plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()

Todas as textfunções retornam uma matplotlib.text.Text instância. Assim como nas linhas acima, você pode personalizar as propriedades passando argumentos de palavras-chave para as funções de texto ou usando setp:

t = plt.xlabel('my data', fontsize=14, color='red')

Essas propriedades são abordadas com mais detalhes em Propriedades e layout do texto .

Usando expressões matemáticas no texto

matplotlib aceita expressões de equação TeX em qualquer expressão de texto. Por exemplo, para escrever a expressão\(\sigma_i=15\)no título, você pode escrever uma expressão TeX cercada por cifrões:

plt.title(r'$\sigma_i=15$')

O rprecedente da string do título é importante - significa que a string é uma string bruta e não deve tratar as barras invertidas como escapes de python. O matplotlib possui um analisador de expressão TeX integrado e um mecanismo de layout, além de fornecer suas próprias fontes matemáticas -- para obter detalhes, consulte Escrevendo expressões matemáticas . Assim, você pode usar texto matemático em várias plataformas sem exigir uma instalação do TeX. Para aqueles que têm o LaTeX e o dvipng instalados, você também pode usar o LaTeX para formatar seu texto e incorporar a saída diretamente em suas figuras de exibição ou postscript salvo -- consulte Renderização de texto com LaTeX .

Anotando o texto

Os usos da textfunção básica acima colocam o texto em uma posição arbitrária nos eixos. Um uso comum para o texto é anotar algum recurso do gráfico, e o annotatemétodo fornece funcionalidade auxiliar para facilitar as anotações. Em uma anotação, há dois pontos a serem considerados: o local que está sendo anotado representado pelo argumento xye o local do texto xytext. Ambos os argumentos são tuplas.(x, y)

ax = plt.subplot()

t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2*np.pi*t)
line, = plt.plot(t, s, lw=2)

plt.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
             arrowprops=dict(facecolor='black', shrink=0.05),
             )

plt.ylim(-2, 2)
plt.show()

Neste exemplo básico, tanto a xy(ponta da seta) quanto as xytext localizações (localização do texto) estão em coordenadas de dados. Há uma variedade de outros sistemas de coordenadas que podem ser escolhidos -- consulte Anotação básica e Anotações avançadas para obter detalhes. Mais exemplos podem ser encontrados em Annotating Plots .

Eixos logarítmicos e outros não lineares

matplotlib.pyplotsuporta não apenas escalas de eixo linear, mas também escalas logarítmicas e logit. Isso é comumente usado se os dados abrangem muitas ordens de magnitude. Alterar a escala de um eixo é fácil:

plt.xscale('log')

Um exemplo de quatro gráficos com os mesmos dados e escalas diferentes para o eixo y é mostrado abaixo.

# Fixing random state for reproducibility
np.random.seed(19680801)

# make up some data in the open interval (0, 1)
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))

# plot with various axes scales
plt.figure()

# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)

# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)

# symmetric log
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthresh=0.01)
plt.title('symlog')
plt.grid(True)

# logit
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
# Adjust the subplot layout, because the logit one may take more space
# than usual, due to y-tick labels like "1 - 10^{-3}"
plt.subplots_adjust(top=0.92, bottom=0.08, left=0.10, right=0.95, hspace=0.25,
                    wspace=0.35)

plt.show()

Também é possível adicionar sua própria escala, veja matplotlib.scalepara mais detalhes.