dashboard

Como Criar um Dashboard com Python e Streamlit

Dashboards permitem transformar dados de uma planilha em informações visuais mais fáceis de interpretar. Em vez de analisar milhares de registros individualmente, podemos utilizar indicadores e gráficos para identificar padrões e comparar resultados.

Neste tutorial, você aprenderá como criar um Dashboard de Vendas do Walmart utilizando Python, Pandas, Matplotlib e Streamlit.

Nosso dashboard terá quatro indicadores:

  • faturamento total;
  • média das vendas;
  • maior venda registrada;
  • quantidade de lojas.

Também criaremos quatro gráficos:

  • Top 5 lojas com mais vendas;
  • vendas em semanas com feriados;
  • evolução das vendas por ano;
  • vendas mensais por ano.

Estrutura do projeto

				
					Dashboard-Walmart/
│
├── main.py
├── graficos.py
└── Walmart_Sales.csv
				
			
  • O arquivo main.py será responsável por carregar os dados e construir o dashboard.
  • O arquivo graficos.py armazenará as funções responsáveis pela criação dos gráficos.
  • Já o arquivo Walmart_Sales.csv contém os dados utilizados na análise.

Passo 1 — Instalar as bibliotecas

Abra o terminal e execute:

				
					pip install streamlit pandas numpy matplotlib
				
			

Neste projeto utilizaremos:

  • Streamlit para construir o dashboard;
  • Pandas para manipular os dados;
  • NumPy para trabalhar com valores numéricos;
  • Matplotlib para criar os gráficos.

Passo 2 — Importar as bibliotecas no graficos.py

Comece importando as bibliotecas:

				
					import streamlit as st
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
				
			

Essas são as bibliotecas utilizadas pelas funções de visualização do projeto.

Passo 3 — Criar a função do Top 5 lojas

A função grafico_lojas() será responsável por identificar quais são as cinco lojas com maior faturamento total e apresentar esse resultado em um gráfico de barras.

Ela agrupa os dados pela coluna Store, soma os valores de Weekly_Sales, organiza os resultados do maior para o menor e seleciona apenas as cinco primeiras lojas.

				
					def grafico_lojas(df):
    somar_vendas_lojas = df.groupby('Store')['Weekly_Sales'].sum()

    print(somar_vendas_lojas)

    top5_lojas = somar_vendas_lojas.sort_values(
        ascending=False
    ).head(5)

    lojas = top5_lojas.index.astype(str)
    vendas = top5_lojas.values

    plt.bar(
        lojas,
        vendas,
        color='blue'
    )

    plt.title("Top 5 Lojas com Mais Vendas")
    plt.xlabel("Lojas")
    plt.ylabel("Faturamento(US$)")
    plt.grid(axis="y", alpha=0.6)

    st.pyplot(plt.gcf())

    plt.close()
				
			
Criar a função do Top 5 lojas

Passo 4 — Criar a função das vendas por ano

A função grafico_ano() será responsável por mostrar como o faturamento evoluiu ao longo dos anos presentes na base de dados.

Primeiro, a coluna Date é convertida para o formato de data. Depois, criamos uma nova coluna chamada Ano, agrupamos as vendas por ano e exibimos os resultados em um gráfico de linha.

				
					def grafico_ano(df):

    # converter a coluna Date para data
    df["Date"] = pd.to_datetime(
        df['Date'],
        format="%d-%m-%Y"
    )

    # criando coluna ano
    df['Ano'] = df['Date'].dt.year

    print(df['Ano'])

    # Somar as vendas por ano
    vendas_ano = df.groupby(
        "Ano"
    )["Weekly_Sales"].sum()

    anos = vendas_ano.index
    valores = vendas_ano.values

    plt.plot(
        anos,
        valores,
        color="green",
        marker="o",
        label="Vendas"
    )

    plt.title(
        "Evolução das Vendas por Ano"
    )

    plt.xlabel("Ano")
    plt.ylabel("Faturamento (US$)")

    plt.xticks(anos)

    plt.legend()

    st.pyplot(plt.gcf())

    plt.close()
				
			

Passo 5 — Criar a função das vendas em feriados

A função grafico_feriados() será utilizada para comparar o faturamento registrado em semanas com feriados e em semanas sem feriados.

Para isso, os dados são agrupados pela coluna Holiday_Flag e as vendas são somadas para cada categoria. Depois, os resultados são apresentados em um gráfico de pizza.

				
					def grafico_feriados(df):
    somar_vendas = df.groupby(
        'Holiday_Flag'
    )['Weekly_Sales'].sum()

    print(somar_vendas)

    valores = [
        somar_vendas[0],
        somar_vendas[1]
    ]

    print(valores)

    nomes = [
        "Com feriado",
        "Sem feriado"
    ]

    plt.pie(
        valores,
        labels=nomes,
        autopct="%1.1f%%",
        colors=["tomato", "skyblue"]
    )

    plt.title(
        "Vendas em Semanas com Feriados"
    )

    st.pyplot(plt.gcf())

    plt.close()
				
			

