Curtiu essa calculadora ? Veja também

• Calculadora para balancear seus investimentos
• Calculadora para planejar a amortização do seu financiamento

Quando um ciclo profissional se encerra, entender a matemática por trás da rescisão de contrato é fundamental. A Consolidação das Leis do Trabalho (CLT) possui diretrizes muito precisas sobre o pagamento das verbas rescisórias, exigindo rigor no cálculo de proporções de dias trabalhados, meses acumulados e multas rescisórias.

O valor final que um trabalhador tem a receber depende diretamente do motivo do desligamento. Uma demissão sem justa causa, por exemplo, garante o acesso a todas as verbas (incluindo a multa de 40% sobre o FGTS e o aviso prévio). Por outro lado, um pedido de demissão ou uma dispensa por justa causa alteram drasticamente esses direitos, removendo multas e restringindo saques.

Para a lógica de programação, o maior desafio não está nas operações matemáticas básicas, mas sim no controle das frações de tempo. Pela regra trabalhista, a fração igual ou superior a 15 dias de trabalho no mês dá ao empregado o direito a 1/12 (um doze avos) de Férias e de 13º salário. Além disso, o Aviso Prévio proporcional exige o acréscimo de 3 dias para cada ano completo trabalhado na mesma empresa, limitado a 90 dias.

Traduzir essa legislação para o código exige atenção aos detalhes e uma boa manipulação de datas. A seguir, vamos descomplicar esse algoritmo e criar o nosso próprio motor de cálculo de rescisão utilizando Python.

O algoritmo da rescisão em Python

Para construir nossa calculadora em Python, vamos utilizar a biblioteca nativa datetime para calcular as diferenças exatas entre a data de admissão e a data de demissão. Separamos a lógica em funções modulares, onde cada uma é responsável por uma regra trabalhista específica.

    from datetime import datetime

def calcular_aviso_previo(adm, dem, salario, motivo, aviso_tipo):
    if motivo == "com_justa_causa":
        return 0

    anos = dem.year - adm.year
    if (dem.month, dem.day) < (adm.month, adm.day):
        anos -= 1

    dias = 30 + (anos * 3)
    if dias > 90:
        dias = 90

    valor = (salario / 30) * dias

    if aviso_tipo == "trabalhado": return 0
    if aviso_tipo == "indenizado": return valor
    if aviso_tipo == "nao_cumprido": return -valor 
    return 0

def calcular_13_proporcional(adm, dem, salario):
    ano_dem = dem.year
    meses = dem.month
    
    if dem.day < 15:
        meses -= 1

    if ano_dem == adm.year:
        meses_adm = adm.month
        diff = meses - meses_adm + 1
        if adm.day > 15:
            diff -= 1
        meses = max(0, diff)

    meses = min(max(meses, 0), 12)
    return (salario / 12) * meses

def calcular_ferias_proporcionais(adm, dem, salario):
    anos = dem.year - adm.year
    meses = dem.month - adm.month
    dias = dem.day - adm.day

    if dias < 0:
        meses -= 1
    if meses < 0:
        anos -= 1
        meses += 12

    meses_trabalhados = (anos * 12) + meses
    meses_ferias = meses_trabalhados % 12

    if dias >= 15:
        meses_ferias += 1

    meses_ferias = min(meses_ferias, 12)
    base_ferias = (salario / 12) * meses_ferias
    um_terco = base_ferias / 3

    return base_ferias + um_terco

def calcular_rescisao_clt(salario, saldo_fgts, motivo, aviso, qtd_ferias_vencidas, str_adm, str_dem):
    adm = datetime.strptime(str_adm, "%Y-%m-%d")
    dem = datetime.strptime(str_dem, "%Y-%m-%d")
    
    total_receber = 0
    
    total_receber += (salario / 30) * dem.day
    
    if motivo != "com_justa_causa":
        total_receber += calcular_13_proporcional(adm, dem, salario)
        total_receber += calcular_ferias_proporcionais(adm, dem, salario)
        
    for _ in range(qtd_ferias_vencidas):
        total_receber += salario + (salario / 3)
        
    total_receber += calcular_aviso_previo(adm, dem, salario, motivo, aviso)
    
    if motivo == "sem_justa_causa":
        total_receber += saldo_fgts * 0.40 
    elif motivo == "acordo":
        total_receber += saldo_fgts * 0.20 
        
    return max(0, round(total_receber, 2))


