Definindo cores com Matplotlib

Introdução

Muitos dos nossos exemplos, até aqui, não precisamos definir as cores presentes nos gráficos. Isso foi possível porque a biblioteca matplotlib já tem uma definição de cores padrão para alguns elementos. Mas não é por que existe uma grade de cores definida como padrão que não é possível alterar esses valores. A biblioteca matplotlib é muito flexível nesse quesito. Permitindo que novas cores sejam adicionadas ao projeto.

Definindo cores

As cores padrões usadas pela biblioteca matplotlib são um pouco neutras. São cores que não saltam aos olhos. E talvez seja exatamente isso que você queira, ou talvez não. Como numa apresentação de dados na sua reunião. Nessas situações é possível que você queira chamar mais atenção para um dado especifico. Ou talvez esses dados não sejam muitos animadores e você precisa tirar o foco desses dados. Seja como for a escolha de cores é uma tarefa muito importante na criação de gráficos. E a matplotlib te fornece total liberdade para escolher as cores.

Mãos a obra...

Com a biblioteca matplotlib é possível escolher as cores do gráfico de varias formas diferentes, veja algumas delas:

• Três cores: A cor é formada pela mistura de três cores: o vermelho, o verde e o azul. É quase a mesma coisa que o RGB, com uma diferença: o valor de cada cor deve variar de 0.0 até 1.0 e não de 0 até 255. Por exemplo, para ter a cor vermelha os valores devem ser 1.0, 0.0 e 0.0.
• Quatro cores: Definir uma cor com quatro cores é do mesmo jeito que definimos uma com três cores. A diferença é o alfa, que define a transparência da cor. Para definir um azul transparente, usaríamos quatro valores: vermelho, verde, azul e alfa. Por exemplo, 0.0, 0.0, 1.0, 0.5.
• Nomes definidos: Na biblioteca matplotlib, algumas cores têm uma string definida ou um alias. Assim podemos passar o nome dessa cor e a biblioteca vai entender que queremos essa cor especifica. Por exemplo, passando a string red a biblioteca vai entender que queremos que nosso gráfico tenha a cor vermelha. Veja alguns alias de cores padrões:



Alias	Cores
r	Vermelho
g	Verde
b	Azul
c	Ciano
m	Mangenta
y	Amarelo
k	Preto
w	Branco



• Nível de cinza: Com o nível de cinza você só precisa passar uma string entre 1 e 0. Quanto mais perto do um o valor for mais claro é o cinza e quanto mais perto do zero mais escuro é.

Como definir cores do gráfico

As cores do gráfico são definidas no parâmetro color da função que vai desenhar o objeto.

Exemplo

import matplotlib.pyplot as plt

x = [10, 20, 30, 40, 50]
y1 = [10, 20, 30, 40, 50]
y2 = [10, 30, 20, 53, 35]
y3 = [10, 22, 29, 43, 49]
y4 = [16, 23, 27, 32, 41]

# três cores
plt.plot(x, y1, color = (.76, .12, .98))
# quatro cores
plt.plot(x, y2, color = (.76, .87, .12, .5))
# nome definido
plt.plot(x, y3, color = 'b')
# nível de cinza
plt.plot(x, y4, color = '.75')

plt.show()

A execução desse código deve resulta num gráfico igual á esse:

Como funciona o parâmetro color

O parâmetro color define a cor do objeto desenhado segundo o valor que ele recebe. Esse valor pode ser com três cores, quatro cores, nomes definidos ou níveis de cinza.

Anterior Próximo

Read More

Triangulação com a biblioteca Matplotlib

A triangulação surge quando temos três ou mais pontos num plano. Ela pode ser usada para indicar relação entre dados ou coordenadas. Essa relação é indicada por uma linha, que com três coordenas ou mais formão triângulos. Muitas áreas fazem uso da triangulação, como é o caso da geometria e investigação. Na geometria a triangulação é usada na subdivisão de um objeto geométrico em simplexos. Nas investigações a triangulação é usada para tentar achar uma ligação entre fatos ou pistas. E como não podia ser diferente, a biblioteca matplotlib fornece funções para a triangulação em gráficos.

Como fazer gráficos com triangulação

A função triplot é usada para criar um gráfico com triangulação.

Exemplo

import matplotlib.pyplot as plt
import matplotlib.tri as tri

x = [2, 4, 8, 5, 6, 8]
y = [5, 18, 16, 14, 8, 10]

triangulos = tri.Triangulation(x, y)

plt.triplot(triangulos)
plt.show()

O código a cima vai produzir um gráfico como esse:

Como funciona…

