<jupyter_start><jupyter_text>Matplotlib  Introdução O Matplotlib é a biblioteca mais antiga de visualização de dados com o Python. Foi criado por <NAME>. Ele o criou para tentar replicar os recursos de plotagem do MatLab (outra linguagem de programação) no Python.É uma excelente biblioteca de gráficos 2D e 3D para gerar figuras científicas.Alguns dos principais profissionais do Matplotlib são:* Para gráficos simples* Suporte para etiquetas e textos personalizados* Ótimo controle de todos os elementos de uma figura* Saída de alta qualidade em muitos formatos* Muito personalizável em geralO Matplotlib permite criar figuras reproduzíveis programaticamente. Vamos aprender como usá-lo! Antes de continuar esta palestra, encorajo você a apenas explorar a página oficial do Matplotlib: http://matplotlib.org/ InstalaçãoVocê precisará instalar o matplotlib primeiro com:    conda install matplotlibou    pip install matplotlib     Importando<jupyter_code>import matplotlib.pyplot as plt<jupyter_output><empty_output><jupyter_text>Você também precisará usar esta linha para ver gráficos no notebook:<jupyter_code>%matplotlib inline<jupyter_output><empty_output><jupyter_text>Essa linha é apenas para notebooks jupyter, se você estiver usando outro editor, você usará: ** plt.show () ** no final de todos os seus comandos de plotagem para que a figura apareça em outra janela.  ExemploVamos percorrer um exemplo muito simples usando duas matrizes numpy.**Os dados que queremos plotar:**<jupyter_code>import numpy as np
x = np.linspace(0, 5, 11)
y = x ** 2
x
y<jupyter_output><empty_output><jupyter_text>Comandos básicos do MatplotlibPodemos criar um gráfico de linhas muito simples usando o seguinte (incentivo você a pausar e usar Shift + Tab ao longo do caminho para verificar as seqüências de caracteres do documento para as funções que estamos usando).<jupyter_code>plt.plot(x, y, 'r') # 'r' é a cor vermelha
plt.xlabel('X Axis Title Here')
plt.ylabel('Y Axis Title Here')
plt.title('String Title Here')
plt.show()<jupyter_output><empty_output><jupyter_text>Criando multiplots na mesma tela<jupyter_code># plt.subplot(nlinha, ncoluna, plot_number)
plt.subplot(1,2,1)
plt.plot(x, y, 'r--') # More on color options later
plt.subplot(1,2,2)
plt.plot(y, x, 'g*-');<jupyter_output><empty_output><jupyter_text>Matplotlib Object Oriented MethodAgora que vimos o básico, vamos detalhar tudo com uma introdução mais formal da API orientada a objetos do Matplotlib. Isso significa que iremos instanciar objetos de figura e, em seguida, chamaremos métodos ou atributos desse objeto.  Introdução ao método orientado a objetos A idéia principal do uso do método Orientado a Objetos, mais formal, é criar objetos de figura e depois chamar métodos ou atributos desse objeto. Essa abordagem é melhor quando se lida com uma tela com várias plotagens.Para começar, criamos uma instância de figura. Em seguida, podemos adicionar eixos a essa figura:<jupyter_code># Criar figura (vazia)
fig = plt.figure()

# Adicione um conjunto de eixos à figura

axes = fig.add_axes([0.1, 0.1, 0.8, 0.8])   # esquerda, inferior, largura, altura (faixa de 0 a 1)


# Traçar nesse conjunto de eixos
axes.plot(x, y, 'b')
axes.set_xlabel('Set X Label') # Observe o uso de set_ para iniciar métodos
axes.set_ylabel('Set y Label')
axes.set_title('Set Title')<jupyter_output><empty_output><jupyter_text>O código é um pouco mais complicado, mas a vantagem é que agora temos controle total de onde os eixos de plotagem são colocados e podemos adicionar facilmente mais de um eixo à figura:<jupyter_code># Cria figura vazia
fig = plt.figure()

axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # eixo principal
axes2 = fig.add_axes([0.2, 0.5, 0.4, 0.3]) # adiciona eixo

#  Figura maior no eixo 1
axes1.plot(x, y, 'b')
axes1.set_xlabel('X_label_axes2')
axes1.set_ylabel('Y_label_axes2')
axes1.set_title('Axes 2 Title')

# Figura inserida no eixo 2
axes2.plot(y, x, 'r')
axes2.set_xlabel('X_label_axes2')
axes2.set_ylabel('Y_label_axes2')
axes2.set_title('Axes 2 Title');<jupyter_output><empty_output><jupyter_text>subplots()O objeto plt.subplots () atuará como um gerenciador de eixos mais automático.Casos de uso básico:<jupyter_code>#Similar a plt.figure() 
fig, axes = plt.subplots()


# Agora use o objeto axes para adicionar itens ao gráfico
axes.plot(x, y, 'r')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');<jupyter_output><empty_output><jupyter_text>Em seguida, você pode especificar o número de linhas e colunas ao criar o objeto subplots ():<jupyter_code>#Duas figuras fazias
fig, axes = plt.subplots(nrows=1, ncols=2)