valor_final = calcular_rescisao_clt(
    salario=3500.00,
    saldo_fgts=12000.00,
    motivo="sem_justa_causa",
    aviso="indenizado",
    qtd_ferias_vencidas=1,
    str_adm="2020-03-10",
    str_dem="2024-08-25"
)

print(f"Valor estimado da rescisão: R$ {valor_final:.2f}")
  

Entendendo o código

Para que o nosso algoritmo de rescisão funcione com a precisão exigida pela legislação trabalhista, nós abandonamos a ideia de criar um bloco único e gigante de código. Em vez disso, adotamos o princípio da modularização, dividindo o problema em pequenos blocos independentes.

A primeira grande escolha técnica foi a importação do módulo nativo datetime. Quando lidamos com direitos trabalhistas, o tempo é a principal moeda de troca. Manipular datas como simples textos seria um pesadelo matemático, considerando anos bissextos e meses com diferentes números de dias. Ao converter a entrada do usuário para objetos manipuláveis de tempo, o Python nos permite extrair propriedades exatas como o ano, o mês e o dia da demissão, facilitando imensamente a validação da famosa "regra dos 15 dias", que dita se um funcionário ganha ou não um avo a mais naquele mês quebrado.

A partir dessa base de controle de tempo, construímos as funções especialistas. A primeira delas foca no Aviso Prévio. Essa função é particularmente interessante porque ela precisa avaliar três variáveis simultaneamente: o tempo de casa do trabalhador, o motivo da demissão e a forma de cumprimento. O código aplica um limite matemático de 90 dias, respeitando a lei atual, e decide se o valor será somado ou transformado em um desconto financeiro.

Em seguida, o motor do código passa pelo cálculo das Férias e do 13º Salário Proporcionais. O pulo do gato na programação dessas funções é a blindagem contra a demissão por justa causa. Observe que, antes mesmo do Python começar a contar os meses trabalhados, nós usamos um bloco condicional if para verificar o motivo da saída. Se for uma justa causa, o script imediatamente aborta a operação e bloqueia o pagamento do 13º e das férias não vencidas.

Caso a demissão seja limpa, o código faz o rastreamento da diferença de meses, aplicando funções nativas de limite (min e max) para garantir que os cálculos nunca fiquem negativos ou ultrapassem a barreira máxima de 12 meses, gerando o pagamento exato acrescido do terço constitucional.

Todo esse arsenal matemático é finalmente orquestrado pela função principal, a calcular_rescisao_clt. Ela funciona como o cérebro financeiro da operação. Primeiro, ela realiza a conversão das datas informadas, calcula os dias trabalhados no próprio mês do desligamento (o chamado Saldo de Salário) e soma as férias já vencidas que eventualmente ficaram esquecidas no banco do empregador.

É também nesta função central que as multas são aplicadas: o código avalia o saldo do FGTS e destina 40% de multa para demissões sem justa causa, ou 20% caso tenha ocorrido um acordo baseado na nova Reforma Trabalhista. Uma curiosidade técnica dessa etapa é o uso da função max(0, total). Nós a implementamos como um escudo jurídico: se um funcionário que pediu demissão faltar ao aviso prévio, os descontos poderiam tornar o valor final matematicamente negativo, mas a lei proíbe que o trabalhador saia devendo a empresa. Assim, o Python força o resultado mínimo para R$ 0,00, arredondando as casas decimais.

Deixe aqui nos comentários o que você achou da calculadora !