Inteligência de dados: Unindo Data Analytics e Business Intelligence para Decisões estratégicas
Os desafios de negócios modernos atualmente estão tendo como necessidade se utilizar de técnicas de data analytics e de ferramentas de business intelligence, mas antes de mostrar exemplos práticos, precisamos entender o significado desses termos
O que seria data analytics?
Data analytics é uma metodologia científica que é utilizada para analisar dados em larga escala, que consiste em investigar os dados procurando com isso identificar padrões, tendências e insights que possam ser utilizados para tomar decisões mais assertivas e melhorar os resultados de uma empresa.
Tem como objetivo responder perguntas para resolver problemas de negócios para que assim as pessoas possam tomar decisões orientadas por dados.
Exemplo de um projeto de Data analytics: Prevenção de Churn de Clientes
Objetivo: Desenvolver um modelo preditivo capaz de identificar clientes com alta probabilidade de churn (cancelamento do serviço ou produto) para que a empresa possa implementar estratégias de retenção proativas.
Situação hipotética: Uma empresa está perdendo clientes e quer entender os fatores que levam ao churn e, mais importante, prever quem vai cancelar antes que isso aconteça.
Solução: Construir um modelo de classificação usando dados históricos de clientes, incluindo informações sobre suas interações, frequência de uso do serviço/produto e histórico de reclamações.
Ferramentas: Python, usando primeiramente as bibliotecas Pandas para manipulação de dados, tendo como foco a biblioteca Scikit-learn para construção e avaliação do modelo, e Matplotlib/Seaborn para visualização.
Potencial de valor gerado para a empresa : A empresa pode antecipar o churn de cliente, o marketing pode direcionar campanhas de retenção personalizadas (ofertas especiais, suporte proativo, etc.) para os clientes em risco, e assim reduzir a taxa de cancelamento e aumentando a receita.
Exemplo de codigo em Python
# 1. Importação de Bibliotecas Necessárias
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
# 2. Carregamento dos Dados
# Para este exemplo, vamos simular dados. Em um projeto real, você carregaria um CSV, banco de dados, etc. Preparação dos Dados: é necessário coletar dados relevantes e efetuar a etapa de pré-processamento (limpeza, tratamento de valores ausentes, etc)
#Suponha que você tem um arquivo CSV chamado 'dados_clientes.csv'
# df = pd.read_csv('dados_clientes.csv')
# Criando um DataFrame de exemplo para ilustrar o processo
import numpy as np
np.random.seed(42)
num_clientes = 1000
dados = {
'cliente_id': range(1, num_clientes + 1),
'idade': np.random.randint(20, 70, num_clientes),
'tempo_servico_meses': np.random.randint(1, 60, num_clientes),
'frequencia_uso': np.random.rand(num_clientes) * 10, # Ex: número de acessos por semana
'num_reclamacoes': np.random.randint(0, 5, num_clientes),
'valor_mensal': np.random.uniform(20, 200, num_clientes),
'plano_premium': np.random.choice([0, 1], num_clientes, p=[0.7, 0.3]), # 0=Não, 1=Sim
'suporte_utilizado_ult_mes': np.random.randint(0, 10, num_clientes),
'churn': np.random.choice([0, 1], num_clientes, p=[0.85, 0.15]) # 0=Não Churn, 1=Churn
}
df = pd.DataFrame(dados)
# Criando uma correlação para o churn
df.loc[df['tempo_servico_meses'] < 12, 'churn'] = np.random.choice([0, 1], sum(df['tempo_servico_meses'] < 12), p=[0.7, 0.3])
df.loc[df['num_reclamacoes'] > 2, 'churn'] = np.random.choice([0, 1], sum(df['num_reclamacoes'] > 2), p=[0.5, 0.5])
print("\nPrimeiras 5 linhas do DataFrame:")
print(df.head())
print(f"\nFormato do DataFrame: {df.shape}")
# 3. Análise Exploratória de Dados (EDA) - Opcional, mas Altamente Recomendado pois ela ajuda a entender os dados e as relações entre as variáveis
# Nesta etapa, você exploraria os dados para entender suas características, distribuições, outliers, etc.
# Ex: Distribuição de churn
plt.figure(figsize=(6, 4))
sns.countplot(x='churn', data=df)
plt.title('Distribuição de Churn (0=Não, 1=Sim)')
plt.xlabel('Churn')
plt.ylabel('Número de Clientes')
plt.show()
# Ex: Correlação entre variáveis (Heatmap)
plt.figure(figsize=(10, 8))
sns.heatmap(df.drop('cliente_id', axis=1).corr(), annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlação')
plt.show()
# 4. Pré-processamento dos Dados
# Definição de features (X) e target (y)
X = df.drop(['cliente_id', 'churn'], axis=1) # Remover ID do cliente e a variável target
y = df['churn']
# Divisão dos dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
print(f"\nShape de X_train: {X_train.shape}, Shape de X_test: {X_test.shape}")
# Escalonamento das features (muito importante para muitos modelos de ML)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
print("\nDados pré-processados e divididos em conjuntos de treino e teste.")
# 5. Treinamento do Modelo Preditivo
# Utilizando Regressão Logística como exemplo (modelo simples e eficaz para classificação)
model = LogisticRegression(random_state=42)
model.fit(X_train_scaled, y_train)
print("\nModelo de Regressão Logística treinado com sucesso!")
# 6. Avaliação do Modelo
# Previsões no conjunto de teste
y_pred = model.predict(X_test_scaled)
# Métricas de avaliação
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)
print(f"\nAcurácia do modelo: {accuracy:.4f}")
print("\nMatriz de Confusão:")
print(conf_matrix)
print("\nRelatório de Classificação:")
print(class_report)
# Visualização da Matriz de Confusão
plt.figure(figsize=(6, 5))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues',
xticklabels=['Não Churn', 'Churn'], yticklabels=['Não Churn', 'Churn'])
plt.xlabel('Previsto')
plt.ylabel('Real')
plt.title('Matriz de Confusão')
plt.show()
Isso é apenas um exemplo de código, você precisa ter um arquivo csv ou criar um arquivo de planilhas para o seu projeto.
Business Intelligence (BI)refere-se ao processo de coleta, organização, análise, compartilhamento e monitoramento de informações que oferecem suporte à gestão de negócios.
O grande desafio de qualquer projeto envolvendo BI é efetuar o ETL (Extract, Transform, Load = extração dos dados, transformação dos dados e carregamento dos dados) e após isso efetuar o storytelling com sucesso para que as pessoas de negócio consigam ter informações claras para tomar decisões assertivas.
O Storytelling é a arte de contar histórias, ou seja contar de forma lúdica ou com uma linguagem acessível ao público que irá interpretar os resultados do seu projeto de business intelligence
Vou usar um exemplo de um projeto de business intelligence voltado ao ambiente contábil
Painel de Controle Financeiro na Contabilidade: Exemplo Prático com Excel/ Power BI/ Python
Contexto de Negócio
Um escritório de contabilidade que atende pequenas empresas frequentemente se depara com um desafio comum: seus clientes têm dificuldade em interpretar as demonstrações contábeis mensais. Embora as informações sejam entregues, a linguagem técnica e a formatação tradicional impedem que gestores não técnicos visualizem facilmente o desempenho financeiro e tomem decisões embasadas.
Solução Proposta: Painel Interativo em Power BI
A solução é a criação de um painel interativo no Power BI que atua como uma ponte entre os dados contábeis brutos e a compreensão gerencial. Esse painel transforma lançamentos e demonstrações complexas em informações visuais, intuitivas e acionáveis.
Fontes de Dados Essenciais
Para construir um painel robusto, diversas fontes de dados contábeis são integradas:
- Balancete de Verificação: Essencial para a base de receitas, despesas e saldos de contas.
- Livro Razão: Permite detalhar os lançamentos e entender a movimentação de cada conta.
- Demonstrações Contábeis (DRE e Balanço Patrimonial): Fornecem as estruturas consolidadas de desempenho e posição financeira.
- Planilhas Excel com Dados Auxiliares: Podem incluir orçamentos, metas, dados de vendas por produto/serviço, custos específicos não detalhados na contabilidade principal, etc.
Indicadores Chave a Serem Incluídos no Painel
O painel deve focar nos indicadores mais relevantes para a tomada de decisão do gestor da pequena empresa:
Indicador
Descrição
Receita por Mês
Mostra a tendência de faturamento
Lucro Líquido
Apresenta o resultado real de cada período após todas as deduções de impostos.
Custos Fixos e Variáveis
Separação clara das despesas para entender a estrutura de custos da empresa.
Índice de Endividamento
Avalia a saúde financeira da empresa em relação às suas dívidas.
Margem de Contribuição
Indica a eficiência operacional por produto ou serviço, essencial para precificação.
Comparativo entre Períodos
Permite visualizar a evolução mês a mês ou ano a ano, identificando tendências.
Simulação de Impostos
Projeção tributária para diferentes regimes, auxiliando no planejamento fiscal.
Fontes de dados:
Tabela 1- Balanço Patrimonial
Tabela 2- Modelo da Demonstração do Resultado do Exercício
Vamos detalhar as etapas essenciais para a execução de um projeto de BI com essas fontes de dados:
1. Definição de Objetivos e Indicadores (KPIs)
Entender a Necessidade do Cliente: Antes de tudo, é crucial conversar com os clientes (as pequenas empresas) para entender quais são suas maiores dores e dúvidas financeiras. O que eles gostariam de saber sobre suas finanças que os relatórios atuais não mostram claramente?
Definir os KPIs (Key Performance Indicators): Com base nas necessidades, selecione os indicadores mais relevantes que podem ser calculados a partir da DRE e do Balanço Patrimonial. faça o mapeamento das perguntas de negócio que o relatório final do projeto deve responder: "Qual a tendência de lucratividade trimestral?", "Como a empresa evoluiu anualmente em termos de lucro?").
Mapeamento de KPIs: Traduzir as necessidades de negócio em KPIs mensuráveis. Para DRE e BP, exemplos incluem:
DRE: Receita Líquida, Lucro Bruto, Lucro Líquido, Margem Bruta, Margem Líquida, Despesas por Categoria (Vendas, Administrativas, Financeiras).
Balanço Patrimonial: Ativo Total, Passivo Total, Patrimônio Líquido, Ativo Circulante, Passivo Circulante, Liquidez Corrente, Endividamento Geral, Participação do Capital Próprio.
Combinados: Retorno sobre o Ativo (ROA), Retorno sobre o Patrimônio Líquido (ROE) – embora esses exijam dados de ambos os relatórios.
Perguntas a Responder: Os KPIs devem responder a perguntas como: "Estamos sendo lucrativos?", "Qual a nossa capacidade de pagar dívidas de curto prazo?", "Como nossas despesas se comportam ao longo do tempo?", "Qual a nossa estrutura de capital?".
2. Coleta e Extração dos Dados (ETL - Extract)
Identificação das Fontes de Dados: As principais fontes serão as DREs e Balanços Patrimoniais dos clientes. Idealmente, esses dados viriam de um software contábil (ERP, sistema próprio do escritório). No caso de dados em planilhas (como os exemplos que você forneceu), elas serão a fonte inicial.
Formato: Para Power BI (ou qualquer ferramenta de BI), é fundamental que os dados estejam em um formato tabular (linhas e colunas), como um arquivo CSV ou uma tabela em um banco de dados.
Extração: Se os dados estiverem em planilhas, a extração é direta. Se estiverem em sistemas, pode ser necessário usar conectores específicos ou exportar relatórios.
3. Transformação e Limpeza dos Dados (ETL - Transform)
Esta é a etapa mais crítica para garantir a qualidade e usabilidade dos dados.
Padronização: As DREs e BPs podem ter diferentes layouts ou nomenclaturas entre clientes ou períodos. É vital padronizar as contas (ex: "Receita Bruta de Vendas" para "Receita Operacional Bruta").
Tratamento de Valores: Garantir que os valores numéricos sejam reconhecidos como tal (remover R$, pontos, vírgulas, etc., e converter para formato numérico).
Estruturação: Transformar a estrutura do relatório contábil (que geralmente é hierárquica) em um formato "plano" ou "tabular", onde cada linha representa uma conta contábil para um determinado período.
Exemplo DRE: Uma tabela com colunas como Conta Contábil, Tipo (Receita, Custo, Despesa), Valor, Período (Data).
Exemplo BP: Uma tabela com colunas como Conta Contábil, Tipo (Ativo Circulante, Passivo Não Circulante, etc.), Valor, Data (do Balanço).
Criação de Colunas Auxiliares: Adicionar colunas para facilitar a análise, como Ano, Mês, Trimestre, Tipo de Cliente, etc.
Tratamento de Sinais: Na DRE, despesas e custos são geralmente apresentados como valores negativos. É importante manter essa convenção ou ajustá-la para que os cálculos de margem funcionem corretamente.
4. Carregamento dos Dados (ETL - Load)
Para o Power BI: Os dados transformados são carregados para o modelo de dados do Power BI. O Power Query (ferramenta de ETL do Power BI) é ideal para realizar todas as transformações mencionadas na etapa anterior.
5. Modelagem de Dados
Relacionamentos: Se você tiver múltiplas tabelas (ex: uma para DRE, outra para BP, e talvez uma tabela de calendário), é fundamental criar relacionamentos entre elas no Power BI (ex: usando a coluna Data ou Período). Isso permite que os filtros e cálculos funcionem de forma cruzada entre os relatórios.
Hierarquias: Criar hierarquias de tempo (Ano > Trimestre > Mês) ou de contas contábeis (Ativo > Ativo Circulante > Disponibilidades) para permitir que o usuário "navegue" pelos dados.
6. Cálculos e Medidas (DAX no Power BI)
Criação de Medidas: No Power BI, você usará a linguagem DAX (Data Analysis Expressions) para criar as fórmulas dos KPIs.
Ex: Margem Bruta = DIVIDE([Lucro Operacional Bruto], [Receita Operacional Líquida])
Ex: Liquidez Corrente = DIVIDE([Ativo Circulante], [Passivo Circulante])
Cálculos de Variação: Medidas para calcular a variação percentual ou absoluta entre períodos (ex: Variação Receita = [Receita Atual] - [Receita Anterior]).
7. Criação do Painel (Dashboards e Visualizações)
Layout Intuitivo: Organize as visualizações de forma lógica e limpa. Agrupe indicadores relacionados.
Visualizações Adequadas:
Gráficos de Linha: Para mostrar a evolução da Receita, Lucro, Ativo Total ao longo do tempo.
Gráficos de Barra: Para comparar despesas por categoria ou a composição de ativos/passivos.
Gráficos de Pizza/Rosca: Para mostrar a proporção de cada item em um total (ex: composição do Ativo Circulante).
Cartões (Cards): Para exibir os valores atuais de KPIs importantes (Lucro Líquido, Liquidez Corrente).
Tabelas/Matrizes: Para exibir os detalhes da DRE e BP de forma organizada, com a possibilidade de expandir e recolher.
Filtros Interativos: Adicionar filtros por cliente (se o painel for multi-cliente), período (ano, mês), tipo de conta, etc., para que o usuário possa explorar os dados.
Cores e Estilo: Usar uma paleta de cores consistente e agradável, que facilite a leitura e destaque as informações importantes.
8. Análise e Geração de Insights
Interpretação: O painel não é apenas sobre números, mas sobre o que eles significam. O contador pode usá-lo para:
Identificar tendências de queda na receita ou aumento de custos.
Analisar a saúde financeira da empresa e sua capacidade de investimento.
Detectar anomalias (ex: um aumento inesperado em uma despesa).
Comparar o desempenho atual com períodos anteriores ou com metas.
Recomendações: Com base nos insights, o contador pode oferecer recomendações proativas ao cliente, como: "Sua margem bruta está caindo, precisamos revisar seus custos de produção", ou "Sua liquidez corrente está baixa, vamos analisar suas contas a receber".
9. Compartilhamento e Colaboração
Publicação: Publicar o painel no serviço do Power BI para que os clientes possam acessá-lo online (com as devidas permissões de segurança).
Treinamento: Oferecer um breve treinamento aos clientes sobre como navegar e interpretar o painel.
Feedback: Coletar feedback dos clientes para aprimorar o painel continuamente.
Ao seguir essas etapas, um escritório contábil pode transformar dados brutos de DRE e Balanço Patrimonial em uma ferramenta de inteligência de negócios valiosa, fortalecendo o relacionamento com o cliente e elevando o nível dos serviços prestados.
Para dar um exemplo para esse projeto, eu decidi criar um dashboard em python mesmo usando as seguintes bibliotecas:
bibliotecas pandas para manipulação de dados e plotly para visualização interativa, além de dash para construir o dashboard.
Construção e organização dos dados com a biblioteca pandas
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from dash import Dash, dcc, html, Input, Output
# Dados do Balanço Patrimonial
bp_data = {
'Conta': ['Disponibilidades', 'Duplicatas a Receber', 'Estoques', 'Dupl. a Receber', 'Investimentos', 'Imobilizado', 'Intangível',
'Fornecedores', 'Salários a Pagar', 'IR e CSLL a Pagar', 'Dividendos a Pagar', 'Financiamentos', 'Capital Social', 'Reserva Legal'],
'Tipo': ['Ativo Circulante', 'Ativo Circulante', 'Ativo Circulante', 'Ativo Não Circulante', 'Ativo Não Circulante', 'Ativo Não Circulante', 'Ativo Não Circulante',
'Passivo Circulante', 'Passivo Circulante', 'Passivo Circulante', 'Passivo Circulante', 'Passivo Não Circulante', 'Patrimônio Líquido', 'Patrimônio Líquido'],
'2008': [302, 420, 705, 100, 80, 860, 500, 650, 120, 150, 200, 500, 1000, 347],
'2009': [180, 650, 800, 80, 70, 700, 400, 721, 150, 59, 111, 381, 1000, 458]
}
df_bp = pd.DataFrame(bp_data)
# Desempilhar os anos para facilitar a plotagem
df_bp_melted = df_bp.melt(id_vars=['Conta', 'Tipo'], var_name='Ano', value_name='Valor')
df_bp_melted['Ano'] = df_bp_melted['Ano'].astype(int)
# Dados da DRE para 2009
dre_data = {
'Conta': ['Receita Operacional Bruta (ROB)', 'Com Vendas', 'Com Serviços', 'Deduções da Receita', 'Devolução de Vendas', 'Descontos Incondicionais e Abatimentos',
'Impostos Sobre Vendas - COFINS', 'Impostos Sobre Vendas - PIS s / Faturamento', 'Impostos Sobre Vendas - ICMS', 'Impostos Sobre Vendas - ISS',
'Receita Operacional Líquida (ROL)', 'Custo da Mercadoria Vendida (CMV)', 'Lucro Operacional Bruto (LOB)', 'Despesas Operacionais',
'Despesas Operacionais - Com Vendas', 'Despesas Operacionais - Administrativas', 'Despesas Operacionais - Financeiras',
'Lucro Operacional Líquido (LOL)', 'Outras Receitas / Despesas', 'Outras Receitas', 'Outras Despesas',
'Lucro / Prejuízo antes do Imposto de Renda (LAIR)', 'Provisão do IRPJ', 'Adicional do IRPJ', 'Provisão da CSLL',
'Lucro Antes das Participações (LAPART)', 'Participações', 'Participações - Debêntures', 'Participações - Partes Beneficiárias',
'Participações - Administração', 'Participações - Empregados', 'Lucro / Prejuízo líquido do Exercício (LLE ou PLE)'],
'Valor': [100000, 80000, 20000, -30000, -5000, -2000, -3000, -1000, -18000, -8000,
70000, -40000, 30000, -22000, -5000, -15000, -2000,
8000, 2000, 5000, -3000,
10000, -1500, -1000, -500,
7000, -2407.30, -700, -630, -567, -510.30, 4592.70]
}
df_dre = pd.DataFrame(dre_data)
# Criar uma coluna 'Tipo' para a DRE para categorizar melhor as contas para visualização
def categorizar_dre(conta):
if 'Receita' in conta and 'Deduções' not in conta:
return 'Receita'
elif 'Custo' in conta:
return 'Custo'
elif 'Despesa' in conta:
return 'Despesa'
elif 'Lucro' in conta or 'Prejuízo' in conta or 'Resultado' in conta:
return 'Resultado'
elif 'Imposto' in conta or 'CSLL' in conta:
return 'Impostos'
elif 'Participações' in conta:
return 'Participações'
else:
return 'Outros'
df_dre['Categoria'] = df_dre['Conta'].apply(categorizar_dre)
Construção do Dashboard com Dash
app = Dash(__name__)
app.layout = html.Div([
html.H1("Painel de Controle Financeiro - Estou aprendendo Contabilidade Ltda", style={'textAlign': 'center'}),
html.Hr(),
html.Div([
html.H2("Análise da Demonstração de Resultado do Exercício (DRE) - 2009", style={'textAlign': 'center'}),
html.Div([
dcc.Graph(id='pie-chart-dre-categorias'),
dcc.Graph(id='bar-chart-dre-detalhe')
], style={'display': 'flex', 'flexDirection': 'row', 'width': '100%'}),
html.P("Selecione uma categoria para detalhar:", style={'paddingLeft': '40px'}),
dcc.Dropdown(
id='dre-category-dropdown',
options=[{'label': cat, 'value': cat} for cat in df_dre['Categoria'].unique()],
value='Receita',
clearable=False,
style={'width': '50%', 'margin': '10px 40px'}
),
html.Hr()
]),
html.Div([
html.H2("Análise do Balanço Patrimonial por Ano", style={'textAlign': 'center'}),
html.Div([
dcc.Graph(id='bar-chart-bp-ativo'),
dcc.Graph(id='bar-chart-bp-passivo')
], style={'display': 'flex', 'flexDirection': 'row', 'width': '100%'}),
html.P("Selecione o tipo de conta para o Balanço Patrimonial:", style={'paddingLeft': '40px'}),
dcc.Dropdown(
id='bp-type-dropdown',
options=[{'label': tipo, 'value': tipo} for tipo in df_bp['Tipo'].unique()],
value='Ativo Circulante',
clearable=False,
style={'width': '50%', 'margin': '10px 40px'}
),
html.Hr()
])
])
# Callbacks para o Dashboard DRE
@app.callback(
Output('pie-chart-dre-categorias', 'figure'),
Output('bar-chart-dre-detalhe', 'figure'),
Input('dre-category-dropdown', 'value')
)
def update_dre_charts(selected_category):
# Gráfico de Pizza para Receita e Lucro
df_receita_lucro = df_dre[df_dre['Conta'].isin(['Receita Operacional Líquida (ROL)', 'Lucro Operacional Líquido (LOL)', 'Lucro / Prejuízo líquido do Exercício (LLE ou PLE)'])]
fig_pie = px.pie(df_receita_lucro, values='Valor', names='Conta',
title='Composição da Receita e Lucro (2009)',
hole=0.3,
color_discrete_sequence=px.colors.qualitative.Pastel)
fig_pie.update_traces(textinfo='percent+label', pull=[0.05, 0, 0])
# Gráfico de Barras detalhado por categoria
df_filtered_dre = df_dre[df_dre['Categoria'] == selected_category]
fig_bar = px.bar(df_filtered_dre, x='Conta', y='Valor',
title=f'Detalhamento de {selected_category} (2009)',
color='Valor',
color_continuous_scale=px.colors.sequential.Viridis)
fig_bar.update_layout(xaxis_title="Conta Contábil", yaxis_title="Valor (R$)")
return fig_pie, fig_bar
# Callbacks para o Dashboard Balanço Patrimonial
@app.callback(
Output('bar-chart-bp-ativo', 'figure'),
Output('bar-chart-bp-passivo', 'figure'),
Input('bp-type-dropdown', 'value')
)
def update_bp_charts(selected_type):
df_ativo = df_bp_melted[df_bp_melted['Tipo'].str.contains('Ativo')]
df_passivo = df_bp_melted[df_bp_melted['Tipo'].str.contains('Passivo|Patrimônio Líquido')]
# Gráfico de Barras para Ativo
fig_ativo = px.bar(df_ativo[df_ativo['Tipo'] == selected_type], x='Conta', y='Valor', color='Ano', barmode='group',
title=f'Evolução do {selected_type} (2008 vs 2009)',
facet_col='Ano' if selected_type in ['Ativo Circulante', 'Ativo Não Circulante'] else None)
fig_ativo.update_layout(xaxis_title="Conta Contábil", yaxis_title="Valor (R$)")
# Gráfico de Barras para Passivo
fig_passivo = px.bar(df_passivo[df_passivo['Tipo'] == selected_type], x='Conta', y='Valor', color='Ano', barmode='group',
title=f'Evolução do {selected_type} (2008 vs 2009)',
facet_col='Ano' if selected_type in ['Passivo Circulante', 'Passivo Não Circulante', 'Patrimônio Líquido'] else None)
fig_passivo.update_layout(xaxis_title="Conta Contábil", yaxis_title="Valor (R$)")
return fig_ativo, fig_passivo
if __name__ == '__main__':
app.run_server(debug=True, port=8051)
Executando o Dashboard
Para executar este dashboard, siga os passos:
Instale as bibliotecas necessárias:
Bash
pip install pandas plotly dash
Salve o código: Salve o código Python acima em um arquivo chamado dashboard_financeiro.py.
Execute o arquivo: Abra seu terminal ou prompt de comando, navegue até o diretório onde você salvou o arquivo e execute:
Bash
python dashboard_financeiro.py
Acesse o dashboard: Abra seu navegador web e vá para http://127.0.0.1:8051/ (ou a porta que o terminal indicar).
O que este Dashboard Demonstra
Este exemplo de dashboard Python, embora simplificado, ilustra os princípios fundamentais de um projeto de BI financeiro:
- Extração e Transformação: Os dados das tabelas de DRE e Balanço Patrimonial são "extraídos" e "transformados" em DataFrames do Pandas, que é um formato tabular ideal para análise. A etapa de melt no Balanço Patrimonial é um exemplo de transformação para facilitar a comparação entre anos.
- Modelagem de Dados: Embora simples, a categorização na DRE (df_dre['Categoria']) e a distinção entre Ativo, Passivo e Patrimônio Líquido no Balanço Patrimonial são formas de modelagem que permitem análises mais granulares.
- Cálculos e Medidas: As visualizações são construídas diretamente dos valores fornecidos, mas em um cenário real, você criaria medidas (DAX no Power BI, ou funções Python/Pandas aqui) para calcular KPIs como Margens, Liquidez Corrente, ROA, etc.
- Visualização Interativa:
- DRE: Um gráfico de pizza mostra a proporção da Receita Líquida, Lucro Operacional Líquido e Lucro Líquido. Um gráfico de barras dinâmico (controlado por um dropdown) detalha as contas dentro de uma categoria selecionada (Receita, Despesa, Custo, etc.), permitindo que o gestor explore os componentes.
- Balanço Patrimonial: Gráficos de barras comparam as contas de Ativo e Passivo entre 2008 e 2009, com a opção de filtrar por tipo de conta (Ativo Circulante, Passivo Não Circulante, etc.), mostrando a evolução da estrutura financeira.
- Geração de Insights: Mesmo com esses dados limitados, o painel permitiria ao gestor:
- Ver rapidamente a composição de sua receita e lucro.
- Entender a distribuição de suas despesas.
- Comparar a evolução de suas contas de ativo e passivo ao longo dos anos. Por exemplo, a queda em "Disponibilidades" e "Imobilizado" do Ativo, e a redução em "Financiamentos" do Passivo.
- Compartilhamento: Um aplicativo Dash pode ser publicado e acessado via navegador, permitindo o compartilhamento com os clientes (pequenas empresas) de forma interativa.
Este projeto demonstra a capacidade do Python e de suas bibliotecas para criar soluções de BI robustas e personalizadas, oferecendo uma alternativa flexível ao Power BI para certos casos de uso ou quando há necessidade de maior controle e customização programática.
Espero que esse projeto tenha sido um exemplo claro de como é possível elaborar projetos de business intelligence até mesmo com códigos python
Fontes pesquisadas:
Data Analytics: aplicações da análise de dados nas empresas
Data Analytics: entenda o que é e como funciona - Sebrae
O que é Business Intelligence?
BÄCHTOLD, Ciro. Contabilidade Básica. Curitiba: Instituto Federal do Paraná/Rede e-Tec, 2011.