# Axes é uma matriz de eixos para plotar
axes<jupyter_output><empty_output><jupyter_text>Podemos realizar as itercões através desta matriz:<jupyter_code>for ax in axes:
    ax.plot(x, y, 'b')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_title('title')


# Exibe o objeto da figura 
fig<jupyter_output><empty_output><jupyter_text>Um problema comum com o matplolib é a sub-plotagem ou figuras sobrepostas. Podemos usar o método **fig.tight_layout ()** ou **plt.tight_layout ()**, que ajusta automaticamente as posições dos eixos na tela da figura para que não haja conteúdo sobreposto:<jupyter_code>fig, axes = plt.subplots(nrows=1, ncols=2)

for ax in axes:
    ax.plot(x, y, 'g')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_title('title')

fig    
plt.tight_layout()<jupyter_output><empty_output><jupyter_text>Tamanho da figura, proporção e DPI O Matplotlib permite que a proporção, o DPI e o tamanho da figura sejam especificados quando o objeto **figure** for criado. Você pode usar os argumentos das palavras-chave `figsize` e` dpi`.* `figsize` é uma tupla da largura e altura da figura em polegadas* `dpi` é o número de pontos por polegada (pixel por polegada).Por exemplo:<jupyter_code>fig = plt.figure(figsize=(8,4), dpi=100)<jupyter_output><empty_output><jupyter_text>Os mesmos argumentos também podem ser passados ​​para os gerenciadores de layout, como a função `subplots`:<jupyter_code>fig, axes = plt.subplots(figsize=(12,3))

axes.plot(x, y, 'r')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');<jupyter_output><empty_output><jupyter_text>Salvando figurasO Matplotlib pode gerar saída de alta qualidade em vários formatos, incluindo PNG, JPG, EPS, SVG, PGF e PDF. Para salvar uma figura em um arquivo, podemos usar o método `savefig` na classe` Figure`:<jupyter_code>fig.savefig("filename.png")<jupyter_output><empty_output><jupyter_text>Aqui também podemos opcionalmente especificar o DPI e escolher entre diferentes formatos de saída:<jupyter_code>fig.savefig("filename.png", dpi=200)<jupyter_output><empty_output><jupyter_text>Legendas, rótulos e títulos Agora que abordamos o básico de como criar um objeto figure e adicionar instâncias de eixos. Vejamos como inserir em uma figura: títulos, rótulos de eixos e legendas. **Títulos das figuras**Um título pode ser adicionado a cada instância de eixo em uma figura. Para definir o título, use o método `set_title` na instância de eixos:<jupyter_code>ax.set_title("title");<jupyter_output><empty_output><jupyter_text>**Rótutos nos eixo**Da mesma forma, com os métodos `set_xlabel` e` set_ylabel`, podemos definir os rótulos dos eixos X e Y:<jupyter_code>ax.set_xlabel("x")
ax.set_ylabel("y");<jupyter_output><empty_output><jupyter_text>Legendas Você pode usar o argumento da palavra-chave **label = "label text"** quando gráficos ou outros objetos são adicionados à figura e, em seguida, usar o método **legend** sem argumentos para adicionar a legenda à figura:<jupyter_code>fig = plt.figure()

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