Passo 6 — Criar a função das vendas mensais por ano

A função grafico_mes() será responsável por comparar as vendas de cada mês entre os anos de 2010, 2011 e 2012.

Ela extrai o mês e o ano da coluna Date, agrupa as vendas por essas duas informações e separa os resultados em três listas, uma para cada ano. Depois, os valores são apresentados em um gráfico de barras horizontais.

				
					def grafico_mes(df):

    # converter a coluna Date para data
    df["Date"] = pd.to_datetime(
        df['Date'],
        format="%d-%m-%Y"
    )

    # criando coluna mes
    df['Mês'] = df['Date'].dt.month

    # criando coluna ano
    df['Ano'] = df['Date'].dt.year

    # Agrupar as vendas por mês e ano
    vendas = df.groupby(
        ["Mês", "Ano"]
    )["Weekly_Sales"].sum()

    print(vendas.index)

    # Separar as vendas de cada ano
    vendas_2010 = []
    vendas_2011 = []
    vendas_2012 = []

    # preencher as listas com os 12 meses
    for mes in range(1, 13):

        for ano, lista in [
            (2010, vendas_2010),
            (2011, vendas_2011),
            (2012, vendas_2012)
        ]:

            if (mes, ano) in vendas.index:
                lista.append(
                    vendas[mes, ano]
                )
            else:
                lista.append(0)

    # Posições das barras
    meses = np.arange(12)
    largura = 0.25

    # Barras de 2010
    plt.barh(
        meses - largura,
        vendas_2010,
        largura,
        label="2010",
        color="blue"
    )

    # Barras de 2011
    plt.barh(
        meses,
        vendas_2011,
        largura,
        label="2011",
        color="orange"
    )

    # Barras de 2012
    plt.barh(
        meses + largura,
        vendas_2012,
        largura,
        label="2012",
        color="green"
    )

    # Nomes dos meses
    nomes_meses = [
        "Jan", "Fev", "Mar", "Abr",
        "Mai", "Jun", "Jul", "Ago",
        "Set", "Out", "Nov", "Dez"
    ]

    plt.yticks(
        meses,
        nomes_meses
    )

    plt.title(
        "Vendas Mensais por Ano"
    )

    plt.xlabel(
        "Faturamento (US$)"
    )

    plt.ylabel("Meses")

    plt.legend()

    st.pyplot(plt.gcf())

    plt.close()
				
			

Passo 7 — Criar o main.py

Comece importando as bibliotecas e as quatro funções:

				
					import streamlit as st
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from graficos import (
    grafico_lojas,
    grafico_feriados,
    grafico_ano,
    grafico_mes
)
				
			

Agora vamos criar a função main() completa:

				
					def main():

    df = pd.read_csv(
        "Walmart_Sales.csv"
    )

    st.title(
        "📊 Dashboard de Vendas - Walmart"
    )

    st.write(
        "Análise visual das vendas das lojas Walmart"
    )

    # Indicadores
    faturamento_total = (
        df["Weekly_Sales"].sum()
    )

    media_vendas = (
        df["Weekly_Sales"].mean()
    )

    maior_venda = (
        df["Weekly_Sales"].max()
    )

    quantidade_lojas = (
        df["Store"].nunique()
    )

    col1, col2, col3, col4 = st.columns(4)

    col1.metric(
        "Faturamento Total",
        f"US$ {faturamento_total:,.2f}"
    )

    col2.metric(
        "Média de Vendas",
        f"US$ {media_vendas:,.2f}"
    )

    col3.metric(
        "Maior Venda",
        f"US$ {maior_venda:,.2f}"
    )

    col4.metric(
        "Quantidade de Lojas",
        quantidade_lojas
    )

    st.markdown("---")

    # Gráficos
    grafico_feriados(df)
    grafico_lojas(df)
    grafico_ano(df)
    grafico_mes(df)
				
			
indicadores

Conclusão

Neste tutorial, você aprendeu como criar um Dashboard de Vendas com Python e Streamlit utilizando dados armazenados em um arquivo CSV. Criamos quatro funções completas no arquivo graficos.py, cada uma responsável por uma visualização diferente. Também utilizamos o Pandas para agrupar e analisar as informações e o Matplotlib para construir gráficos de barras, pizza, linha e barras horizontais. Por fim, utilizamos o Streamlit para exibir os indicadores e transformar nossa análise em uma aplicação visual.

Posts Similares

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *