[Python] como posso colocar constantes para substituir a repetição nas fórmulas de cálculo

Boa tarde. Sou bem iniciante em Python e gostaria de saber como posso colocar constantes no meu código para que eu não precise colocar o número de uma coluna toda vez que eu vou definir o resultado de uma expressão.

import tkinter as tk
from tkinter import filedialog
import pandas as pd

def carregar_csv():
caminho_arquivo = filedialog.askopenfilename(
filetypes=[("Arquivos CSV", "*.csv")],
title="Selecione o arquivo CSV"
)
if caminho_arquivo:
try:
df = pd.read_csv(caminho_arquivo, skiprows=2, delimiter=';')

# Diagnóstico dos tipos de dados das colunas
print("Tipos de dados antes da conversão:")
print(df.dtypes)

# Converte para string se necessário
if df.iloc[:, 0].dtype not in ['object', 'string']:
df.iloc[:, 0] = df.iloc[:, 0].astype(str)
if df.iloc[:, 1].dtype not in ['object', 'string']:
df.iloc[:, 1] = df.iloc[:, 1].astype(str)

# Converte a coluna 13 para numérico, se necessário
if not pd.api.types.is_numeric_dtype(df.iloc[:, 13]):
df.iloc[:, 13] = pd.to_numeric(df.iloc[:, 13], errors='coerce')

# Diagnóstico dos tipos de dados após conversão
print("Tipos de dados após a conversão:")
print(df.dtypes)

# Filtra os dados
df_filtrado = df[df.iloc[:, 14] == 'ending_balance']

# Aplica os cálculos
resultados = {
'Poder Executivo': calcular_prefeitura_municipal(df_filtrado),
'Poder Legislativo': calcular_camara_municipal(df_filtrado),
'Previdência Própria': calcular_previdencia_social(df_filtrado),
'Consolidado': calcular_poder_executivo(df_filtrado),
'Total do Ativo': calcular_total_ativo(df_filtrado),
'Total do Ativo Financeiro': calcular_ativo_financeiro(df_filtrado),
'Ativo Financeiro - Contas 8': calcular_AF_contas_controle(df_filtrado),
'Total do Passivo': calcular_resultado_passivo(df_filtrado),
'VPD': calcular_vpd(df_filtrado),
'VPA': calcular_vpa(df_filtrado),
'Ativo - Passivo (Resultado do Exercício)': calcular_pvpd_vpa(df_filtrado),
'PC sem Consignações': calcular_passivo_circulante_sem_2188(df_filtrado),
'PC sem Consignações - CC': calcular_pc_sem_2188_821130100(df_filtrado),
'Parcelamento PREVI - PREFEITURA': calcular_parcelamento_previ(df_filtrado),
'Duodécimo PREFEITURA - CÂMARA': calcular_duodécimo_cm_pm(df_filtrado),
'Consignações': calcular_consignacoes(df_filtrado),
'Consignações - Conta Controle' : calcular_consignacoes_821130200(df_filtrado),
'Receita Prevista': calcular_receita_prevista(df_filtrado),
'Receita Atualizada': calcular_receita_atualizada(df_filtrado),
'Receita Arrecadada': calcular_receita_arrecadada(df_filtrado),
'RP não Processado Inscrito em 2023': calcular_rp_nao_processado_2023(df_filtrado),
'RP não Processado Inscrito Exercícios Anteriores': calcular_rp_nao_processado_anterior(df_filtrado),
'RP Processado Inscrito em 2023': calcular_rp_processado_2023(df_filtrado),
'RP Processado Inscrito Exercícios Anteriores': calcular_rp_processado_anterior(df_filtrado),
'Crédito Disponível': calcular_credito_disponivel(df_filtrado),
'Dotação Inicial': calcular_dotacao_inicial(df_filtrado),
'Dotação Atualizada': calcular_dotacao_atualizada(df_filtrado),
'Empenhado a Liquidar': calcular_empenhado_liquidar(df_filtrado),
'Empenhado a Pagar': calcular_empenhado_pagar(df_filtrado),
'Empenhado Pago': calcular_empenhado_pago(df_filtrado),
'RP não Processado Saldo': calcular_rp_nao_processado_saldo(df_filtrado),
'RP não Processado Pago': calcular_rp_nao_processado_pago(df_filtrado),
'RP não Processado Anulado': calcular_rp_nao_processado_anulado(df_filtrado),
'RP Processado Saldo': calcular_rp_processado_saldo(df_filtrado),
'RP Processado Pago': calcular_rp_processado_pago(df_filtrado),
'RP Processado Anulado': calcular_rp_processado_anulado(df_filtrado)
}

mostrar_resultados(resultados)
resultado_label.config(text="Resultados calculados com sucesso.")
except Exception as e:
resultado_label.config(text=f"Erro ao carregar o arquivo CSV: {e}")

def calcular_prefeitura_municipal(df):
df_filtrado = df[(df.iloc[:, 0].str.startswith('111')) & (df.iloc[:, 1] == '10131')]
valor_d = df_filtrado[df_filtrado.iloc[:, 15] == 'D'].iloc[:, 13].sum()
valor_c = df_filtrado[df_filtrado.iloc[:, 15] == 'C'].iloc[:, 13].sum()
return valor_d - valor_c

def calcular_camara_municipal(df):
df_filtrado = df[(df.iloc[:, 0].str.startswith('111')) & (df.iloc[:, 1] == '20231')]
valor_d = df_filtrado[df_filtrado.iloc[:, 15] == 'D'].iloc[:, 13].sum()
valor_c = df_filtrado[df_filtrado.iloc[:, 15] == 'C'].iloc[:, 13].sum()
return valor_d - valor_c

def calcular_previdencia_social(df):
df_filtrado = df[(df.iloc[:, 0].str.startswith('111')) & (df.iloc[:, 1] == '10132')]
valor_d = df_filtrado[df_filtrado.iloc[:, 15] == 'D'].iloc[:, 13].sum()
valor_c = df_filtrado[df_filtrado.iloc[:, 15] == 'C'].iloc[:, 13].sum()
return valor_d - valor_c