ax.plot(x, x**2, label="x**2")
ax.plot(x, x**3, label="x**3")
ax.legend()<jupyter_output><empty_output><jupyter_text>Observe como as legendas se sobrepõem!A função **legend** usa um argumento opcional de palavra-chave **loc** que pode ser usado para especificar onde na figura a legenda deve ser desenhada. Os valores permitidos de **loc** são códigos numéricos para os vários locais em que a legenda pode ser desenhada. Consulte a [página da documentação] (http://matplotlib.org/users/legend_guide.htmllegend-location) para obter detalhes. Alguns dos valores **loc** mais comuns são:<jupyter_code># Muitas opções ....

ax.legend(loc=1) # canto superior direito
ax.legend(loc=2) # canto superior esquerdo
ax.legend(loc=3) # Canto inferior esquerdo
ax.legend(loc=4) # Canto inferior direito


# .. muitas outras opções estão disponíveis

# Mais comum de escolher
ax.legend (loc = 0) # deixe o matplotlib decidir a localização ideal
fig<jupyter_output><empty_output><jupyter_text>Definir cores, larguras de linha, tipos de linhaO Matplotlib oferece muitas opções para personalizar cores, larguras de linha e tipos de linha.Existe a sintaxe básica do MATLAB (que eu sugiro que você evite usar por motivos mais claros:  Cores com MatLab como sintaxe Com o matplotlib, podemos definir as cores das linhas e outros elementos gráficos de várias maneiras. Primeiro, podemos usar a sintaxe semelhante ao MATLAB, onde "b" significa azul, "g" significa verde, etc. A API do MATLAB para selecionar estilos de linha também é suportada: onde, por exemplo, 'b.-' significa uma linha azul com pontos:<jupyter_code># MATLAB estilo cor e estilo da linha
fig, ax = plt.subplots()
ax.plot(x, x**2, 'b.-') # linha azul com pontos
ax.plot(x, x**3, 'g--') # linha tracejada verde<jupyter_output><empty_output><jupyter_text>Cores com o parâmetro color Também podemos definir cores por seus nomes ou códigos hexadecimais RGB e, opcionalmente, fornecer um valor alfa usando os argumentos das palavras-chave `color` e `alpha`. Alfa indica opacidade.<jupyter_code>fig, ax = plt.subplots()

ax.plot(x, x+1, color="blue", alpha=0.5) # semitransparente
ax.plot(x, x+2, color="#8B008B")        # RGB hex code
ax.plot(x, x+3, color="#FF8C00")        # RGB hex code<jupyter_output><empty_output><jupyter_text>Estilos de linha e marcador Para alterar a largura da linha, podemos usar o argumento`linewidth` ou` lw`. O estilo da linha pode ser selecionado usando os argumentos `linestyle` ou `ls`:<jupyter_code>fig, ax = plt.subplots(figsize=(12,6))

ax.plot(x, x+1, color="red", linewidth=0.25)
ax.plot(x, x+2, color="red", linewidth=0.50)
ax.plot(x, x+3, color="red", linewidth=1.00)
ax.plot(x, x+4, color="red", linewidth=2.00)


# opções possíveis de tipos de linha '-', '-.', ':', 'etapas'
ax.plot(x, x+5, color="green", lw=3, linestyle='-')
ax.plot(x, x+6, color="green", lw=3, ls='-.')
ax.plot(x, x+7, color="green", lw=3, ls=':')


# traço personalizado
line, = ax.plot(x, x+8, color="black", lw=1.50)
line.set_dashes([5, 10, 15, 10]) # formato: comprimento da linha, comprimento do espaço, ...


# símbolos possíveis de marcador: marcador = '+', 'o', '*', 's', ',', '.', '1', '2', '3', '4', ...
ax.plot(x, x+ 9, color="blue", lw=3, ls='-', marker='+')
ax.plot(x, x+10, color="blue", lw=3, ls='--', marker='o')
ax.plot(x, x+11, color="blue", lw=3, ls='-', marker='s')
ax.plot(x, x+12, color="blue", lw=3, ls='--', marker='1')

# tamanho e cor do marcador
ax.plot(x, x+13, color="purple", lw=1, ls='-', marker='o', markersize=2)
ax.plot(x, x+14, color="purple", lw=1, ls='-', marker='o', markersize=4)
ax.plot(x, x+15, color="purple", lw=1, ls='-', marker='o', markersize=8, markerfacecolor="red")
ax.plot(x, x+16, color="purple", lw=1, ls='-', marker='s', markersize=8, 
        markerfacecolor="yellow", markeredgewidth=3, markeredgecolor="green");<jupyter_output><empty_output><jupyter_text>Controle sobre a aparência do eixo Nesta seção, veremos como controlar as propriedades de dimensionamento do eixo em uma figura do matplotlib. Podemos configurar as faixas dos eixos usando os métodos `set_ylim` e `set_xlim` no objeto axis, ou `axis ('tight')` para obter automaticamente faixas de eixos "bem ajustadas":<jupyter_code>fig, axes = plt.subplots(1, 3, figsize=(12, 4))

axes[0].plot(x, x**2, x, x**3)
axes[0].set_title("default axes ranges")

axes[1].plot(x, x**2, x, x**3)
axes[1].axis('tight')
axes[1].set_title("tight axes")

axes[2].plot(x, x**2, x, x**3)
axes[2].set_ylim([0, 60])
axes[2].set_xlim([2, 5])
axes[2].set_title("custom axes range");<jupyter_output><empty_output><jupyter_text>Tipos de plotagem especiaisPodemos criar muitos gráficos especializados, como gráficos de barras, histogramas, gráficos de dispersão e muito mais. A maioria desses tipos de plotagens criaremos usando seaborn, uma biblioteca de plotagem estatística para Python. Mas aqui estão alguns exemplos desse tipo de plotagem:<jupyter_code>plt.scatter(x,y)
from random import sample
data = sample(range(1, 1000), 100)
plt.hist(data)
data = [np.random.normal(0, std, 100) for std in range(1, 4)]


# plotagem de caixa retangular
plt.boxplot(data,vert=True,patch_artist=True);<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11720581340834506, 'fraction_numerical': 0.01617440225035162, 'mean_word_length': 5.83707264957265, 'pattern_counts': {'":': 1, '<': 98, '<?xml version=': 0, '>': 98, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '24', 'dir': 'jupyter-structured-clean-dedup', 'id': '661511', 'license': 'MIT', 'n_tokens_mistral': 5085, 'n_tokens_neox': 4883, 'n_words': 1465, 'path': 'TE1/3 - Matplotlib/3.1-MatplotlibConcepts.ipynb', 'repo_name': 'EdTonatto/UFFS-2020.2-Inteligencia_Artificial', 'size': '12803'}