import pandas as pd
from pandas import DataFrame
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib import rcParams
from io import BytesIO
from PIL import Image
import io
import matplotlib.ticker as ticker
from loguru import logger
[docs]class Analyzes:
def __init__(self) -> None:
"""
Classe responsável por conter os métodos de análise de dados.
"""
self.__dpi = 200
pass
[docs] def lineplot(self, data: DataFrame, x: str, y: str) -> Image:
"""
Método lineplot: Gera um gráfico de linha do tipo imagem PIL.
Parâmetros:
data: Dataframe.
x: str.
y: str.
Descrição dos parâmetros:
data -> Argumento onde o usuário fornece um conjunto de dados em formato de dataframe.
x -> Argumento onde o usuário fornece a coluna do dataframe fornecido que ele deseja utilizar como eixo x.
y -> Argumento onde o usuário fornece a coluna do datafame fornecido que ele deseja utilizar como eixo y.
Exemplo de uso:
analise = Anaylzes()
df = 'caminho_do_seu_dataframe'
grafico_linha = analise.lineplot(data=df, x='Coluna_1', y='Coluna_2')
grafico_linha.show()
"""
logger.info('Gerando gráfico de linha...')
fig, ax = plt.subplots()
sns.lineplot(x=x, y=y, data=data, ax=ax)
img = BytesIO()
fig.savefig(img, format='png')
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
[docs] def barplot(self, data: DataFrame, x: str, y: str) -> Image:
"""
Método barplot: Gera um gráfico de barras do tipo imagem PIL.
Parâmetros:
data: Dataframe.
x: str.
y: str.
Descrição dos parâmetros:
data -> Argumento onde o usuário fornece um conjunto de dados em formato de dataframe.
x -> Argumento onde o usuário fornece a coluna do dataframe fornecido que ele deseja utilizar como eixo x.
y -> Argumento onde o usuário fornece a coluna do datafame fornecido que ele deseja utilizar como eixo y.
Exemplo de uso:
analise = Anaylzes()
df = 'caminho_do_seu_dataframe'
grafico_barras = analise.barplot(data=df, x='Coluna_1', y='Coluna_2')
grafico_barras.show()
"""
logger.info('Gerando gráfico de barra...')
rcParams['figure.figsize'] = (16, 10)
fig, ax = plt.subplots()
sns.barplot(data=data, x=x, y=y, estimator="sum")
ax.set_title(f"Consumidores {y} por {x}")
for p in ax.patches:
height = p.get_height()
ax.text(p.get_x()+p.get_width()/2., height+3, '{:1.2f}'.format((height+3)), ha='center')
img = BytesIO()
fig.savefig(img, format='png', dpi=self.__dpi)
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
[docs] def dispersao_plot(self, data1: DataFrame, data2: DataFrame, x_label: str, y_label: str, coluna_referencia: str, titulo: str) -> Image:
"""
Método dispersao_plot: Gera um gráfico de dispersão do tipo imagem PIL.
Parâmetros:
data1: Dataframe.
data2: Dataframe.
coluna_referencia: str.
x_label: str.
y_label: str.
titulo: str
Descrição dos parâmetros:
data1 -> Argumento onde o usuário fornece um conjunto de dados em formato de dataframe.
data2 -> Argumento onde o usuário fornece o segundo conjunto de dados em formato de dataframe.
x_label -> Argumento onde o usuário fornece a legenda que deseja exibir no eixo x.
y_label -> Argumento onde o usuário fornece a legenda que deseja exibir no eixo y.
coluna_referencia -> Argumento onde o usuário fornece o nome da coluna em comum que se encontra nos dois dataframes e que será comparada.
titulo -> Argumento onde o usuário fornece o título que dejesa para o seu gráfico.
Exemplo de uso:
analise = Anaylzes()
df1 = 'caminho_do_seu_dataframe1'
df2 = 'caminho_do_seu_dataframe2'
grafico_dispersao = analise.dispersao_plot(data1=df1, data2=df2, x_label='Legenda do eixo x', y_label= 'Legenda do eixo y', coluna_referencia='Coluna', titulo: 'Esse é o título do meu gráfico')
grafico_dispersao.show()
NOTA:
certifique-se que a coluna de referência nos dois dataframes estejam com o mesmo nome.
Exemplo:
O usuário possui dois dataframes, um dataframe de vendas de um produto, e um dataframe de lucro obtido com esse produto.
Caso queira comparar a dispersão entre os dois dataframes, utilize uma coluna em comum entre as duas, ex: Produto4
"""
if coluna_referencia in ['Poder Publico', 'Iluminacao Publica', 'Servico Publico', 'Consumo Proprio']:
logger.info('Gerando gráfico de dispersão...')
coluna2 = coluna_referencia.replace(' ','_')
rcParams['figure.figsize'] = (16,10)
fig, ax = plt.subplots()
plt.scatter(data1[coluna_referencia], data2[coluna2]/1000)
plt.title(titulo)
plt.xlabel(x_label)
plt.ylabel(y_label)
formatter = ticker.ScalarFormatter(useMathText=True)
formatter.set_scientific(False)
formatter.set_powerlimits((-1,1))
plt.gca().yaxis.set_major_formatter(formatter)
plt.gca().xaxis.set_major_formatter(formatter)
img = BytesIO()
fig.savefig(img, format='png', dpi=self.__dpi)
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
else:
logger.info('Gerando gráfico de dispersão...')
rcParams['figure.figsize'] = (16,10)
fig, ax = plt.subplots()
plt.scatter(data1[coluna_referencia], data2[coluna_referencia]/1000)
plt.title(titulo)
plt.xlabel(x_label)
plt.ylabel(y_label)
formatter = ticker.ScalarFormatter(useMathText=True)
formatter.set_scientific(False)
formatter.set_powerlimits((-1,1))
plt.gca().yaxis.set_major_formatter(formatter)
plt.gca().xaxis.set_major_formatter(formatter)
img = BytesIO()
fig.savefig(img, format='png', dpi=self.__dpi)
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
[docs] def pointplot(self, data: DataFrame, x: str, y: str, title: str, x_label: str, y_label: str, hue:str=None) -> Image:
"""
Método pointplot: Gera um gráfico de linha com pontos do tipo imagem PIL.
Parâmetros:
data: Dataframe.
x: str.
y: str.
title: str.
x_label: str.
y_label: str.
hue: str.
Descrição dos parâmetros:
data -> Argumento onde o usuário fornece um conjunto de dados em formato de dataframe.
x -> Argumento onde o usuário fornece a coluna do dataframe fornecido que ele deseja utilizar como eixo x.
y -> Argumento onde o usuário fornece a coluna do datafame fornecido que ele deseja utilizar como eixo y.
title -> Argumento onde o usuário fornece o título do gráfico.
x_label -> Argumento onde o usuário fornece a legenda do eixo x.
y_label -> Argumento onde o usuário fornece a legenda do eixo y.
hue -> Argumento onde o usuário fornece a coluna do dataframe responsável por segregar os dados.
Exemplo de uso:
analise = Anaylzes()
df = 'caminho_do_seu_dataframe'
grafico_pontos = analise.pointplot(data=df, x='Coluna_1', y='Coluna_2', title='Titulo do gráfico', x_label='Legenda do eixo x', y_label='Legenda do eixo y', hue='Coluna_5')
grafico_pontos.show()
NOTA:
Nesse exemplo de uso, repare que o hue é a coluna 5 do dataframe, imagine que esse dataframe em questão na coluna 5 tenha informações de classificação.
E esse dataframe está com as seguintes classificações: Pequeno, Médio e Grande.
Quando o gráfico for plotado, irá ter 3 linhas, uma para cada classificação.
O argumento hue NÃO É OBRIGATÓRIO
"""
logger.info('Gerando gráfico de pontos...')
rcParams['figure.figsize'] = (16, 10)
fig, ax = plt.subplots()
sns.pointplot(data=data, x=x, y=y, hue=hue)
ax.set_title(title)
ax.legend()
ax.set_xlabel(x_label)
ax.set_ylabel(y_label)
ax.grid(True)
img = BytesIO()
fig.savefig(img, format='png', dpi=self.__dpi)
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
[docs] def boxplot(self, data: DataFrame, column: str, x_label: str) -> Image:
"""
Método boxplot: Gera um gráfico de caixa do tipo imagem PIL.
Parâmetros:
data: Dataframe.
column: str.
x_label: str.
Descrição dos parâmetros:
data -> Argumento onde o usuário fornece um conjunto de dados em formato de dataframe.
column -> Argumento onde o usuário fornece a coluna que ele deseja fazer a análise de outliers.
Exemplo de uso:
analise = Anaylzes()
df = 'caminho_do_seu_dataframe'
grafico_caixa = analise.boxplot(data=df, column='Coluna_3', x_label='Outliers da coluna 3')
grafico_caixa.show()
"""
logger.info('Gerando gráfico de caixa (boxplot)...')
rcParams['figure.figsize'] = (16, 10)
fig, ax = plt.subplots()
sns.boxplot(data=data[column]).set(xlabel=x_label)
img = BytesIO()
fig.savefig(img, format='png', dpi=self.__dpi)
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
[docs] def grafico_de_barras_e_linha(self, dataBarra: DataFrame, dataLinha: DataFrame, coluna_em_comum: str, coluna_barra: str, coluna_linha, x_label: str, y_label_barra: str, y_label_linha: str, title: str) -> Image:
"""
Método grafico_de_barras_e_linhas: Gera um gráfico de barras com linha do tipo imagem PIL.
Parâmetros:
dataBarra: Dataframe.
dataLinha: Dataframe.
coluna_em_comum: str.
coluna_barra: str.
coluna_linha: str.
x_label: str.
y_label_barra: str.
y_label_linha: str.
title: str.
Descrição dos parâmetros:
dataBarra -> Argumento onde o usuário fornece o conjunto de dados desejado para ser representado em barra, no formato Dataframe.
dataLinha -> Argumento onde o usuário fornece o conjunto de dados desejado para ser representado em linha, no formato Dataframe.
coluna_em_comum -> Argumento onde o usuário fornece a coluna do dataframe em que vai ser comparada pelos dois.
coluna_barra -> Argumento onde o usuário fornece a coluna do dataframe em que vai ser usada para a barra.
coluna_linha -> Argumento onde o usuário fornece a coluna do dataframe em que vai ser usada para a linha.
x_label -> Argumento onde o usuário coloca a legenda do eixo x.
y_label_barra -> Argumento onde o usuário coloca a legenda do eixo y da barra.
y_label_linha -> Argumento onde o usuário coloca a legenda do eixo y da linha.
title -> Argumento onde o ususário coloca o título dog gráfico.
Exemplo de uso:
analise = Anaylzes()
df1 = 'caminho_do_seu_dataframe'
df2 = 'caminho_do_seu_segundo_dataframe'
grafico_barras_e_linha = analise.grafico_de_barras_e_linha(dataBarra=df1, dataLinha= df2, coluna_em_comum='Pets', coluna_barra='Pets_Vendas', coluna_linha='Pets_inflação', x_label='Pets', y_label_barra= 'Vendas de itens de pets', y_label_linha='Inflação sobre os produtos', title='Relação vendas de itens de pets com inflação sobre os produtos')
grafico_barras_e_linha.show()
"""
logger.info('Gerando gráfico de barra com linha...')
rcParams['figure.figsize'] = (16, 10)
# criar o plot com barras para o PIB
fig, ax1 = plt.subplots(figsize=(8, 6))
ax1.bar(dataBarra[coluna_em_comum], dataBarra[coluna_barra], alpha=0.5, color='b')
# criar o segundo eixo y para o consumo
ax2 = ax1.twinx()
ax2.plot(dataLinha[coluna_em_comum], dataLinha[coluna_linha], color='r', linewidth=3, marker='o')
# definir os rótulos dos eixos e o título do gráfico
ax1.set_xlabel(x_label)
ax1.set_ylabel(y_label_barra, color='b')
ax2.set_ylabel(y_label_linha, color='r')
plt.title(title)
img = BytesIO()
fig.savefig(img, format='png', dpi=self.__dpi)
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
[docs] def matriz_corr(self, data: DataFrame, colunas: list = []) -> Image:
"""
Método matriz_corr: Gera um gráfico de matriz de correlação do tipo imagem PIL.
Parâmetros:
data: Dataframe.
colunas: list.
Descrição dos parâmetros:
data -> Argumento onde o usuário fornece um conjunto de dados em formato de dataframe.
colunas -> Argumento onde o usuário fornece uma lista com as colunas que deseja utilizar para a correlação.
Exemplo de uso:
analise = Anaylzes()
df = 'caminho_do_seu_dataframe'
grafico_matriz_corr = analise.matriz_corr(data=df, colunas=['Coluna_1', 'Coluna_7', 'Coluna_4'])
grafico_matriz_corr.show()
NOTA:
O argumento de colunas NÃO É OBRIGATÓRIO
"""
# Correlation
logger.info('Gerando gráfico de matriz de correlação...')
rcParams['figure.figsize'] = (30, 20)
fig, ax = plt.subplots()
if colunas:
corr_mat = data[colunas].corr()
else:
corr_mat = data.corr()
mask = np.array(corr_mat)
mask[np.tril_indices_from(mask)] = False
sns.heatmap(corr_mat, mask=mask, square=True, annot=True)
img = BytesIO()
fig.savefig(img, format='png', dpi=self.__dpi)
img.seek(0)
plt.close(fig)
grafico = Image.open(io.BytesIO(img.read()))
return grafico
[docs] def correlacao(self, data: DataFrame, colunas: list = []) -> list:
"""
Método correlacao: Gera uma tabela de correlação entre as colunas.
Parâmetros:
data: Dataframe.
colunas: list.
Descrição dos parâmetros:
data -> Argumento onde o usuário fornece um conjunto de dados em formato de dataframe.
colunas -> Argumento onde o usuário fornece uma lista com as colunas que deseja utilizar para a correlação.
Exemplo de uso:
analise = Anaylzes()
df = 'caminho_do_seu_dataframe'
graifico_correlacao = analise.correlacao(data=df, colunas=['Coluna_3', 'Coluna_20', 'Coluna_13'])
print(grafico_correlacao)
NOTA:
O argumento de colunas NÃO É OBRIGATÓRIO
"""
logger.info('Gerando informações de correlação...')
correlacao = data[colunas].corr()
return correlacao