def calcular_total_ativo(df):
valor_d = df[(df.iloc[:, 0].str.startswith('1')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
valor_c = df[(df.iloc[:, 0].str.startswith('1')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
return valor_d - valor_c

def calcular_ativo_financeiro(df):
resultado_caixa = calcular_poder_executivo(df)
adiantamentos_113 = df[(df.iloc[:, 0].str.startswith('113')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
adiantamentos_114 = df[(df.iloc[:, 0].str.startswith('114')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
return resultado_caixa + adiantamentos_113 + adiantamentos_114

def calcular_AF_contas_controle(df):
resultado_AF = calcular_ativo_financeiro(df)
valor_821110100c = df[(df.iloc[:, 0].str.startswith('821110100')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_821110100d = df[(df.iloc[:, 0].str.startswith('821110100')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
valor_outras = df[(df.iloc[:, 0].str.startswith(('821120100', '821130100', '821130200')))].iloc[:, 13].sum()
return resultado_AF - (valor_821110100c - valor_821110100d) - valor_outras

def calcular_resultado_passivo(df):
valor_c = df[(df.iloc[:, 0].str.startswith('2')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_d = df[(df.iloc[:, 0].str.startswith('2')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
return valor_c - valor_d

def calcular_consignacoes(df):
return df[df.iloc[:, 0].str.startswith('2188')].iloc[:, 13].sum()

def calcular_consignacoes_821130200(df):
consignacoes = calcular_consignacoes(df)
conta_controle = df[df.iloc[:, 0].str.startswith('821130200')].iloc[:, 13].sum()
return consignacoes - conta_controle

def calcular_passivo_circulante_sem_2188(df):
consignacoes = calcular_consignacoes(df)
passivo_circulante = df[df.iloc[:, 0].str.startswith('21')].iloc[:, 13].sum()
return passivo_circulante - consignacoes

def calcular_pc_sem_2188_821130100(df):
calcular_pc_sem_2188 = calcular_passivo_circulante_sem_2188(df)
conta_controle = df[df.iloc[:, 0].str.startswith('821130100')].iloc[:, 13].sum()
return calcular_pc_sem_2188 - conta_controle

def calcular_parcelamento_previ(df):
calcular_parcelamento_previ = df[df.iloc[:, 0].str.startswith('121120604')].iloc[:, 13].sum()
calcular_parcelamento_pref = df[df.iloc[:, 0].str.startswith('221420201')].iloc[:, 13].sum()
return calcular_parcelamento_previ - calcular_parcelamento_pref

def calcular_duodécimo_cm_pm(df):
calcular_duodécimo_pref = df[df.iloc[:, 0].str.startswith('351120200','351120400')].iloc[:, 13].sum()
calcular_duodécimo_câmara = df[df.iloc[:, 0].str.startswith('451120200','451120400')].iloc[:, 13].sum()
return calcular_duodécimo_pref - calcular_duodécimo_câmara

def calcular_vpd(df):
valor_vpd = df[(df.iloc[:, 0].str.startswith('3')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
return valor_vpd

def calcular_vpa(df):
valor_vpa = df[(df.iloc[:, 0].str.startswith('4')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
return valor_vpa

def calcular_pvpd_vpa(df):
resultado_passivo = calcular_resultado_passivo(df)
vpd = calcular_vpd(df)
vpa = calcular_vpa(df)
total_do_ativo = calcular_total_ativo(df)
return total_do_ativo - resultado_passivo + vpd - vpa

def calcular_poder_executivo(df):
prefeitura_municipal = calcular_prefeitura_municipal(df)
camara_municipal = calcular_camara_municipal(df)
previdencia_social = calcular_previdencia_social(df)
return prefeitura_municipal + camara_municipal + previdencia_social

def calcular_receita_prevista(df):
valor_52111 = df[df.iloc[:, 0].str.startswith('52111')].iloc[:, 13].sum()
valor_52112 = df[df.iloc[:, 0].str.startswith('52112')].iloc[:, 13].sum()
return valor_52111 - valor_52112

def calcular_receita_atualizada(df):
valor_5212 = df[(df.iloc[:, 0].str.startswith('5212')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_52121 = df[(df.iloc[:, 0].str.startswith('5212')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
valor_52111 = df[df.iloc[:, 0].str.startswith('52111')].iloc[:, 13].sum()
valor_52112 = df[df.iloc[:, 0].str.startswith('52112')].iloc[:, 13].sum()

return valor_52121 - valor_5212 + valor_52111 - valor_52112

def calcular_receita_arrecadada(df):
valor_6212_c = df[(df.iloc[:, 0].str.startswith('6212')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_6213_d = df[(df.iloc[:, 0].str.startswith('6213')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
return valor_6212_c - valor_6213_d

def calcular_dotacao_inicial(df):
valor_5221_c = df[(df.iloc[:, 0].str.startswith('52211')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_5221_d = df[(df.iloc[:, 0].str.startswith('52211')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
return valor_5221_d - valor_5221_c

def calcular_dotacao_atualizada(df):

valor_5221_c = df[(df.iloc[:, 0].str.startswith('52211')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_5221_d = df[(df.iloc[:, 0].str.startswith('52211')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()

valor_52212_c = df[(df.iloc[:, 0].str.startswith('52212')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_52212_d = df[(df.iloc[:, 0].str.startswith('52212')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()

valor_52213_c = df[(df.iloc[:, 0].str.startswith('52213')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_52213_d = df[(df.iloc[:, 0].str.startswith('52213')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()

valor_52219_c = df[(df.iloc[:, 0].str.startswith('52219')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_52219_d = df[(df.iloc[:, 0].str.startswith('52219')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()


return valor_5221_d - valor_5221_c + valor_52212_d - valor_52212_c + valor_52213_d - valor_52213_c + valor_52219_d - valor_52219_c

def calcular_credito_disponivel(df):
valor_62211_c = df[(df.iloc[:, 0].str.startswith('62211')) & (df.iloc[:, 15] == 'C')].iloc[:, 13].sum()
valor_62211_d = df[(df.iloc[:, 0].str.startswith('62211')) & (df.iloc[:, 15] == 'D')].iloc[:, 13].sum()
return valor_62211_c - valor_62211_d

def calcular_rp_nao_processado_2023(df):
return df[df.iloc[:, 0].str.startswith('5311')].iloc[:, 13].sum()

def calcular_rp_nao_processado_anterior(df):
return df[df.iloc[:, 0].str.startswith('5312')].iloc[:, 13].sum()

def calcular_rp_processado_2023(df):
return df[df.iloc[:, 0].str.startswith('5321')].iloc[:, 13].sum()

def calcular_rp_processado_anterior(df):
return df[df.iloc[:, 0].str.startswith('5322')].iloc[:, 13].sum()

def calcular_empenhado_liquidar(df):
return df[df.iloc[:, 0] == '622130100'].iloc[:, 13].sum()

def calcular_empenhado_pagar(df):
return df[df.iloc[:, 0] == '622130300'].iloc[:, 13].sum()

def calcular_empenhado_pago(df):
return df[df.iloc[:, 0] == '622130400'].iloc[:, 13].sum()

def calcular_rp_nao_processado_saldo(df):
return df[df.iloc[:, 0].str.startswith(('6311', '6313'))].iloc[:, 13].sum()

def calcular_rp_nao_processado_pago(df):
return df[df.iloc[:, 0].str.startswith('6314')].iloc[:, 13].sum()

def calcular_rp_nao_processado_anulado(df):
return df[df.iloc[:, 0].str.startswith('6319')].iloc[:, 13].sum()

def calcular_rp_processado_saldo(df):
return df[df.iloc[:, 0].str.startswith('6321')].iloc[:, 13].sum()

def calcular_rp_processado_pago(df):
return df[df.iloc[:, 0].str.startswith('6322')].iloc[:, 13].sum()

def calcular_rp_processado_anulado(df):
return df[df.iloc[:, 0].str.startswith('6329')].iloc[:, 13].sum()

def mostrar_resultados(resultados):
global resultado_frame
# Limpa a área de resultados antes de adicionar novos blocos
resultado_frame.pack_forget()

# Configura o frame principal para os resultados
resultado_frame = tk.Frame(root, bg="#F0F8FF")
resultado_frame.pack(pady=10, padx=10, fill='both', expand=True)

def criar_bloco(titulo, itens):
frame = tk.Frame(resultado_frame, bd=2, relief="groove", bg="#F0F8FF")
frame.pack(side='left', padx=10, pady=5, fill='y', expand=True)

titulo_label = tk.Label(frame, text=titulo, font=("Arial", 14, "bold"), bg="#F0F8FF")
titulo_label.pack(pady=5)

for key, value in itens.items():
label = tk.Label(frame, text=f"{key}: {value:,.2f}", font=("Arial", 12), bg="#F0F8FF", anchor="w")
label.pack(fill='x', padx=10, pady=3)

resultados_caixa = {
'Poder Executivo': resultados['Poder Executivo'],
'Poder Legislativo': resultados['Poder Legislativo'],
'Previdência Própria': resultados['Previdência Própria'],
'Consolidado': resultados['Consolidado']
}

resultados_patrimonial = {
'Total do Ativo': resultados['Total do Ativo'],
'Total do Ativo Financeiro': resultados['Total do Ativo Financeiro'],
'Total do Passivo': resultados['Total do Passivo'],
'PC sem Consignações': resultados['PC sem Consignações'],
'Consignações': resultados['Consignações'],
'VPD': resultados['VPD'],
'VPA': resultados['VPA'],
'Consignações - Conta Controle': resultados['Consignações - Conta Controle'],
'PC sem Consignações - CC': resultados['PC sem Consignações - CC'],
'Ativo Financeiro - Contas 8': resultados['Ativo Financeiro - Contas 8'],
'Parcelamento PREVI - PREFEITURA': resultados['Parcelamento PREVI - PREFEITURA'],
'Duodécimo PREFEITURA - CÂMARA': resultados['Duodécimo PREFEITURA - CÂMARA'],
'Ativo - Passivo (Resultado do Exercício)': resultados['Ativo - Passivo (Resultado do Exercício)']

}

resultados_receita = {
'Receita Prevista': resultados['Receita Prevista'],
'Receita Atualizada' : resultados['Receita Atualizada'],
'Receita Arrecadada': resultados['Receita Arrecadada']
}

resultados_restos = {
'RP não Processado Inscrito em 2023': resultados['RP não Processado Inscrito em 2023'],
'RP não Processado Inscrito Exercícios Anteriores': resultados['RP não Processado Inscrito Exercícios Anteriores'],
'RP não Processado Pago': resultados['RP não Processado Pago'],
'RP não Processado Anulado': resultados['RP não Processado Anulado'],
'RP não Processado Saldo': resultados['RP não Processado Saldo'],
'RP Processado Inscrito em 2023': resultados['RP Processado Inscrito em 2023'],
'RP Processado Inscrito Exercícios Anteriores': resultados['RP Processado Inscrito Exercícios Anteriores'],
'RP Processado Pago': resultados['RP Processado Pago'],
'RP Processado Anulado': resultados['RP Processado Anulado'],
'RP Processado Saldo': resultados['RP Processado Saldo']


}

resultados_despesa = {
'Dotação Inicial': resultados['Dotação Inicial'],
'Dotação Atualizada' : resultados['Dotação Atualizada'],
'Crédito Disponível': resultados['Crédito Disponível'],
'Empenhado a Liquidar': resultados['Empenhado a Liquidar'],
'Empenhado a Pagar': resultados['Empenhado a Pagar'],
'Empenhado Pago': resultados['Empenhado Pago']
}

criar_bloco("Resultado do Caixa", resultados_caixa)
criar_bloco("Situação Patrimonial", resultados_patrimonial)
criar_bloco("Execução da Receita", resultados_receita)
criar_bloco("Execução dos Restos a Pagar", resultados_restos)
criar_bloco("Execução da Despesa", resultados_despesa)

def reiniciar_importacao():
# Reinicia a importação limpando a tela e resetando as variáveis
for widget in root.winfo_children():
widget.destroy()
iniciar_interface()

def iniciar_interface():
# Título
title = tk.Label(root, text="Sistema de Análise Matricial", font=("Arial", 20, "bold"), fg="#006400")
title.pack(pady=10)

# Descrição
descricao = tk.Label(root, text="Por favor, carregue um arquivo CSV para iniciar.",
font=("Arial", 14), fg="#2F4F4F")
descricao.pack(pady=10)

# Botão de Carregar CSV
botao_carregar = tk.Button(root, text="Carregar CSV", command=carregar_csv,
width=25, height=2, font=("Arial", 12), bg="#4682B4", fg="white")
botao_carregar.pack(pady=5)

# Botão de Reiniciar Importação
botao_reiniciar = tk.Button(root, text="Reiniciar Importação", command=reiniciar_importacao,
width=25, height=2, font=("Arial", 12), bg="#B22222", fg="white")
botao_reiniciar.pack(pady=5)

global resultado_label
resultado_label = tk.Label(root, text="", font=("Arial", 12), fg="red")
resultado_label.pack(pady=10)

global resultado_frame
resultado_frame = tk.Frame(root, bg="#F0F8FF")
resultado_frame.pack(pady=10, padx=10, fill='both', expand=True)

# Inicializa a interface Tkinter
root = tk.Tk()
root.title("Análise de MSC")
root.geometry("800x600")
root.configure(bg="#F0F8FF")

iniciar_interface()

root.mainloop()


Ele funciona normalmente mas acho que fazendo essas constantes poderia melhorar. Além disso, queria adicionar um botão que antes de tudo ser feito eu pudesse selecionar qual o valor da segunda coluna que eu quero aplicar os cálculos, tipo assim, selecionava só calcularia os valores que na segunda coluna tem o valor x ou todos os valores juntos.

Continue reading...