Para criar um gráfico com triangulação precisamos informar as coordenadas x e y de cada ponto para a função Triangulation. A função Triangulation retorna um objeto que será usado pela função triplot para desenhar o gráfico com as coordenadas informadas. Note que cada novo ponto se conecta com pelo menos três outros pontos, criando mais triangulos.

Anterior Próximo

Read More

Boxplot com Matplotlib

Boxplot ou diagrama de caixa é uma ferramenta utilizada para identificar o maior e menor valor, mediana e quartis de um conjunto de dados. Em estatística descritiva, o diagrama de caixa, é uma ferramenta gráfica para representar a variação de dados observados de uma variável numérica por meio de quartis.

Como fazer um diagrama de caixa com matplotlib

A função utilizada para fazer um diagrama de caixa, com matplotlib, é a boxplot. Essa função recebe uma lista, da qual, se deseja saber o valor mínimo, máximo, mediana e quartis.
Nesse exemplo vamos usar uma lista ordenada, apenas para facilitar o entendimento. Listas desordenadas também podem ser usadas (a função boxplot ordena os elementos da lista).

Exemplo

import matplotlib.pyplot as plt

data = [52, 59, 67, 73, 73, 74, 77, 84, 85, 92, 96]

plt.boxplot(data)
plt.show()

Com a execução desse código, o gráfico apresentado deve ser igual a esse:

Como a função boxplot funciona

A função boxplot monstra um gráfico onde é possível ver os valores mínimos e máximos, mediana e quartis.
Para perceber isso note as duas linhas que saem da caixa. A linha que vai para cima, essa representa o valor máximo (96). A linha que vai para baixo, representa o valor mínimo (52). E a linha laranja, representa a mediana (A mediana é o número que fica no meio dos elementos: 74).
Os quartis são os números que ficam no meio dos meios. Por exemplo, peque a lista acima e divida ao meio em duas partes (Esqueça a mediana). A primeira parte vai ficar com os elementos 52, 59, 67, 73, 73. Com esse resultado já podemos descobrir qual é o primeiro quartis: 67. Do mesmo modo descobrimos que o terceiro quartis (a mediana é o segundo ;D) é 85.
As partes debaixo e de cima da caixa representam os quartis inferior e o superior, respectivamente.
Se você observou bem o gráfico percebeu que a parte superior da caixa fica exatamente no valor 85 (quartis superior). E que a parte de baixo ficou no número 70 e não no 67. Isso acontece porque o número subsequente desse quartis é muito discrepante. Quando isso acontece a função plotbox faz uma média entre o quartis inferior (67) e o número subsequente (73). Por isso a parte de baixo da caixa esta no 70. Por que a média entre 67 e 73 é 70. Para mudar isso tente trocar o número 73 por um mais próximo do 67.

Tem mais...

Se você precisar criar um gráfico com mais diagramas de caixa é só passar uma lista contendo listas para a função boxplot.

Exemplo

import matplotlib.pyplot as plt

data = [[52, 59, 67, 73, 73, 74, 77, 84, 85, 92, 96],
        [64, 65, 67, 69, 73, 74, 77, 84, 85, 92, 96],
        [56, 45, 87, 23, 49, 76, 23, 12, 185, 98, 1]]

plt.boxplot(data)
plt.show()

O gráfico desse exemplo deve ficar assim:

O circulo em cima do terceiro boxplot é usado para representar um valor muito fora da curva.

Anterior Próximo

Read More

Histograma com Matplotlib

Um histograma é uma distribuição de dados em forma de linhas ou barras. É muito utilizado para acompanhar a evolução de dados. Como a produção de alimentos em períodos do ano, o número de alunos matriculados, o consumo de combustíveis fosseis, entre outras coisas.
Visualmente um histograma é um gráfico com barras. Então porque não usar a função para a criação de barras do matplotlib? Porque a biblioteca matplotlib tem uma função especifica para a criação de histogramas. E a criação de histogramas com essa função torna o trabalho mais fácil.

Como fazer um histograma com a biblioteca Matplotlib

A função usada para fazer um histograma, com a biblioteca matplotlib, é a hist. Para o nosso exemplo vamos criar alguns valores aleatórios.

Exemplo

import matplotlib.pyplot as plt
from random import randint

dados = []
for i in range(100):
dados.append(randint(0, 9))

plt.hist(dados, bins = 20)
plt.show()

Executando o código acima o resultado deve ser parecido com esse (lembre-se que os valores são aleatórios):

Como a função hist funciona

A função hist, nesse exemplo, recebe dois argumentos. O primeiro é uma lista contendo cem números repetidos com valores entre 0 e 9. E o segundo é o número de colunas que o histograma deve ter.
A função hist agrupa os números repetidos e cria uma coluna com a altura/valor igual ao numero de elementos repetidos para cada grupo de elementos. Como o nosso histograma tem dez grupos e vinte colunas, fica um espaço entre as colunas.
Os elementos são ordenados de forma crescente, da esquerda para a direita. Assim sendo a primeira coluna informa a quantidade de números zero na lista dados. E a última coluna informa a quantidade de números nove na lista dados. Agora ficou fácil perceber que a função hist agrupa elementos iguais e mostra a quantidade desse elemento.

Tem mais…

Se o número de colunas, que o histograma deve ter for menor que o número de grupos, os grupos serão agrupados. Por exemplo, existem dez grupos (números de 0 a 9) e apenas cinco colunas: Os dois primeiros grupos (0 e 1) serão agrupados e assim sucessivamente. Assim se o primeiro grupo (0) tem cinco elementos e o segundo (1) tem dois elementos, a primeira coluna do histograma vai ter o valor/altura igual a sete.

Anterior Próximo

Read More

Gráfico em pizza com Matplotlib

Os gráficos em formato de pizza, ou circular. É um gráfico fácil de compreender. Geralmente os dados, de um gráfico circular, é usado para representar uma porção de um todo. Como por exemplo, quantos por cento da população brasileira sabe inglês? Ou quantas pessoas gostam de café?
Expressar esses dados em forma de barra tornaria mais difícil a compreensão dos dados. Já com o gráfico em formato de pizza os seus dados são compreendidos quase que instantaneamente (pelo menos com dados muito discrepantes). Isso acontece porque os dados de um gráfico em pizza são representações de partes de um todo, e não um valor absoluto. Por isso o gráfico em pizza é usado para apresentar valores que fazem parte de um conjunto.

Como fazer um gráfico em formato de pizza

Para poder criar um gráfico em forma de pizza, a biblioteca matplotlib fornece a função pie.
Veja um exemplo abaixo do uso da função pie:

Exemplo

import matplotlib.pyplot as plt

dados = [32, 25, 18, 25]

plt.pie(dados)
plt.show()

A execução do código acima deve resultar num gráfico parecido com esse:

Como funciona a função pie da biblioteca matplotlib

A função pie recebe uma lista com os dados dos gráfico e calcula a área de cada dado. A lista poderia ser substituída por uma tupla ou um array da biblioteca numpy. O que você precisa prestar atenção é nos valores passados. A soma de todos os elementos da lista deve ser igual a cem. Se o valor da soma de todos os elementos da lista for menor que cem, uma fatia do gráfico ficará maior do que deveria.

Anterior Próximo

Read More

Mais barras com Matplotlib

Quando comparamos dados que podem ser representados por barras, e essas barras estão uma do lado da outra, é interessante que essas barras sejam de cores diferentes. Para facilitar o entendimento e localizar os dados que se procura.
Todo esse trabalho, de criar múltiplas barras com corres diferentes, pode ser feito com a função bar. Só precisamos adicionar alguns parâmetros e chamar a função algumas vezes (uma para cada nova barra que se deseja desenhar no gráfico).

Exemplo

import numpy as np
import matplotlib.pyplot as plt

dados = [[5., 25., 50., 20.],
         [4., 23., 51., 17.],
         [6., 22., 52., 19.]]

X = np.arange(4)

plt.bar(X + 0.00, dados[0], color = 'r', width = 0.25)
plt.bar(X + 0.25, dados[1], color = 'g', width = 0.25)
plt.bar(X + 0.50, dados[2], color = 'b', width = 0.25)
plt.show()

A execução do código acima deve resultar no seguinte resultado:

Empilhando barras

Com a função bar também podemos criar gráficos com barras sobre barras. Para definir qual barra estará embaixo da outra utilizamos o parâmetro bottom.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

a = np.array([5., 30., 45., 22.])
b = np.array([5., 25., 50., 20.])
c = np.array([1., 2., 1., 1.])
x = np.arange(4)

plt.bar(x, a, color = 'b')
plt.bar(x, b, color = 'g', bottom = a)
plt.bar(x, c, color = 'r', bottom = a + b)
plt.show()

O resultado desse exemplo é um gráfico com com quatro barras, cada uma com três barras empilhadas:

Fica fácil compreender o exemplo se você notar que começamos desenhando as barras de baixo. E conforme vamos adicionando barras indicamos quais barras estão abaixo.

Barras verticais

