2
respostas

[Sugestão] 11 - Calculadora com lambda

Joana está participando de um processo seletivo para uma vaga de desenvolvedora e recebeu um desafio técnico de criar uma calculadora para somar, subtrair, multiplicar e dividir dois números.

Sua tarefa é criar um programa usando funções lambda que receba dois números e um operador matemático escolhido pelo usuário (+, -, * ou /) e exiba o resultado correspondente.

Exemplo de entrada:
Digite o primeiro número: 10
Digite o segundo número: 5
Escolha a operação (| + | - | * | / |): +

Saída esperada:
O resultado é: 15

Meu Código:

try:
    numero1 = int(input("Digite o primeiro número: "))
    numero2 = int(input("Digite o segundo número: "))
    operacao = input("Digite a operação (| + | - | * | / |): ")
    calculadora = lambda x, y, op: eval(f"{x} {op} {y}")
    print(round(calculadora(numero1, numero2, operacao), 2))
except (ValueError, TypeError, SyntaxError, ZeroDivisionError) as e:
    print(f"Erro: {e}")

Explicação: Eu optei por tratar as exceções num bloco try-except e usei a função built-in eval para transformar o input do usuário em um "bloco de código". Cabe melhorias para tratar melhor as exceções ou a lógica com o lambda.

2 respostas

Olá, Malderson! Como vai?

Sua solução é muito interessante e demonstra um nível de abstração bem avançado para quem está praticando funções! O uso da função eval em conjunto com a fórmula lambda para criar uma calculadora dinâmica em uma única linha é um ótimo exercício de síntese de código.

No entanto, como você é Consultor de TI, sabe que em ambientes de produção o uso do eval() é frequentemente debatido devido a questões de segurança (visto que ele pode executar qualquer código enviado pelo usuário).

Gostaria de propor algumas reflexões e uma alternativa para "refinar" essa sua lógica com lambda, mantendo a elegância, mas aumentando a segurança:

1. O perigo do eval

Quando usamos eval(f"{x} {op} {y}"), se um usuário mal-intencionado digitar algo como __import__('os').system('rm -rf /') no lugar do operador, o Python pode tentar executar comandos do sistema. Por isso, em aplicações reais, preferimos mapear as operações.

2. Dicionário de Lambdas (A "Boa Prática")

Uma forma muito comum e elegante em Python é criar um dicionário onde as chaves são os operadores e os valores são as funções lambda. Isso elimina a necessidade do eval e torna o código mais explícito:

try:
    numero1 = float(input("Digite o primeiro número: "))
    numero2 = float(input("Digite o segundo número: "))
    operacao = input("Escolha a operação (+, -, *, /): ").strip()

    # Mapeamento de funções lambda
    operacoes = {
        "+": lambda x, y: x + y,
        "-": lambda x, y: x - y,
        "*": lambda x, y: x * y,
        "/": lambda x, y: x / y if y != 0 else "Erro: Divisão por zero"
    }

    if operacao in operacoes:
        resultado = operacoes[operacao](numero1, numero2)
        print(f"O resultado é: {resultado}")
    else:
        print("Operação inválida!")

except ValueError:
    print("Erro: Por favor, digite apenas números.")

3. Tratamento de Exceções

Você fez muito bem em agrupar as exceções! No Python, o ZeroDivisionError é clássico em calculadoras. No modelo de dicionário acima, note que tratei a divisão por zero dentro do próprio lambda usando um operador ternário, o que é uma técnica bem "pythônica" para manter o código conciso.

Sua evolução no curso está excelente, e o fato de você já pensar em tratamento de erros e segurança da informação mostra que sua base como Consultor está sendo muito bem aplicada na programação.

Espero que possa ter lhe ajudado!

Você já chegou a ver como funcionam os operadores ternários dentro de lambdas (como o if/else em uma linha só) ou prefere tratar essas condições fora da função?

Muito bem colocado sobre o eval. Fiz algumas pesquisas e sua recomendação em aplicações em produção e 0. Irei adotar outras estruturas para substituir o eval e pesquisar sobre o operador ternário dentro de Lambdas.