<jupyter_start><jupyter_text>Gráfico de dispersãoNesta aula vamos aprender como gerar um gráfico de dispersão utilizando a biblioteca ***matplotlib***Você aprenderá:- Plotar gráfico de dispersão;- Editar o gráfico;    - Alterar o tamanho do gráfico;    - Alterar tipo, tamanho, formato, cor, etc, dos marcadores;    - Adicionar legendas, nomes nos eixos e título;        - Alterar tipo a família da fonte, e também seu tamanho;- Salvar e exportar o gráfico.  Índice    - [Versões](versoes-id)- [Introdução](intro-id)- [Importações](imports-id)- [Conjunto de dados](data-id)- [Gráfico de dispersão](grafico-dispersao-id)- [Tamanho do Gráfico](tamanho-figura-id)- [Editando os pontos do gráfico](editando-pontos-id)    * [Cor do marcador](editando-cor-marcador-id)        * [Tamanho do marcador](editando-tamanho-marcador-id)    * [Tipo de marcador](editando-tipo-marcador-id)    * [Cor da linha do marcador](editando-borda-marcador-id)    * [Espessura da linha do marcador](editando-borda-espessura-marcador-id)- [Elementos de texto](elementos-texto-id)    * [Legendas](elementos-texto-legendas-id)            + [posição da legenda no gráfico](elementos-texto-legendas-posicao-id)            * [Título no eixo x](elementos-texto-titulo-x-id)        * [Título no eixo y](elementos-texto-titulo-y-id)        * [Título no gráfico](elementos-texto-titulo-grafico-id)        * [Tipos de fontes](elementos-texto-fonte-id)    * [Tamanho da fontes](elementos-texto-fonte-tamanho-id)- [Diversas séries](elementos-diversas-series-id)- [Exportando o gráfico](elementos-exportacao-id)    * [DPI's](elementos-exportacao-dpis-id)        * [Transparência](elementos-exportacao-transparencia-id)- [Exercícios Resolvidos](exericio-resolvido-id)- [Sobre](sobre-id)- [Bibliografia](citations-id) ---  Versões das bibliotecas utilizadas Python```pythonimport platformprint('Python version: ' + platform.python_version())```Python version: 3.7.3 IPython```pythonimport IPythonprint('IPython version: ' + IPython.__version__)```IPython version: 7.22.0 matplotlib```pythonimport matplotlib as mplprint('matplotlib version: ' + mpl.__version__)```matplotlib version: 3.3.4 IMPORTANTEPara uma melhor experiência de aprendizado, **rode a célula abaixo** e ***clique no link*** que irá aparecer no ***output*** da célula para esconder o código. Esta célula contém os scripts utilizados para gerar as reflexões feitas ao longo do notebook, e não tem ligação direta com o aprendizado pretendido nesta aula.🎵 You can look for answers but that ain't fun 🎵<jupyter_code>import ipywidgets as widgets
import sys
from IPython.display import HTML
from IPython.display import display as reflexao
from IPython.display import clear_output
import random

# source: https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook

def hide_toggle(for_next=False):
    this_cell = """$('div.cell.code_cell.rendered.selected')"""
    next_cell = this_cell + '.next()'

    toggle_text = 'Visualizar código / Esconder código'  # text shown on toggle link
    target_cell = this_cell  # target cell to control with toggle
    js_hide_current = ''  # bit of JS to permanently hide code in current cell (only when toggling next cell)

    if for_next:
        target_cell = next_cell
        toggle_text += ' next cell'
        js_hide_current = this_cell + '.find("div.input").hide();'

    js_f_name = 'code_toggle_{}'.format(str(random.randint(1,2**64)))

    html = """
        <script>
            function {f_name}() {{
                {cell_selector}.find('div.input').toggle();
            }}

            {js_hide_current}
        </script>

        <a href="javascript:{f_name}()">{toggle_text}</a>
    """.format(
        f_name=js_f_name,
        cell_selector=target_cell,
        js_hide_current=js_hide_current, 
        toggle_text=toggle_text
    )

    return HTML(html)

def create_multipleChoice_widget(description, options, explanation):

    
    radio_options = [(words, i) for i, words in enumerate(options)]
    alternativ = widgets.RadioButtons(
        options = radio_options,
        description = '',
        disabled = False
    )
    
    description_out = widgets.Output()
    with description_out:
        print(description)
        
    feedback_out = widgets.Output()

    def check_selection(b):
        a = int(alternativ.value)
        
        
        if "Correto! " in explanation[a]:
            first_line, second_line = '\x1b[1;30;42m' + explanation[a][:9] + "\n" , explanation[a][9:]
        elif "Incorreto! " in explanation[a]:
            first_line, second_line =  '\x1b[1;30;41m' + explanation[a][:11] + "\n" , explanation[a][11:]
            
        elif "Correto, mas fora de contexto! " in explanation[a]:
            first_line, second_line =  '\x1b[1;30;41m' + explanation[a][:31] + "\n" , explanation[a][31:]
        else:
            first_line, second_line =  'Pergunta', 'Mal formulada'
        

        with feedback_out:
            clear_output()
            print(first_line)
            print('\033[0m' + second_line)
        return
    
    check = widgets.Button(description="Enviar")
    check.on_click(check_selection)
    
    
    return widgets.VBox([description_out, alternativ, check, feedback_out])


## Reflexão 1
pergunta_1 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_1 = ['a', 'b', 'c', 'd']
explicacoes_1 = ['Correto! Está é a ordem ideal para desenhar um gráfico utilizando o matplotlib',
                'Incorreto! Apesar desta ordem gerar um gráfico, os parâmetros passados em plt.figure() não serão utilizados.',
                 'Incorreto! Apesar desta ordem gerar um gráfico, os parâmetros passados em plt.figure() não serão utilizados.',
                 'Incorreto! A parte "pyplot" esta inserida dentro do matplotlib, e não ao contrário!']
Q1 = create_multipleChoice_widget(pergunta_1, opcoes_1, explicacoes_1)


## Reflexão 2
pergunta_2 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_2 = ['a', 'b', 'c', 'd']
explicacoes_2 = ['Incorreto! Apesar de não ser a forma mais usual, esta também é uma forma de importar a parte gráfica da biblioteca matplotlib!',
                'Incorreto! Apesar do alias "cafezinho" não ter relação nenhuma com a geração de gráficos, esta forma irá importar a parte gráfica do matplotlib de forma correta!',
                 'Incorreto! Embora seja uma forma pouco eficiente (pois será necessário escrever mpl.pyplot muitas vezes), esta forma irá importar a parte gráfica do matplotlib de forma correta!',
                 'Correto! Não existe a biblioteca "pyplot"!']
Q2 = create_multipleChoice_widget(pergunta_2, opcoes_2, explicacoes_2)


## Reflexão 3
pergunta_3 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_3 = ['a', 'b', 'c', 'd']
explicacoes_3 = ['Correto! Também é possível utilizar o parâmetro color, mas a forma abreviada é mais eficiente!',
                'Incorreto! O elemento plt.scatter() não tem o parâmetro cores',
                 'Incorreto! Apesar de que tomar um café é sempre uma boa ideia, não existe o parâmetro cafézinho em plt.scatter() e em nenhuma outra biblioteca do Python, pois acentos não são aceitos em nomes de variáveis/parâmetros/classes/funções, etc, sendo permitido apenas em strings',
                 'Correto! Também é possível utilizar o parâmetro c, que é mais eficiente!']
Q3 = create_multipleChoice_widget(pergunta_3, opcoes_3, explicacoes_3)


## Reflexão 4
pergunta_4 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_4 = ['a', 'b', 'c']
explicacoes_4 = ['Correto! Podemos passsar um número inteiro ou um número decimal (float)',
                'Correto! Podemos passsar número decimal ou um número inteiro (int)',
                 'Incorreto! Apenas números podem ser utilizados para alterar o tamanho dos marcadores']
Q4 = create_multipleChoice_widget(pergunta_4, opcoes_4, explicacoes_4)


## Reflexão 5
pergunta_5 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_5 = ['a', 'b', 'c']
explicacoes_5 = ['Correto, mas fora de contexto! Existe pelo menos uma empresa com o nome Marker (Marker International), mas no contexto do matplotlib, marker é o parâmetro utilizado para alterar o marcador (ou símbolo) utilizado para os pontos de um gráfico.',
                'Correto! É através do parâmetro marker que alteramos o tipo de marcador utilizado para desenhar os pontos de um gráfico.',
                'Incorreto! O parâmtro marker é utilizado para alterar o tipo do marcador. Para alterar o tamanho do marcador, utiliza-se o parâmetro s.']
Q5 = create_multipleChoice_widget(pergunta_5, opcoes_5, explicacoes_5)


## Reflexão 6
pergunta_6 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_6 = ['a', 'b', 'c', 'd']
explicacoes_6 = ['Incorreto! O parâmetro s altera o tamanho dos marcadores.',
                'Incorreto! O plt.scatter() não tem um parâmetro edge_colors.',
                'Correto! Esta é a forma correta de alterar a cor das "bordas" de um marcador para a cor verde.',
                'Incorreto! Apesar do parâmetro utilizado estar correto, as aspas simples utilizada para passar o nome da cor não foi fechada, o que resultará em um erro.']
Q6 = create_multipleChoice_widget(pergunta_6, opcoes_6, explicacoes_6)


## Reflexão 7
pergunta_7 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_7 = ['a', 'b', 'c']
explicacoes_7 = ['Incorreto! O plt.scatter() não tem um parâmetro para ligar os pontos do gráfico. Para isto, utilizamos o plt.plot().',
                'Incorreto! O parâmetro utilizado para alterar a cor das bordas é o edgecolors.',
                'Correto! O parâmetro linewidths altera a espessura da borda dos marcadores!']
Q7 = create_multipleChoice_widget(pergunta_7, opcoes_7, explicacoes_7)


## Reflexão 8
pergunta_8 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_8 = ['a', 'b', 'c']
explicacoes_8 = ['Incorreto! Apesar de passar "none" para o parâmetro facecolors deixa o marcador aberto, mas sem adicionar bordas no marcador, ele ficará todo transparente e não será possível ver ele no gráfico.',
                'Correto! Para deixar o marcador aberto precisamos adicionar cor à borda, e remover a cor da face do marcador.',
                'Incorreto! Ao passar a string "w" para facecolors, a cor do marcador ficará branca, e não aberto.']
Q8 = create_multipleChoice_widget(pergunta_8, opcoes_8, explicacoes_8)


## Reflexão 9
pergunta_9 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_9 = ['a', 'b', 'c', 'd']
explicacoes_9 = ['Incorreto! Apesar de de que imprimir o gráfico e adicionar a legenda manualmente seja plausível, a pergunta quer saber como adicionar a legenda utilizando o matplotlib.',
                'Incorreto! Apenas adicionar o plt.legend() apenas irá criar um elemento de legenda. É necessário adicionar o nome (label) para cada elemento do gráfico.',
                'Incorreto! Apenas adicionar o label em plt.scatter não irá criar um elemento de legenda.',
                'Correto! A legenda somente será adicionada ao gráfico caso o parâmetro label seja passado em plt.scatter() e o plt.legend() for adicionado após o plt.scatter().']
Q9 = create_multipleChoice_widget(pergunta_9, opcoes_9, explicacoes_9)


## Reflexão 10
pergunta_10 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_10 = ['a', 'b', 'c']
explicacoes_10 = ['Incorreto! O parâmetro pad esta correto, mas ele deve ser passado em plt.title() ao invés de plt.xlabel()',
                'Incorreto! O parâmetro labelpad adiciona espaçamento ao título dos eixos, e não aos título do gráfico.',
                'Correto! Esta é a forma correta de adicionar espaçamento ao título de um gráfico no matplotlib']
Q10 = create_multipleChoice_widget(pergunta_10, opcoes_10, explicacoes_10)


## Reflexão 11
pergunta_11 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_11 = ['a', 'b', 'c', 'd']
explicacoes_11 = ['Incorreto! Não existe o método matplotlib.Arial()!',
                'Incorreto! Não existe o método matplotlib.Arial()!',
                'Correto! Esta é uma das formas de alterar o tipo de fonte no matplotlib!',
                'Incorreto! Apesar do comando estar correto, esta faltando fechar as aspas no final da linha.']
Q11 = create_multipleChoice_widget(pergunta_11, opcoes_11, explicacoes_11)


## Reflexão 12
pergunta_12 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_12 = ['a', 'b', 'c']
explicacoes_12 = ['Correto! Os elementos devem ser adicionados antes do plt.show().',
                'Incorreto! Desta forma, a cada sequência um novo gráfico será desenhado!',
                'Incorreto! Passar diversas séries para o parâmetro y irá levantar um erro!']
Q12 = create_multipleChoice_widget(pergunta_12, opcoes_12, explicacoes_12)


## Reflexão 13
pergunta_13 = 'Escolha a opção correta (pode existir mais de uma resposta correta)'
opcoes_13 = ['a', 'b', 'c', 'd']
explicacoes_13 = ['Incorreto! O plt.scatter() não tem o parâmetro tight!',
                'Incorreto! O plt.Figure() não tem o parâmetro tight!',
                'Incorreto! O parâmetro bbox_inches não aceita valores boleanos!',
                 'Correto! Esta é uma das formas de deixar o gráfico com espaçamento justo!']
                 
Q13 = create_multipleChoice_widget(pergunta_13, opcoes_13, explicacoes_13)

hide_toggle()<jupyter_output><empty_output><jupyter_text>IntroduçãoOs gráficos de dispersão são uma forma de representar graficamente a associação entre pares de dados (*x* e *y*). O pareamento de x e y esta relacionado a diferentes caracteristicas de um objeto.Para desenha-lo, utilizamos dados vinculados a uma observação. Por exemplo, a hora do dia e a temperatura registrada em uma hora específica. Outro exemplo, a relação entre o número de rotações de um ventilador dependendo da velocidde setada.Genericamente, temos uma variável X e uma variávle Y, que tem o mesmo tamanho. Os dados de X geralmente estão relacionados a uma medida independete, enquanto que os dados de Y estão relacionados a uma medida dependente (de X).Por exemplo, o número de rotações do ventilador é dependente (variável Y) da velocidade escolhida (varáivel X).  A temperatura ambiente (variável Y) é dependente da hora (variável X) em que a medida foi feita.Mas também podemos relacionar variáveis que não apresentam essa relação direta. Por exemplo, a umidade relativa do ar e a temperatura ambiente. Embora relacionadas, não é possível ajustar uma para medir a outra. O ***principal objetivo*** deste documento é trazer as principais **formas de edição** dos gráficos de dispersão utilizando a biblioteca [matplotlib](https://matplotlib.org/). Ela é a principal ferramenta utilizada para gerar gráficos no Python, e que permite a edição de cada detalhe do gráfico, e por isso foi escolhida.  ImportaçõesVamos começar importando a biblioteca matplotlib para o ambiente de trabalho:- *matplotlib* para desenhar/plotar os gráficos[Voltar ao topo](title-id)<jupyter_code>import matplotlib.pyplot as plt<jupyter_output><empty_output><jupyter_text>---  Conjunto de dadosFonte: www.hypescience.comPara exemplificação de como gerar gráficos de dispersão, vamos utilizar um conjunto de dados que relaciona a **altura** (em cm) com o **peso** (em kg) de diversas ***raças de cachorros***. Os valores utilizados são os *valores médios* dentro de cada raça.Os dados de **peso** foram atribuidos à variavel *x* utilizando uma *list*, e os dados da **altura** foram atribuidos à variável *y*, também utilizando uma *list*. As respectivas raças de cachorro foram amarzenadas na lista *raca_cachorro*.Os dados estão ***ordenados*** da raça mais leve para a mais pesada.Por favor, visite [esta página](https://www.dimensions.com/collection/dogs-dog-breeds) para ter acesso aos dados originais.<jupyter_code>x = [1.59, 4.53, 8.16, 10.2, 10.88, 22.68, 22.68, 30.62, 37.42, 45.36, 68.04] # peso em kilos

y = [19.05, 25.4, 26.67, 29.21, 36.83, 52.07, 54.61, 57.15, 60.96, 62.23, 67.31] # altura em em centímetros

raca_cachorro = ['Chihuahua', 'Poodle Toy', 'Pug', 'French Bulldog', 'Beagle', 'Chow Chow', '<NAME>', 
                 'Labrador Retriever', 'German Shepherd Dog', 'Rottweiler', 'Saint Bernard'] # nome da respectiva raça<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)---  Criando o gráfico de dispersãoO método utilizado para desenhar um [gráfico de dispersão no matplotlib](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html) é o método ```plt.scatter()```, que necessita de pelo menos dois parâmetros:- *x*: dados que serão utilizados no o eixo x, que devem ser uma sequência (*list*, *tuple*, *ndarray*, etc);- *y*: dados que serão utilizados no o eixo y, que devem ser uma sequência (*list*, *tuple*, *ndarray*, etc);A estrutura mínima para desenhar um gráfico de dispersão é:```pythonplt.scatter(x,y)plt.show()```Onde o```pythonplt.scatter(x,y)```é o resposável por gerar o gráfico, enquanto que ```pythonplt.show()```é o responsável por apresentar o gráfico.<jupyter_code>plt.scatter(x=x, y=y)
plt.show()<jupyter_output><empty_output><jupyter_text>Entretanto, o ```plt.show()``` não é necessário nos notebooks, pois o gráfico sempre será impresso no output da célula:<jupyter_code>plt.scatter(x=x, y=y)<jupyter_output><empty_output><jupyter_text>Mas será impressa a *representação do objeto* de gráfico criado, o que em muitas vezes não é interessante. Além disso, em diversas outras [IDE's (Ambiente Integral de Desenvolvimento)](https://en.wikipedia.org/wiki/Integrated_development_environment), como o [PyCharm](https://www.jetbrains.com/pycharm/) ou o [Atom](https://atom.io/), o gráfico não será apresentado. Por estes motivos, é recomendado sempre utilizar o ```plt.show()```. De qualquer forma, podemos editar este gráfico para que ele fique mais elegante e apresentavel. Uma das principais edições que podemos fazer é aterar o tamanho do gráfico. [Voltar ao topo](title-id)---  Tamanho do GráficoO tamanho do gráfico pode ser alterado utilizando o método ```plt.figure()```. Este método tem com função criar uma nova figura, e nele podemos alterar diversos parâmetros, como a cor de fundo do gráfico, cor das bordas, e o tamanho do gráfico.Para alterar o tamanho do gráfico, precisamos passar uma *tupla* com dois elementos para o parâmetro ```figsize()```:```plt.figure(figsize=(x, y))```- O valor de *x* corresponde ao tamanho (em polegadas) da largura do eixo *x*. - Já o valor de *y*, corresponde ao tamanho (em polegadas) da altura do eixo *y*. Por padrão, o gráfico é criado com 6.4 polegadas de largura e 4.8 polegadas de altura:```plt.figure(x,y, figsize=(6.4, 4.8))```[Documentação](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.figure.html)Para desenhar um gráfico **quadrado**, basta utilizar valores de *x* e *y* iguais:<jupyter_code>plt.figure(figsize=(8,8))
plt.scatter(x=x, y=y)
plt.show()<jupyter_output><empty_output><jupyter_text>Para desenhar um gráfico mais largo, basta utilizar um valor de *x* **maior** do que o valor de *y*:<jupyter_code>plt.figure(figsize=(12,6))
plt.scatter(x=x, y=y)
plt.show()<jupyter_output><empty_output><jupyter_text>E para desenhar um gráfico mais alto, basta utilizar um valor de *x* **menor** do que o valor de *y*:<jupyter_code>plt.figure(figsize=(6,12))
plt.scatter(x=x, y=y)
plt.show()<jupyter_output><empty_output><jupyter_text>Observe a ordem em que os elementos foram adicionados:```pythonplt.figure(figsize=(6,12))plt.scatter(x=x, y=y)plt.show()```Inicialmente, criamos a figura, depois desenhamos os pontos, e por fim apresentamos o gráfico. A ideia é simular o desenho de um quadro, onde incialmente conseguimos a tela de desenho (ou *canvas*), depois *pintamos* o quadro (adicionamos os elementos), e por fim *apresentamos o quadro* para outras pessoas (exportamos o gráfico).Esta estrutura vai ***sempre se repetir*** (não apenas em um gráfico de dispersão, mas em todos os tipos de gráficos que vamos aprender ao longo deste curso), sendo adicionado mais elementos entre ***criar o canvas*** e ***apresentar a figura***. Vamos ver as principais formas de editar um gráfico. ---  Momento para reflexão***Qual ordem correta para gerar um gráfico de dispersão no matplotlib?***.a) criar canvas, adicionar elementos, apresentar o gráficob) adicionar elementos, criar canvas, apresentar o gráficoc) adicionar elementos,  apresentar o gráfico, criar canvasd) criar o canvas,  tomar um cafézinho, apresentar o gráfico<jupyter_code>reflexao(Q1)<jupyter_output><empty_output><jupyter_text>***Qual opção não irá importar a parte gráfica da biblioteca matplotlib?***a) from matplotlib import pyplot as pltb) import matplotlib.pyplot as cafezinhoc) import matplotlib as mpld) import pyplot.matplotlib as plt<jupyter_code>reflexao(Q2)<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)---  Editando os pontos do gráficoAs edições dos pontos do gráfico são feitas através de alguns parâmetros passados no comando onde é criado o gráfico (neste caso, o ```plt.scatter()```).As principais edições geralmente feitas são:- [Alterar cor do marcador](editando-cor-marcador-id);- [Alterar o tamanho do marcador](editando-tamanho-marcador-id);- [Alterar o tipo de marcador](editando-tipo-marcador-id);- [Alterar a cor da linha do marcador](editando-borda-marcador-id);- [Alterar a espessura da linha do marcador](editando-borda-espessura-marcador-id);- [Alterar a cor de preenchimento do marcador](editando-cor-preenchimento-marcador-id);  Alterando a cor do marcadorAdicionar cores em um gráfico é uma das formas mais eficientes para expressar o que o gráfico deve representar. Para alterar a cor dos marcadores, devemos passar o parâmetro ```color``` ou apenas ```c```, para o ```plt.scatter()```. Este parâmetro deve receber o nome da cor em formato de *string*.Por exemplo, para deixar os pontos do gráfico preenchidos na cor preta, devemos utilizar:```python...plt.scatter(x, y, c="black")...```<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x=x, y=y, color="black")
plt.show()<jupyter_output><empty_output><jupyter_text>De forma análoga, mas utilizando a abreviação ```c = "black"```:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x=x, y=y, c="black")
plt.show()<jupyter_output><empty_output><jupyter_text>Através deste parâmetro (```c``` ou ```color```) passamos uma *string* que represente o nome da cor desejada. Para as cores primárias (abaixo), também temos opção de utilizar uma abreviação do nome da cor.- b (azul);- g (verde);- r (vermelho);- c (ciano);- m (magenta);- y (amarelo);- k (preto);- w (branco);Exemplo: marcadores na cor magenta.<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x=x, y=y, c="m")
plt.show()<jupyter_output><empty_output><jupyter_text>Também podemos passar uma sequência (*list*, *tuple*, *ndarray*, etc) com diversas cores para alterar cada ponto do gráfico. Cada elemento desse array deve conter uma *string* com o nome da cor desejada para cada ponto. O tamanho deste array deve coincidir com o número de pontos do gráfico.Por exemplo, dado esta sequência de cores:<jupyter_code>cores = ['k', 'k', 'b', 'b', 'y', 'y', 'm', 'r', 'r', 'g', 'g']<jupyter_output><empty_output><jupyter_text>Podemos alterar a cor de cada ponto, pois o tamanho da lista ```cores``` é o mesmo da lista ```x```<jupyter_code>len(cores) == len(x)
plt.figure(figsize=(8,6))
plt.scatter(x=x, y=y, c=cores)
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Qual é o parâmetro utilizado para alterar a cor dos marcadores ao gerar um elemento de plt.scatter()?***a) c;b) cores;c) cafézinho;d) color;<jupyter_code>reflexao(Q3)<jupyter_output><empty_output><jupyter_text>Você encontra uma lista com todas as cores disponíveis [neste link aqui](https://matplotlib.org/stable/gallery/color/named_colors.html) [Voltar ao topo](title-id)    ---  Alterando o tamanho do marcadorO parâmetro que deve ser passado para alterar o tamanho dos marcadores é o parâmetro ```s```, que deve receber um número inteiro (*int*) ou decimal (*float*), sendo que valor o padrão é 20.Por exemplo, para deixar os macadores menores (do que o padrão):<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = 10) 
plt.show()<jupyter_output><empty_output><jupyter_text>Observação:Observe que na célula acima, os valores de x e y foram passados diretamante para o ```plt.scatter()```. Antes, era feito desta forma:```pythonplt.scatter(x=x, y=y)```E agora foi feito desta forma:```pythonplt.scatter(x, y)```A segunda forma é mais eficiente, mas resulta no mesmo valor. Mas observe que isto funciona pois estou passando os valores de *x* e *y* na ordem esperada pelo ```plt.scatter()```. Caso fosse feito desta forma:```pythonplt.scatter(y, x)```Os valores de *y* seriam utilizados no eixo x, e os valores de x seriam utilizados no eixo *y*. Mas a forma abaixo estaria correta, pois estou efetivamente falando qual parâmetro esta sendo alterado.```pythonplt.scatter(y=y, x=x)```  Para deixar os macadores maiores (do que o padrão):<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = 100.1) 
plt.show()<jupyter_output><empty_output><jupyter_text>Também pode passar uma sequência (*list*, *tuple*, *ndarray*, etc) para o parâmetro ```s```, onde cada elemento deve ser um número correspondente ao tamanho do marcador.Este array deve ter o mesmo tamanho que o número de pontos do gráfico.Por exemplo, a lista ```tamanhos```:<jupyter_code>tamanhos = [40, 40, 50, 50, 60, 10, 10, 100, 100, 150, 150]
plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = tamanhos) 
plt.show()<jupyter_output><empty_output><jupyter_text>Observe que a lista ```tamanhos``` e ```x``` tem o mesmo número de elementos:<jupyter_code>len(tamanhos) == len(x)<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Qual é o tipo de variável que deve ser passado através do parâmetro s para o plt.scatter() para alterar o tamanho do marcador?***a) int;b) float;c) string;<jupyter_code>reflexao(Q4)<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)    ---  Alterando o tipo de marcadorPara alterar o tipo do marcador utilizamos o parâmetro ```marker```, que deve receber uma *string* contendo o símbolo desejado ou um número inteiro (*int*) da lista de referências de marcadores.Os marcadores mais utilizados são:- " . " (ponto);- " o " (circulo);- " v " (triângulo para cima);- " s " (quadrado);- "\ * " (estrela);- " D " (diamante);- " + " (mais);Na Figura abaixo você pode visualizar todos os marcadores disponíveis:O script utilizado para desenhar o gráfico acima pode ser acessado [neste link](https://github.com/andersonmdcanteli/matplotlib-course/blob/main/auxiliary-scripts/matplotlib-all-markers/matplotlib-all-markers.ipynb).[Documentação](https://matplotlib.org/stable/api/markers_api.html). Por exemplo, para deixar os marcadores em formato de diamante:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = 100.1, marker = "D") 
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***O que é um marker?***a) Uma empresa;b) Parâmetro utilizado para alterar o simbolo do marcador em um gráfico do matplotlibc) Parâmetro utilizado para alterar o tamanho do marcador em um gráfico do matplotlib<jupyter_code>reflexao(Q5)<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)    ---  Alterando a cor da linha do marcador (bordas do marcador)Também é possível alterar a cor das linhas (bordas) dos marcadores de forma bem simples, bastando passar o nome da cor desejada (como uma *string*) através do parâmetro ```edgecolors```. As cores seguem o mesmo padrão apresentado no item [Alterando a cor do marcador](editando-cor-marcador-id).Por exemplo, para deixar a borda na cor preta:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = 100.1, marker = "D", edgecolors = 'k') 
plt.show()<jupyter_output><empty_output><jupyter_text>Também podemos passar uma sequência de elementos (*list*, *tuple*, *ndarray*, etc) com os nomes das cores para alterar a cor da borda de cada ponto do gráfico.Utilizando a lista ```cores``` criada anteriormente:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = 100.1, marker = "D", edgecolors = cores) 
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Qual linha de comando alteraria a cor da borda de um marcador para a cor verde?***a) plt.scatter(x, y, s='g')b) plt.scatter(x, y, edge_colors='g')c) plt.scatter(x, y, edgecolors='g')d) plt.scatter(x, y, edgecolors='g)<jupyter_code>display(Q6)<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)    ---  Alterando a espessura da linha do marcador (espessura da borda)Também é possível alterar a espessura da borda dos marcadores, o que é feito passando um número inteiro (*int*) ou decimal (*float*) através do parâmetro ```linewidths```.<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = 100.1, marker = "D", edgecolors = cores, linewidths=2.5) 
plt.show()<jupyter_output><empty_output><jupyter_text>Também podemos passar uma sequência (*list*, *tuple*, etc) com diversos valores para a espessura das bordas:<jupyter_code>espessura_marcador = [1, 1.2, 1.4, 1.6, 1.8, 2, 2.2, 2.4, 2.6, 2.8, 3.0]
plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c='red', s = 100.1, marker = "D", edgecolors = cores, linewidths=espessura_marcador) 
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Qual a função do parâmetro linewidths quando passado para o plt.scatter()?***a) Adicionar uma linha entre os pontos;b) Alterar a cor da borda dos marcadores;c) Alterar a espessura da borda dos marcadores;<jupyter_code>reflexao(Q7)<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)    ---  Alterando a cor de preenchimento do marcadorÉ possível alterar a cor de dentro (interior) dos marcadores, o que é feito passando o nome da cor desejada através do parâmetro ```facecolors```. As cores seguem o mesmo padrão apresentado no item [Alterando a cor do marcador](editando-cor-marcador-id).Entretanto, não devemos passar o parâmetro ```color```, pois ele tem prioridade mais elevada no código e irá sobrescrever as cores.Por exemplo, se adicionarmos o ```facecolors='g'``` no gráfico que estamos construindo, não teremos mudanças visuais no gráfico:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, c = 'red', s = 100.1, marker = "D", edgecolors = 'k', facecolors='g') 
plt.show()<jupyter_output><empty_output><jupyter_text>Como passamos o parâmetro ```facecolors='g'```, era esperado que as cores das faces ficassem verdes, o que não aconteceu.Mas se removermos o parâmetro ```c```, obtemos a cor verde:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='g') 
plt.show()<jupyter_output><empty_output><jupyter_text>Também podemos passar uma sequência de elementos (*list*, *tuple*, *ndarray*, etc) com os nomes das cores para alterar a cor de preenchimento de cada marcador do gráfico.Utilizando a lista cores criada anteriormente:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors=cores) 
plt.show()<jupyter_output><empty_output><jupyter_text>Caso queira o marcador aberto, basta passar ```facecolors = "none"```. Observe que é ```none```, com n minusculo, e não ```None```.<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none') 
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Como deve ser passado para deixar o marcador aberto em plt.scatter?***a) plt.scatter(x,y, facecolors='none')b) plt.scatter(x,y, facecolors='none', edgecolors='k')c) plt.scatter(x,y, facecolors='w', edgecolors='k')<jupyter_code>reflexao(Q8)<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)    ---  Adicionando elementos de textoPodemos adicionar diversos elementos textuais nos gráficos de forma bem simples. Os principais são:- [Legendas](elementos-texto-legendas-id)    * [Posição da legenda no gráfico](elementos-texto-legendas-posicao-id)        * [Tamanho da fonte da legenda no gráfico](elementos-texto-legendas-tamanho-fonte-id)- [Título no eixo x](elementos-texto-titulo-x-id)- [Título no eixo y](elementos-texto-titulo-y-id)- [Título no gráfico](elementos-texto-titulo-grafico-id)- [Tipos de fontes](elementos-texto-fonte-id)- [Tamanho da fontes](elementos-texto-fonte-tamanho-id)  Adicionando legendasPara adicionar ***legendas*** em um gráfico, precismos adicionar o parâmetro ```label``` ao ```plt.scatter()``` que irá indicar qual *nome* que será inserido na legenda.Também precisamos adicionar o ```plt.legend()```, que irá efetivamente criar a legenda e adicionar ela a figura criada. Este último parâmetro deve estar posicionado após o ```plt.scatter()``` e antes de ```plt.show()```.Então, precisamos da sequinte estrutura:```pythonplt.figure() plt.scatter(label="Nome da legenda") plt.legend()plt.show() ```Por exemplo, caso for adicionado apenas o parâmetro ```label``` em ```plt.scatter()```:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.show()<jupyter_output><empty_output><jupyter_text>obtemos o gráfico sem as legendas. Mas ao adicionar o ```plt.legend()``` após o ```plt.scatter()```:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend() 
plt.show()<jupyter_output><empty_output><jupyter_text>Obtemos as legendas corretamente.Mas observe que, se o ```plt.legend()``` estiver antes de ```plt.scatter()```<jupyter_code>plt.figure(figsize=(8,6)) 
plt.legend() 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.show() 
plt.legend() 
plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.show()<jupyter_output><empty_output><jupyter_text>ou depois de ```plot.show()```<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.show() 
plt.legend()<jupyter_output><empty_output><jupyter_text>as legendas não serão inseridas. [Voltar ao topo](title-id)    ---  Posição da legenda no gráficoPodemos especificar o local em que a legenda será inserida no gráfico, o que é feito passando a **posição** desejada através do parâmetro ```loc``` em ```plt.legend()```. Esta posição pode ser definida através de uma *string* ou através de um número *int* que se refere a posição desejada. Temos 10 posições disponíveis, sendo que a ```loc='best'``` é a padrão:- 'best', que corresponde ao código 0, e a legenda é posicionada na melhor posição definida por um algoritmo (valor padrão);- 'upper right', que corresponde ao código 1, e a legenda é posicionada no canto superior direito;- 'upper left', que corresponde ao código 2, e a legenda é posicionada no canto superior esquerdo;- 'lower left', que corresponde ao código 3, e a legenda é posicionada no canto inferior esquerdo;- 'lower right', que corresponde ao código 4, e a legenda é posicionada no canto inferior direito;- 'right', que corresponde ao código 5, e a legenda é posicionada no canto direito;- 'center left', que corresponde ao código 6, e a legenda é posicionada no centro a esquerda;- 'center right', que corresponde ao código 7, e a legenda é posicionada no centro a direita;- 'lower center', que corresponde ao código 8, e a legenda é posicionada no centro inferior;- 'upper center', que corresponde ao código 9, e a legenda é posicionada no centro superior;- 'center', que corresponde ao código 10, e a legenda é posicionada no centro do gráfico;Visualmente: O notebook utilizado para desenhar a imagem acima pode ser acessado [clicando aqui](https://github.com/andersonmdcanteli/matplotlib-course/blob/main/auxiliary-scripts/matplotlib-all-legend-positions/matplotlib-legend-positions.ipynb).Por exemplo, para deixar a legenda no centro do gráfico, podemos utilizar ```loc='center'```:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend(loc = 'center') 
plt.show()<jupyter_output><empty_output><jupyter_text>ou, de forma análoga mas utilizando um número, ```loc=10```:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend(loc=10) 
plt.show()<jupyter_output><empty_output><jupyter_text>Também temos a possibilidade de **especificar a posição** da legenda de forma ***arbitrária***, o que é feito passando uma *tupla* com a posição em *x* e *y* desejada através do parâmetro ```bbox_to_anchor``` em ```plt.legend()```.Por exemplo, em x = 0 e y = 0:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend(bbox_to_anchor=(0,0)) 
plt.show()<jupyter_output><empty_output><jupyter_text>Já em  x = 1 e y = 0.5:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend(bbox_to_anchor=(1,0.5))
plt.show()<jupyter_output><empty_output><jupyter_text>E também podemos colocar a legenda para fora do gráfico:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend(bbox_to_anchor=(1.02,1)) 
plt.show()<jupyter_output><empty_output><jupyter_text>Você encontra mais detalhes sobre o posicionamento das legendas [na documentação](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html). [Voltar ao topo](title-id)    ---  Tamanho da fonte da legenda no gráficoTambém podemos alterar o tamanho da fonte da legenda diretamente em ```plt.legend()```. Basta passar um número (*int* ou *float*) para o ```plt.legend()``` através do parâmetro ```fontsize```:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend(bbox_to_anchor=(1.02,1), fontsize=20) 
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Como adicionar legenda em um gráfico de dispersão no matplotlib?***a) Imprimindo o gráfico e escrevendo com uma canetab) Adicionando o plt.legend() após a adição do plt.scatter()c) Passando o parâmetro label em plt.scatter() com o nome que será utilizado na legenda.d) combinando as respostas b e c<jupyter_code>reflexao(Q9)<jupyter_output><empty_output><jupyter_text>Adicionando título ao eixo xPara adicionar um título ao eixo *x*, utilizamos o ```plt.xlabel()```, passando como uma *string* o texto que será adicionado ao título do eixo *x*. O ```plt.xlabel()``` precisa estar posicionado antes de ```plt.show()```:```pythonplt.figure()...plt.xlabel()plt.show()```Por exemplo:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)") 
plt.show()<jupyter_output><empty_output><jupyter_text>Podemos alterar o espaçamento entre o eixo *x* e o nome do eixo x, passando um número (*float* ou *int*) através do parâmetro ```labelpad```. O valor padrão é 4.0.<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)", labelpad=20.0) 
plt.show()<jupyter_output><empty_output><jupyter_text>Ainda podemos alterar a posição do título do eixo x através do parâmetro ```loc```. Temos três opções:- 'center' (padrão): posiciona o título no centro do eixo *x*;- 'right': posiciona o título à direita do eixo *x*;- 'left': posiciona o título à esquerda do eixo *x*;Por exemplo, para deixar o título do eixo *x* no canto direito:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)", labelpad=20, loc="right")
plt.show()<jupyter_output><empty_output><jupyter_text>[Documentação](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.xlabel.html). [Voltar ao topo](title-id)    ---  Adicionando título ao eixo yPara adicionar um título ao eixo *y*, utilizamos o ```plt.ylabel()```, passando como uma *string* o texto que será adicionado ao título do eixo *y*. Assim como o ```plt.xlabel()```, o ```plt.ylabel()``` precisa esta posicionado antes de ```plt.show()```.```pythonplt.figure()...plt.ylabel()plt.show()```Por exemplo:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)") 
plt.show()<jupyter_output><empty_output><jupyter_text>Podemos alterar o espaçamento entre o eixo *y* e o titulo do eixo *y*, passando um número (*float* ou *int*) através do parâmetro ```labelpad```. O valor padrão é 4.0.<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)", labelpad=25) 
plt.show()<jupyter_output><empty_output><jupyter_text>Ainda podemos alterar a posição do título do eixo y através do parâmetro ```loc```. Temos três opções:- 'center' (padrão): posiciona o título no centro do eixo *x*;- 'bottom': posiciona o título na base do eixo *x*;- 'top': posiciona o título no topo do eixo *x*;Por exemplo, para deixar o título do eixo *x* no topo direito:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)", labelpad=25, loc='top') 
plt.show()<jupyter_output><empty_output><jupyter_text>[Documentação](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.ylabel.html). [Voltar ao topo](title-id)    ---  Adicionando título ao gráficoPara adicionar um título ao gráfico utilizamos o ```plt.title()```, passando como uma *string* o nome para o título. O ```plt.title()``` precisa esta posicionado antes de ```plt.show()```.```pythonplt.figure()...plt.title()plt.show()```Por exemplo:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)")
plt.title("Relação entre peso e altura de diversas raças de cachorro") 
plt.show()<jupyter_output><empty_output><jupyter_text>Podemos alterar o espaçamento entre o título do gráfico e o topo do gráfico, passando um número (*float* ou *int*) através do parâmetro ```labelpad```. O valor padrão é 6.0.<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)")
plt.title("Relação entre peso e altura de diversas raças de cachorro", pad=40) 
plt.show()<jupyter_output><empty_output><jupyter_text>Ainda podemos alterar a posição do título do gráfico através do parâmetro ```loc```. Temos três opções:- 'center' (padrão): posiciona o título no centro (em relação ao eixo x);- 'right': posiciona o título à direita (em relação ao eixo x);- 'left': posiciona o título à esquerda (em relação ao eixo x);Por exemplo, para deixar o título do gráfico no lado direito:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)")
plt.title("Relação entre peso e altura de diversas raças de cachorro", pad=40, loc='right') 
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Como adicionar espaçamento entre o título do gráfico e o gráfico?***a) Passando o parâmetro pad em  plt.xlabel()b) Passando o parâmetro labelpad em plt.title()c) Passando o parâmetro pad em plt.title()<jupyter_code>reflexao(Q10)<jupyter_output><empty_output><jupyter_text>[Documentação](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.title.html). [Voltar ao topo](title-id)    ---  Tipos de fontesUm ponto muito importante em um gráfico é o tipo (ou família) de fonte utilizada. Algumas revistas cinentíficas limitam as figuras em alguns tipos de fontes para garantir uma boa leitura do gráfico. Alterar a fonte utilizada nos elementos de texto e numéricos do gráfico do matplotlib é bem simples. É possível alterar de duas formas:- alterar a fonte padrão de todos os elementos (recomendado);- alterar a fonte de cada elemento;A primeira forma é recomendada para evitar discrepâncias no gráfico. O gráfico é um elemento único, que tem uma mensagem a ser passada, e esta mensagem deve estar padronizada para não confundir o leitor. Em poucos casos será necessário alterar a fonte apenas um ou outro elemento, e então não irei abordar está possibilidade.Para alterar a fonte padrão no matplotlib, podemos utilizar a classe ```rc``` do matplotlib. Através desta classe, podemos alterar qualquer configuração padrão do matplotlib (gerenciamento de backend).Uma lista com todas as opções pode ser acessada [neste link](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.rc.html)Para alterar a fonte padrão, precisamos alterar o valor do tipo da família da fonte. Para alterar a fonte padrão (que é a **DejaVu Sans**) para a fonte **Arial**, podemos fazer da seguinte forma:```pythonmatplotlib.rc('font', family = 'Arial')```O primeiro argumento ```font``` se refere a qual caracteristica será alterada. O argumento ```family``` se refere ao tipo de fonte que será utilizado.Para utilizar esta ferramenta, precisamos importar a *root* do matplotlib:<jupyter_code>import matplotlib as mpl<jupyter_output><empty_output><jupyter_text>E então aplicar o método:<jupyter_code>mpl.rc('font', family = 'Arial')<jupyter_output><empty_output><jupyter_text>O que resulta no seguinte gráfico:<jupyter_code>plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)")
plt.title("Relação entre peso e altura de diversas raças de cachorro", pad=40, loc='right') 
plt.show()<jupyter_output><empty_output><jupyter_text>Observe que todos os elementos de texto/numéricos agora estão na fonte Arial. Um incoveniente desta forma de alterar o fonte, é que para retornar ao padrão temos de aplicar o método novamente, mas com a fonte padrão (DejaVu Sans) ou reiniciar todo o notebook.Para saber quais fontes temos disponíveis para utilizar, utilizamos o ```mpl.font_manager.get_fontconfig_fonts()```, que retorna uma lista com o caminho de todos os arquivos de fontes disponíveis. Mas para obter os nomes que são utilizados para alterar o tipo da fonte, podemos fazer desta forma:<jupyter_code>flist = mpl.font_manager.get_fontconfig_fonts()
names = [mpl.font_manager.FontProperties(fname=fname).get_name() for fname in flist]
names<jupyter_output><empty_output><jupyter_text>Como você pode observar, os nomes não estão ordenados, que dificulta a busca. Para ordenar os dados em uma lista, utilizamos o método ```sorted()```:<jupyter_code>names = sorted(names)
names<jupyter_output><empty_output><jupyter_text>Mas repare que temos algumas fontes que estão repetidas. Para acessar apenas nomes de fontes únicas, podemos transformar a lista *names* em um *set*:<jupyter_code>fontes = set(names)
fontes<jupyter_output><empty_output><jupyter_text>Desta forma, o *set* *fontes* tem todos os tipos de fontes diponíveis para editar o gráfio do matplotlib. Por curiosidade, temos que a quantidade total de fontes é:<jupyter_code>len(fontes)<jupyter_output><empty_output><jupyter_text>Observação:O número de fontes disponíveis pode variar de acordo com a versão do matplotlib, versão do sistema operacional, versão do python, entre outros motivos. Então, caso queira altear a fonte para 'Times New Roman', basta:<jupyter_code>mpl.rc('font', family = 'Times New Roman')

plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)")
plt.title("Relação entre peso e altura de diversas raças de cachorro", pad=40, loc='right') 
plt.show()<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)    ---  Tamanho da fonteOutro ponto importante é o tamanho da fonte. As informações devem estar claras, e ter um tamanho de fonte adequado é essencial para isto. Também podemos alterar o tamanho da fonte diretamente em cada elemento (como fizemos para a legenda), mas é mais comum manter um tamanho padrão no gráfico todo. Então, para alterar o tamanho da fonte de todos os elementos gráficos, podemos aplicar o método ```mpl.rc()```novamente, mas agora passando o parâmetro ```size``` com um número correspondente ao tamanho de fonte dsejada. Por exemplo, passando ```size = 30```:<jupyter_code>mpl.rc('font', size = 30)

plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)")
plt.title("Relação entre peso e altura de diversas raças de cachorro", pad=40, loc='right') 
plt.show()<jupyter_output><empty_output><jupyter_text>Obtemos esse gráfico com o tamanho do texo muito grande. Um valor adequado geralmente gira em torno de 12, mas isto depende da fonte utilizada e do tamanho da figura.<jupyter_code>mpl.rc('font', size = 12)
plt.figure(figsize=(8,6)) 
plt.scatter(x,y, s = 100.1, marker = "D", edgecolors = 'k', facecolors='none', 
            label="Raças de cachorros") 
plt.legend()
plt.xlabel("Peso (kg)")
plt.ylabel("Altura (cm)")
plt.title("Relação entre peso e altura de diversas raças de cachorro", pad=40, loc='right') 
plt.show()<jupyter_output><empty_output><jupyter_text>Uma boa prática é aplicar o método ```mpl.rc('font', family = 'string', size = number)``` logo no início do notebook ou na mesma célula do gráfico, de forma que ao rodar o script, a atualização dos valores padrão é feita automaticamente. ---  Momento para reflexão***Como alterar o tipo de fonte geral para Arial no matplotlib?***a) Passando o parâmetro matplotlib.Arial() após criar o canvas da figura (plt.figure())b) Passando o parâmetro matplotlib.Arial() após criar os elementos do gráfico (plt.scatter())c) Setando a familia da fonte da seguinte forma: mpl.rc('font', family='Arial') antes de gera o gráficod) Setando a familia da fonte da seguinte forma: mpl.rc('font', family='Arial) antes de gera o gráfico<jupyter_code>reflexao(Q11)<jupyter_output><empty_output><jupyter_text>[Voltar ao topo](title-id)    ---  Diversas séries Em muitos casos vamos ter dois ou mais conjuntos de dados, ou seja, várias séries de *x* e *y*. No exemplo acima, com dados relacionando peso e altura dos cachorros, temos várias raças, e seria importante diferenciar as raças no gráfico.Para adicionar mais de uma série em um gráfico de dispersão, basta adicionar um novo elemento de ```plt.scatter()``` com a nova série. Por exemplo, o gráfico de dispersão que relaciona peso e altura apenas para a raça Chihuahua (posição 0) é:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0])
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Já para a raça 'Poodle Toy' (posição 1):<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[1], y[1], label=raca_cachorro[1])
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Para juntar estes dois gráficos (como séries diferentes), combinamos dois elementos de ```plt.scatter()```, um após o outro:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0])
plt.scatter(x[1], y[1], label=raca_cachorro[1])
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Dessa forma, o matplotlib irá automaticamente diferenciar a cor do marcador das diferentes séries de dados. E podemos adicionar quantas séries quanto desejarmos:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0])
plt.scatter(x[1], y[1], label=raca_cachorro[1])
plt.scatter(x[2], y[2], label=raca_cachorro[2])
plt.scatter(x[3], y[3], label=raca_cachorro[3])
plt.scatter(x[4], y[4], label=raca_cachorro[4])
plt.scatter(x[5], y[5], label=raca_cachorro[5])
plt.scatter(x[6], y[6], label=raca_cachorro[6])
plt.scatter(x[7], y[7], label=raca_cachorro[7])
plt.scatter(x[8], y[8], label=raca_cachorro[8])
plt.scatter(x[9], y[9], label=raca_cachorro[9])
plt.scatter(x[10], y[10], label=raca_cachorro[10])
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>---  Momento para reflexão***Como adicionar diversos elementos de dispersão no matplotlib?***a) Adicionando vários elementos de plt.scatter() antes de apresentar o gráficob) Criando várias sequências de criação de gráficos (criar canvas, adicionar elemento, apresentar o gráfico)c) Passando várias séries de dados através do parâmetro y em plt.scatter()<jupyter_code>reflexao(Q12)<jupyter_output><empty_output><jupyter_text>Desafio 1Crie o mesmo gráfico acima, mas utilizando um loop for. São necessárias apenas 5 linhas.Você pode acessar o notebook básico [clicando aqui](https://github.com/andersonmdcanteli/matplotlib-course/blob/main/curso/grafico-dispersao/desafio-1/Desafio-1.ipynb) (mas tente criar um novo notebook do zero, e implementar todos os dados por conta própria).O notebook com a resolução do desafio pode ser acessado [clicando aqui](https://github.com/andersonmdcanteli/matplotlib-course/blob/main/curso/grafico-dispersao/desafio-1/Desafio-1-Resolucao.ipynb)O vídeo da resolução do desafio 1 pode ser acessado [neste link](https://youtu.be/PziPMMthKY4)  Edição do gráficoAgora vamos editar o gráfico com as formas de edições que vimos para deixa-lo apresentavel.Em geral, gráficos coloridos são bons para apresentações, mas não para artigos (a inclusão de figuras coloridas geralmente esta atrelado ao pagamento de uma taxa elevada). Então vou alterar a cor dos marcadores para preta:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], c='k')
plt.scatter(x[1], y[1], label=raca_cachorro[1], c='k')
plt.scatter(x[2], y[2], label=raca_cachorro[2], c='k')
plt.scatter(x[3], y[3], label=raca_cachorro[3], c='k')
plt.scatter(x[4], y[4], label=raca_cachorro[4], c='k')
plt.scatter(x[5], y[5], label=raca_cachorro[5], c='k')
plt.scatter(x[6], y[6], label=raca_cachorro[6], c='k')
plt.scatter(x[7], y[7], label=raca_cachorro[7], c='k')
plt.scatter(x[8], y[8], label=raca_cachorro[8], c='k')
plt.scatter(x[9], y[9], label=raca_cachorro[9], c='k')
plt.scatter(x[10], y[10], label=raca_cachorro[10], c='k')
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Mas desta forma, não tem como diferenciar as raças! Então, vou alterar o tipo de marcador para cada série:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], c='k', marker='o')
plt.scatter(x[1], y[1], label=raca_cachorro[1], c='k', marker='s')
plt.scatter(x[2], y[2], label=raca_cachorro[2], c='k', marker='p')
plt.scatter(x[3], y[3], label=raca_cachorro[3], c='k', marker='*')
plt.scatter(x[4], y[4], label=raca_cachorro[4], c='k', marker='v')
plt.scatter(x[5], y[5], label=raca_cachorro[5], c='k', marker='^')
plt.scatter(x[6], y[6], label=raca_cachorro[6], c='k', marker='<')
plt.scatter(x[7], y[7], label=raca_cachorro[7], c='k', marker='>')
plt.scatter(x[8], y[8], label=raca_cachorro[8], c='k', marker='x')
plt.scatter(x[9], y[9], label=raca_cachorro[9], c='k', marker='D')
plt.scatter(x[10], y[10], label=raca_cachorro[10], c='k', marker='H')
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Mas os marcadores estão pequenos, e vou altera-los. Como a mudança de tamanho é apenas para fins estéticos, é mais indicado que todos os marcadores tenham o mesmo tamanho. Então, vou criar uma varáivel ```marker_size``` que vai receber o valor do tamanho do marcador, e vou passar esta variável para o parâmetro ```s```. Dessa forma, todas as séries terão marcador do mesmo tamanho, e caso eu queira alterar o tamanho, eu não preciso ficar alterando em todos os locais, bastando alterar o valor de ```marker_size```<jupyter_code>marker_size = 80
plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], c='k', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], c='k', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], c='k', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], c='k', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], c='k', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], c='k', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], c='k', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], c='k', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], c='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], c='k', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], c='k', marker='H', s = marker_size)
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Particularmente, eu prefiro os pontos abertos. Então:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='none', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Observe que o marcador da raça 'German Shepherd Dog' acabou desaparecendo, o que aconteceu pois o marcador utilizado é um ```x```, e este marcador não tem ```edgecolor```. Para resolver isto, basta passar a cor preta para o parâmetro ```facecolor```:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>Agora vou adicionar os elementos de texto no gráfico:<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend()
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.show()<jupyter_output><empty_output><jupyter_text>E por fim, vou alterar o tamanho das fontes e também a famila das fontes utilizando o ```mpl.rc()```. O tamanho da fonte da legenda eu vou alterar diretamente em ```plt.legend()```, pois ela acaba ficando maior do que eu gostaria.<jupyter_code>mpl.rc('font', family = 'Arial', size = 14)
plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("desafio_2.png")
plt.show()<jupyter_output><empty_output><jupyter_text>E pronto, temos um gráfico de disperção corretamente editado.  Desafio 2Obtenha o gráfico acima com todas as edições utilizando um for loop.O notebook base pode ser acessado [neste link](https://github.com/andersonmdcanteli/matplotlib-course/blob/main/curso/grafico-dispersao/desafio-2/Desafio-2.ipynb)O notebook com a resolução pode ser acessado [neste outro link](https://github.com/andersonmdcanteli/matplotlib-course/blob/main/curso/grafico-dispersao/desafio-2/Desafio-2-final.ipynb)O video com a resolução pode ser visto [clicando neste link](https://youtu.be/MImLX6iN5uA) [Voltar ao topo](title-id)    ---  Exportando o gráficoPara exportar um gráfico desenhado com o matplotlib utilizamos o ```plt.savefig()```, que deve ter como argumento o nome do arquivo que será criado, inclusive com a extensão desejada. O ```plt.savefig()``` deve ser adicionado logo acima de ```plt.show()```, e após todos os demais elementos terem sido criados.```pythonplt.figure()...plt.savefig()plt.show()```Para saber quais tipos de extensões podem ser utilizadas, utilize o seguinte comando:<jupyter_code>plt.gcf().canvas.get_supported_filetypes()<jupyter_output><empty_output><jupyter_text>No *dicionário* acima, temos a extensão possível como chave, e o nome da respectiva extesão no valor de cada chave. Para exemplificar, vamos criar um arquivo com extensão ".png":<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("meu_arquivo_em_png.png")
plt.show()<jupyter_output><empty_output><jupyter_text>Confira no diretório local o arquivo exportado (o mesmo em que este arquivo está salvo). Para saber qual é o diretório em que o notebook está, podemos utilizar a biblioteca ```os```, e utilizar o método ```os.getcwd()```:<jupyter_code>import os
os.getcwd()<jupyter_output><empty_output><jupyter_text>Vamos gerar um outro gráfico, mas com a extensão ".svg":<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("meu_arquivo_em_svg.svg") 
plt.close()<jupyter_output><empty_output><jupyter_text>Observe que, no código acima, o gráfico não foi apresentado. Isto aconteceu pois foi utilizado o ```plt.close()``` ao invés do ```plt.show()```, o que faz com que a figura não seja apresentada. Mas ainda assim, o arquivo foi exportado.Um arquivo '.svg' é muito interessante, pois ele permite a mudança no tamanho do gráfico sem perda de qualidade! [Voltar ao topo](title-id)    ---  Alterando o número de dpi'sTambém podemos especificar a densidade de pixels (*dpi*) do gráfico, o que é feito passando um número (*float* ou *int*) através do parâmetro ```dpi```. A quantidade de *dpis* padrão é de 100 dpis.<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("meu_arquivo_em_png.png", dpi=300) 
plt.show()<jupyter_output><empty_output><jupyter_text>Quanto maior o dpi, maior a qualidade final do gráfico, mas também maior será o tamanho do arquivo gerado. [Voltar ao topo](title-id)    ---  Adicionando transparênciaEm alguns casos, especialmente para posters e banners, é interessante que o gráfico tenha trânsparência, de forma a facilitar em adicionar outros elementos no banner/poster. Para exportar o gráfico transparente, basta passar como ```True``` o parâmetro ```transparent``` em ```plt.savefig()```. Tudo que não foi especificamente preenchido com alguma cor ficará transparente.<jupyter_code>plt.figure(figsize=(8,6))
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("scatter_plot_final.png", dpi=300, transparent='True')
plt.show()<jupyter_output><empty_output><jupyter_text>[Documentação](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.savefig.html) [Voltar ao topo](title-id)    ---  Preenchimento das bordas externasUm ponto importante, especialmente na hora de salvar os gráficos, é a área de preenchimento das bordas externas. Por padrão, esta área é transparente, mas podemos altera-la passado uma cor para o parâmetro ```facecolor``` em ```plt.figure()```:<jupyter_code>plt.figure(figsize=(8,6), facecolor='blue')
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("grafico_fundo_azul.png", dpi=100)
plt.show()<jupyter_output><empty_output><jupyter_text>Em alguns casos pode acontecer do gráfico exportado "corte" alguma parte do gráfico. Por exemplo, caso alterarmos a posição das legendas para fora do gráfico:<jupyter_code>plt.figure(figsize=(8,6), facecolor='blue')
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12, bbox_to_anchor=(1.,1.))
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("grafico_fundo_azul_legenda_fora_eixo.png", dpi=100)
plt.show()<jupyter_output><empty_output><jupyter_text>Visualmente, parece que o gráfico esta correto (pelo menos no output). Mas ao abrir o arquivo, obtemos ele incompleto (abra no seu navegador ou visualizador de fotos também!): ![output_fundo_azul.png](attachment:output_fundo_azul.png) Para evitar que isto aconteça, podemos passar um o parâmetro ```bbox_inches='tight'``` em ```plt.savefig()```:<jupyter_code>plt.figure(figsize=(8,6), facecolor='blue')
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12, bbox_to_anchor=(1.,1.))
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("grafico_fundo_azul_legenda_fora_tight.png", dpi=100, bbox_inches='tight')
plt.show()<jupyter_output><empty_output><jupyter_text>Observe que o output gerado é semelhante ao output gerado antes de utilizar o ```bbox_inches='tight'``` em ```plt.savefig()```, mas não é igual. Observe que o espaço entre os titulos (tanto dos eixos, como do titulo) está mais próximo do limite do gráfico. O gráfico ficou 'justo'.Já na versão exportada, agora temos a legenda inteira, como era de se esperar: ![output_fundo_azul_tight.png](attachment:output_fundo_azul_tight.png) O ```bbox_inches='tight'``` é muito útil para remover espaços vazios do gráfico, sendo possível obter um gráfico maior ocupando o mesmo tamanho da figura. Voltando a legenda para a posição ```best``` e com o  ```bbox_inches='tight'```, obtemos:<jupyter_code>plt.figure(figsize=(8,6), facecolor='blue')
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("grafico_fundo_azul_tight.png", dpi=100, bbox_inches='tight')
plt.show()<jupyter_output><empty_output><jupyter_text>E sem a cor azul de fundo:<jupyter_code>plt.figure(figsize=(8,6),facecolor='w')
plt.scatter(x[0], y[0], label=raca_cachorro[0], edgecolor='k', facecolor='none', marker='o', s = marker_size)
plt.scatter(x[1], y[1], label=raca_cachorro[1], edgecolor='k', facecolor='none', marker='s', s = marker_size)
plt.scatter(x[2], y[2], label=raca_cachorro[2], edgecolor='k', facecolor='none', marker='p', s = marker_size)
plt.scatter(x[3], y[3], label=raca_cachorro[3], edgecolor='k', facecolor='none', marker='*', s = marker_size)
plt.scatter(x[4], y[4], label=raca_cachorro[4], edgecolor='k', facecolor='none', marker='v', s = marker_size)
plt.scatter(x[5], y[5], label=raca_cachorro[5], edgecolor='k', facecolor='none', marker='^', s = marker_size)
plt.scatter(x[6], y[6], label=raca_cachorro[6], edgecolor='k', facecolor='none', marker='<', s = marker_size)
plt.scatter(x[7], y[7], label=raca_cachorro[7], edgecolor='k', facecolor='none', marker='>', s = marker_size)
plt.scatter(x[8], y[8], label=raca_cachorro[8], edgecolor='k', facecolor='k', marker='x', s = marker_size)
plt.scatter(x[9], y[9], label=raca_cachorro[9], edgecolor='k', facecolor='none', marker='D', s = marker_size)
plt.scatter(x[10], y[10], label=raca_cachorro[10], edgecolor='k', facecolor='none', marker='H', s = marker_size)
plt.legend(fontsize=12)
plt.xlabel("Peso (kg)", labelpad=15)
plt.ylabel("Altura (cm)", labelpad=15)
plt.title("Relação entre peso e altura de diversas raças de cachorros", pad=15)
plt.savefig("grafico_fundo_normal_tight.png", dpi=100, bbox_inches='tight')
plt.show()<jupyter_output><empty_output><jupyter_text>Observe que é importante deixar a área externa ao gráfico na cor branca, pois esta parte é ***transparente por padrão.*** ---  Momento para reflexão***Como deixar o gráfico exportado fique com espaçamento justo?***a) Passar o parâmetro tight = True em plt.scatter()b) Passar o parâmetro tight = True em plt.Figure()c) Passar o parâmetro bbox_inches = True em plt.savefig()d) Passar o parâmetro bbox_inches = 'tight' em plt.savefig()<jupyter_code>reflexao(Q13)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14902467010900747, 'fraction_numerical': 0.01733122968062727, 'mean_word_length': 5.904761904761905, 'pattern_counts': {'":': 2, '<': 381, '<?xml version=': 0, '>': 381, 'https://': 24, 'lorem ipsum': 0, 'www.': 3, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '90', 'dir': 'jupyter-structured-clean-dedup', 'id': '135885', 'license': 'MIT', 'n_tokens_mistral': 33083, 'n_tokens_neox': 31802, 'n_words': 8382, 'path': 'curso/grafico-dispersao/aula/grafico-dispersao.ipynb', 'repo_name': 'andersonmdcanteli/matplotlib-course', 'size': '83672'}