Utilizar barras verticais, uma do lado da outra, pode ser útil para demostrar o mesmo dado com grupos diferentes de indivíduos. Por exemplo, o numero de nascimentos de meninos e meninas. E é possível fazer esse tipo de gráfico com a biblioteca matplotlib.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

meninas = np.array([5., 30., 45., 22.])
meninos = np.array([5., 25., 50., 20.])

X = np.arange(4)

plt.barh(X, meninas, color = 'r')
plt.barh(X, -meninos, color = 'b')
plt.show()

Veja como é simples criar barras verticais uma “sobre” a outra: nesse exemplo mudamos apenas o sinal de um dos valores. E o resultado é esse:

Assim usamos o conhecimento das matrizes da biblioteca numpy ao nosso favor. Em vez de mudar todos os valores da matriz, um por um, podemos fazer isso de uma vez só.

Anterior Próximo

Read More

Gráfico com pontos e barras com Matplotlib

Pontos

Quando traçamos uma linha ou uma curva num gráfico o que realmente fazemos é interligar dois ou mais pontos. Esse tipo de coisa é interessante quando queremos ver a relação entre duas coisas relacionada. Como a variação de temperatura com o passar do tempo. Mas existem situações onde esse tipo de relação não existe, um dado é simplesmente um dado. Sem relação com outro. Por exemplo, uma coordenada no plano cartesiano.
Para o nosso exemplo vamos usar a função scatter da biblioteca matplotlib e a função rand da biblioteca numpy. A função scatter é utilizada para desenhar pontos no gráfico. E para isso a função recebe dois argumentos: as posições x e y de cada ponto. Já a função rand cria uma matriz com números aleatórios no intervalo de 0 até 1.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

coordenadas = np.random.rand(100, 2)

plt.scatter(coordenadas[:,0], coordenadas[:,1])
plt.show()

Executando o código acima o resultado deve ser parecido com esse:

Barras

Gráficos com barras são muito comuns e a biblioteca matplotlib não podia deixar de trazer funções para a criação de gráficos com barras. Uma dessas funções é a bar. Veja um exemplo de utilização da função bar:

Exemplo

import matplotlib.pyplot as plt

dados = [5., 25., 50., 20.]

plt.bar(range(len(dados)), dados)
plt.show()

O gráfico com barras, desenhado pelo código acima, deve ser parecido com esse:

A função bar recebe dois argumentos. O primeiro pode ser uma lista, tupla ou range. E o segundo é o valor da barra, ou sua altura. O primeiro argumento fornece as coordenadas x das barras no gráfico.
Entre as barras existe um espaço. E se por algum motivo você quiser alterar ou diminuir esse espaço podemos usar o parâmetro width da função bar. O valor padrão da largura das barras é 0,8.

Exemplo

import matplotlib.pyplot as plt

dados = [5., 25., 50., 20.]

plt.bar((1, 2, 3, 4), dados, width=0.5)
plt.show()

Com o valor do parâmetro width de 0.5 podemos notar que a largura da barra ficou menor.

Barras verticais

Para criar barras verticais a biblioteca matplotlib fornece a função barh. A função barh funciona da mesma forma que a bar. A única diferença é que a função barh desenha as barras na vertical.

Exemplo

import matplotlib.pyplot as plt

dados = [5., 25., 50., 20.]

plt.barh(range(len(dados)), dados)
plt.show()

Com esse exemplo o resultado é um gráfico com barras na vertical.

Anterior Próximo

Read More

Gráfico com dados de arquivo com Matplotlib

Se você leu os outros tutoriais, já deve saber que a biblioteca matplotlib não tem funções para leitura de dados em arquivos. A biblioteca matplotlib só renderiza o gráfico. Para ler dados de um arquivo vamos precisar usar funções fora do módulo matplotlib. Mas felizmente a linguagem python já vem com funções build-in para leitura e escrita de dados.
A primeira coisa que precisamos para ler dados de um arquivo é o arquivo com os dados que pretendemos ler. Nesse exemplo vamos usar um arquivo de texto com os seguintes dados:
0 0
1 1
2 4
3 9
4 16
5 25
6 36

Para fazer a leitura do arquivo vamos usar a função build-in open do python. E para desenhar o gráfico vamos usar o módulo matplotlib. Veja o código abaixo:

Exemplo

import matplotlib.pyplot as plt

x, y = [], []

for linha in open('dados.txt', 'r'):
  dados = [float(s) for s in linha.split()]
  x.append(dados[0])
  y.append(dados[1])

plt.plot(x, y)
plt.show()

O desenho do gráfico, com os dados do arquivo dados.txt, deve ficar parecido com esse:

Como podemos notar os dados no nosso arquivo são uma matriz. E qual biblioteca podemos usar para trabalhar com matrizes? Isso mesmo. A biblioteca numpy. Além de trabalhar com matrizes a biblioteca fornece a função loadtxt. A função loadtxt é usada para leitura de dados em arquivos txt.
Veja o mesmo exemplo acima, agora fazendo uso do módulo numpy:

Exemplo

import matplotlib.pyplot as plt
import numpy as np

dados = np.loadtxt('dados.txt')

plt.plot(dados[:,0], dados[:,1])
plt.show()

A função loadtxt retorna uma matriz de duas dimensões. Assim fica mais fácil para nos trabalharmos com esses dados. Utilizando um laço for o código pode ficar mais complexo.
Utilizando a biblioteca numpy, além de tornar o código menor, o código ficou mais fácil de entender. E a biblioteca numpy ainda trás funções para podermos ler dados de arquivos de text, CVS e Matlab.
A biblioteca numpy ainda trás vantagens quanto a velocidade e consumo de memória. Já que as partes de cálculos de matrizes da biblioteca foram escritas em C. E os dados são guardados na memoria como uma matriz numpy.

Anterior Próximo

Read More

Múltiplas curvas com Matplotlib

Uma das utilidades dos gráficos é analisar dados. Mas para analisar alguma coisa é sempre bom ter algum parâmetro. E nada melhor que um gráfico exibindo os dados que estão sendo analisados.
Nos exemplos passados criamos gráficos com apenas uma linha. Para analisar dois dados diferentes precisamos que esse gráfico tenha mais de uma linha. Uma linha pra cada dado.
Com a biblioteca matplotlib podemos criar um gráfico com múltiplas linhas. E nesse caso vamos criar um gráfico que mostra o seno de x e o cosseno de x no intervalo entre 0 e 2 * pi.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

X = np.linspace(0, 2 * np.pi, 100)
Ya = np.sin(X) # seno de x
Yb = np.cos(X) # cosseno de x

plt.plot(X, Ya)
plt.plot(X, Yb)
plt.show()

Executando o código acima o resultado deve ser um gráfico com duas linhas:

Nesse exemplo podemos notar que nosso gráfico tem duas linhas com cores diferentes. Essas cores são escolhidas automaticamente pela biblioteca matplotlib (nos próximos tutoriais vamos aprender a escolher as cores).
É importante notar que chamamos a função plot duas vezes, uma para cada linha. E chamamos a função show apenas uma. Isso acontece porque a função plot é apenas um “aviso” do que pretendemos desenhar no gráfico. Enquanto a função show faz o desenho. Por isso chamamos a função plot duas vezes e a função show apenas uma.
A função show monstra que a renderização do matplotlib é central. Assim você pode renderizar o gráfico quando e como quiser. Apenas chamando a função show. Antes disso você estará definindo a forma do objeto, mas não o criando. Esse comportamento da biblioteca é muito útil quando se esta criando um gráfico complexo com múltiplas linhas. Isso permite que você possa utilizar todos os recursos da linguagem para criar as formas do gráfico. E só depois, de tudo pronto, mostra-lo.

Anterior Próximo

Read More

Matplotlib e NumPy em Python

Você não precisar saber usar a biblioteca numpy para usar a biblioteca matplotli. Mas a biblioteca NumPy fornecem muitas funções e métodos que podem nos ajudar a criar o nosso gráfico. Ter conhecimento da biblioteca numpy será muito útil na utilização da biblioteca matplotlib.
Para entendermos melhor como um conhecimento da biblioteca numpy pode ser útil vamos desenhar uma linha no gráfico fazendo uso da função seno de x (sin(x)). O primeiro gráfico será feito sem utilizar a biblioteca numpy e o outro fará uso da biblioteca.

Exemplo

import math
import matplotlib.pyplot as plt

T = range(100)
x = [(2 * math.pi * t) / len(T) for t in T]
y = [math.sin(i) for i in x]

plt.plot(x, y)
plt.show()

Nesse exemplo faremos uso do módulo numpy.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

plt.plot(x, y)
plt.show()

Executando os dois exemplos você terá esse gráfico como resultado:

A única alteração no código foi feita na parte onde são geradas as coordenadas do gráfico. E mesmo assim o resultado foi o mesmo. Com uma diferença: utilizando a biblioteca numpy o código ficou mais simples.
No primeiro exemplos usamos as bibliotecas padrão do python para gerar as coordenadas de uma onda senoidal. Já no segundo utilizamos as funções da biblioteca numpy para fazer o mesmo trabalho.
A função linspace cria uma matriz com cem elementos uniformemente espaçados. Todos com os valores entre 0 e 2 * pi. Já a função sin retorna o seno de cada elemento da matriz x, que foi criada com a função linspace.
Com as funções da biblioteca numpy não precisamos calcular os valores, um por um, como fizemos no primeiro exemplo utilizando o módulo math. A biblioteca numpy trabalha com matrizes por isso podemos passar todos os valores de uma vez.
Por trabalhar com matrizes podemos utilizar a biblioteca numpy para gerar curvas de forma mais rápidas e economizar tempo. Outra vantagem de se utilizar as matrizes da numpy é a sua velocidade de execução. Já que a biblioteca foi otimizada para trabalhar com matrizes.
No próximo exemplo vamos traçar a linha do binômio x^2 -2x +1, no intervalo entre -3 e 2 usando 200 pontos.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-3, 2, 200)
y = x ** 2 - 2 * x + 1

plt.plot(x, y)
plt.show()

Executando o código acima o resultado deve ser um gráfico como esse:

Como no primeiro exemplo poderíamos criar as coordenadas usando apenas as bibliotecas padrão do python. Mas utilizando a biblioteca numpy o código fica mais legível e simples.
Considere aprender a utilizar a biblioteca numpy. É possível utilizar o módulo matplotlib sem saber nada de numpy. Mas saber numpy vai facilitar muito o trabalho na criação de coordenadas.

Anterior Próximo

Read More

Introdução ao Matplotlib e primeiro exemplo

Matplot é uma biblioteca que facilita a visualização de dados em gráficos. O objetivo da biblioteca é facilitar a criação de gráficos. Permitindo que o programador gaste o seu tempo na busca e analise de dados. Ao invés de desperdiçar horas criando um gráfico.
Com a biblioteca matplotlib é possível criar gráfico com poucas linhas de código.
Nesse tutorial vamos instalar o módulo matplotlib e criar o nosso primeiro gráfico com a biblioteca matplotlib.

Instalando o módulo Matplotlib

A instalação do módulo matplotlib pode ser feita através do gerenciador de pacotes pip.
A instalação pode ser feita, usando o pip, tanto no Windows como numa distribuição Linux.
No terminal ou promtp de comando digite: pip install matplotlib. Pronto! Você já pode começar a criar gráficos com a biblioteca matplotlib.
Obs: Se houver algum erro na instalação do módulo matplotlib, tente pip install matplotlib --user

A primeira curva

Para o nosso primeiro exemplo vamos traçar uma curva. Com esse exemplo você terá uma pequena noção de como a biblioteca matplotlib funciona.

Exemplo

import matplotlib.pyplot as plt

x = range(100)
y = [i ** 2 for i in x]

plt.plot(x, y)
plt.show()

Com esse código o nosso resultado deve ser um gráfico com uma linha curva. Como essa:

Na primeira linha importamos o módulo matplotlib.pyplot e criamos um apelido: plt. Se você procurar por códigos que utilizam o módulo matplotlib vai perceber que esse apelido é uma convenção entre os programadores.
E vamos adotar esse padrão aqui nos próximos tutoriais.
Na terceira linha criamos um objeto do tipo range com um range de 0 a 99.
Na quarta linha criamos uma lista com valores crescendo exponencialmente.
A função plot cria uma linha usando as coordenadas das variáveis x e y.
E por fim a função show monstra o gráfico.
O módulo matplotlib é desenvolvido, exclusivamente para plotagem (desenho de gráficos) e só. Se você quiser acessar os valores de um banco de dados e criar um gráfico, você vai precisar de outros módulos. Mais por sorte a linguagem python é muito popular e tem muitos módulos para acessar bancos de dados e fazer muito mais.

Anterior Próximo

Read More

MySQL em Python

Instalação e teste

MySQL é um dos bancos de dados mais utilizados na atualidade. E nos podemos utilizar esse banco de dados nas nossas aplicações em python.

Database MySQL

Para poder utilizar o banco de dados MySQL nas nossas aplicações, primeiro precisamos ter o MySQL instalado no nosso computador.
Caso você não tenha o MySQL instalado você pode baixa-lo gratuitamente aqui.
Se você utiliza uma distribuição Linux tente instalar o pacote mysql-server pelo gerenciador de pacotes da sua distribuição.
Uma alternativa ao MySQL é o MariaDB. O MariaDB é um fork do MySQL e é mais fácil de instalar. Todos os exemplos vão funcionar perfeitamente no MariaDB.

Instalando o driver do MySQL

Para ter acesso ao nosso banco de dados precisamos instalar o drive do MySQL.
Para instalar esse drive vamos utilizar o pip.
Copie e cole o texto abaixo no terminal (Linux ou Mac) ou promtp de comando (Windows).
python -m pip install mysql-connector
Com isso feito estamos prontos para usar o banco de dados MySQL.

Testando a conexão com o banco de dados

Para testar a conexão com o banco de dados é só importar o módulo mysql.connector. Se for apresentado algum erro a instalação do banco de dados ou do drive não foi bem sucedida. E se não for apresentado nada à instalação foi bem sucedida.

Exemplo

import mysql.connector

Criando uma conexão com o banco de dados MySQL

Para criar uma conexão com o banco de dados utilizamos o método connect. O método connect precisa receber os argumentos host, user e passwd. O primeiro argumento é o endereço da maquina (Se for uma maquina remota um ip deve ser fornecido, não é o nosso caso por isso usamos localhost). O segundo argumento é o usuário (vamos utilizar o usuário root. Esse já é criado por padrão). E por último o passwd. Nos exemplos desse tutorial não vamos utilizar senha, mas se você definiu uma senha deve utiliza-la.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd=''
)

print(meubd)

Você deve receber uma resposta parecido com essa:
<mysql.connector.connection.MySQLConnection object at 0x02ED60B8>

Criando um banco de dados

Para criar um banco de dados chamamos o método execute com a seguinte string: CREATE DATABASE nome-do-meu-banco-de-dados.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd=''
)

meucursor = meubd.cursor()
meucursor.execute('CREATE DATABASE meuBD')

O método cursor instancia objetos que podem executar operações como instruções SQL.
Que é exatamente o que o método execute faz.
Se não for apresentado nenhum erro o banco de dados meuBD foi criado.

Verificando se um banco de dados existe

Para verificar se um banco de dados existe vamos utilizar a instrução SQL SHOW DATABASES.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd=''
)

meucursor = meubd.cursor()
meucursor.execute('SHOW DATABASES')

for i in meucursor:
  print(i)

Esse exemplo vai retornar uma lista com os bancos de dados do sistema.
Também podemos definir o banco de dados no momento da conexão.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)

Se houver algum erro é por que o banco de dados meuBD não existe.

Criando tabelas

Para criar uma tabela usamos a instrução SQL CREATE TABLE nomedatabela.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()

meucursor.execute("CREATE TABLE minhaT (name VARCHAR(255), address VARCHAR(255))")

Se nenhum erro for apresentado a tabela minhaT foi criada.

Verificando se uma tabela existe

Você pode verificar se uma tabela existe no seu banco de dados usando a instrução sql SHOW TABLES. A instrução show tables vai monstra todas as tabelas do seu banco de dados.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
meucursor.execute('SHOW TABLES')

for i in meucursor:
  print(i)

Quando você criar uma tabela, você também deve criar uma coluna com uma chave exclusiva para cada registro.
Isso pode ser feito definindo uma chave primária.
Usamos a instrução "INT AUTO_INCREMENT PRIMARY KEY" que inserirá um número exclusivo para cada registro. Começando em um e aumentado em um para cada registro.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
meucursor.execute('CREATE TABLE minhaT (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), address VARCHAR(255))')

Se a tabela já existir utilizamos ALTER TABLE.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
meucursor.execute('ALTER TABLE minhaT ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY')

Inserindo dados na tabela

Para inserir dados numa tabela utilizamos a instrução sql INSERT INTO.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "INSERT INTO minhaT (name, address) VALUES (%s, %s)"
dados = ("João", "São Paulo - SP")
meucursor.execute(instrucaoSQL, dados)

meubd.commit()

print(meucursor.rowcount, 'Dados inseridos.')

O método commit salva as alterações feitas no banco de dados.

Inserindo múltiplas linhas

Para inserir múltiplas linhas vamos utilizar o método executemany. O método executemany recebe dois argumentos: a instrução sql e os dados. Os dados devem estar numa lista de tuplas.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "INSERT INTO minhaT (name, address) VALUES (%s, %s)"
dados = [
  ('Maria', 'Rio branco - AC'),
  ('Fabiana', 'Tíbau - RN'),
  ('Fábio', 'Rio de janeiro - RJ'),
  ('Michele', 'Fortaleza - CE')
]

meucursor.executemany(instrucaoSQL, dados)

meubd.commit()

print(meucursor.rowcount, 'Dados inseridos.')

ID da última linha inserida

É fácil descobrir o id da última linha inserida na tabela com o atributo lastrowid.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "INSERT INTO minhaT (name, address) VALUES (%s, %s)"
dados = ("Naruto", "Konoha")
meucursor.execute(instrucaoSQL, dados)

meubd.commit()

print("Uma linha foi inserida, ID:", meucursor.lastrowid)

Selecionando elementos da tabela

Para selecionar dados de uma tabela utilizamos a instrução sql SELECT.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
meucursor.execute("SELECT * FROM minhaT")

resultado = meucursor.fetchall()

for i in resultado:
  print(i)

Nesse exemplo estamos selecionando todos os elementos da tabela minhaT.
O método fetchall busca todas as linhas da última instrução executada.

Selecionando colunas

Para selecionar as colunas da nossa tabela é só especificarmos os nomes das colunas.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
meucursor.execute("SELECT name, address FROM minhaT")

resultado = meucursor.fetchall()

for i in resultado:
  print(i)

Método fetchone

Se você só precisar da primeira linha da tabela use o método fetchone. O método fetchone retorna uma tupla com a primeira linha da tabela.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
meucursor.execute("SELECT * FROM minhaT")

resultado = meucursor.fetchone()

print(resultado)

Instrução WHERE

Com a instrução where selecionamos com dados com um filtro melhor. Em vez de selecionar uma coluna ou uma linha da nossa tabela podemos selecionar um dado.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "SELECT * FROM minhaT WHERE address ='Rio branco - AC'"

meucursor.execute(instrucaoSQL)

resultado = meucursor.fetchall()

for i in resultado:
  print(i)

Com esse exemplo todos os dados da coluna address que o valor seja “Rio branco – AC” vão ser mostrados.

Caracteres coringa

Se você precisar procurar no banco de dados por um dado que você só conhece uma parte, os caracteres coringa podem ajudar. Com eles você só precisar saber uma parte do que você está procurando.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "SELECT * FROM minhaT WHERE address LIKE '%RN%'"

meucursor.execute(instrucaoSQL)

resultado = meucursor.fetchall()

for i in resultado:
  print(i)

Ordenando por resultado

Podemos ordenar os nossos resultados de forma crescente ou decrescente usando a instrução SORT BY.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "SELECT * FROM minhaT ORDER BY name"

meucursor.execute(instrucaoSQL)

resultado = meucursor.fetchall()

for i in resultado:
  print(i)

Ordem decrescente

Por padrão a instrução ORDER BY ordena os resultados de forma crescente. Para mudarmos esse comportamento usamos o DESC.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "SELECT * FROM minhaT ORDER BY name DESC"

meucursor.execute(instrucaoSQL)

resultado = meucursor.fetchall()

for i in resultado:
  print(i)

Apagando dados

Você pode apagar dados de uma tabela com a instrução DELETE FROM.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "DELETE FROM minhaT WHERE address = 'Rio branco - AC'"

meucursor.execute(instrucaoSQL)
meubd.commit()

print(meucursor.rowcount, 'Dados apagados.')

Apagando uma tabela

Para apagar uma tabela do nosso banco de dados usamos a instrução DROP TABLE.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = 'DROP TABLE minhaT'

meucursor.execute(instrucaoSQL)

Com esse exemplo se você tentar apagar uma tabela que não existe um erro vai ser lançado. Para evitar isso podemos usar o IF EXISTS.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = 'DROP TABLE IF EXISTS minhaT'

meucursor.execute(instrucaoSQL)

Atualizando dados de uma tabela

Para atualizar dados de uma tabela utilizamos a instrução UPDATE.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
instrucaoSQL = "UPDATE minhaT SET address = 'Campinas' WHERE address = 'Campinas - SP'"

meucursor.execute(instrucaoSQL)

meubd.commit()

print(meucursor.rowcount, 'Dado(s) atualizado(s).')

O primeiro valor (Campinas) é o dado que será alterado.

Limitando os resultados

Com uma tabela pequena não é preciso limitar os resultados numa consulta. Mas em uma tabela com centenas ou milhões de resultados limitar os resultados passa a ser interessante.
Podemos fazer isso com a instrução LIMIT.

Exemplo

import mysql.connector

meubd = mysql.connector.connect(
  host='localhost', # máquina local
  user='root',
  passwd='',
  database='meuBD'
)
meucursor = meubd.cursor()
meucursor.execute("SELECT * FROM minhaT LIMIT 5 OFFSET 2")

resultado = meucursor.fetchall()

for i in resultado:
  print(i)

Esse exemplo retorna cinco resultados começando da terceira linha.

Anterior Próximo

Read More