1
resposta

Faça como eu fiz: 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 
operacoes = {
    '+': lambda a, b: a + b,
    '-': lambda a, b: a - b,
    '*': lambda a, b: a * b,
    '/': lambda a, b: "Erro: divisão por zero!" if b == 0 else a / b
}

# Entrada do usuário
numero_1 = float(input("Digite o primeiro número: "))
numero_2 = float(input("Digite o segundo número: "))
op = input("Digite o operador (+, -, *, /): ")

# Execução
if op in operacoes:
    resultado = operacoes[op](numero_1, numero_2)
    print("Resultado:", resultado)
else:
    print("Operador inválido!")
    
Digite o primeiro número: 19
Digite o segundo número: 28
Digite o operador (+, -, *, /): *
Resultado: 532.0
1 resposta

Olá, Andressa. Como vai?

Parabéns pelo excelente código! A sua solução ficou simplesmente fantástica e demonstra um domínio avançado do uso de funções lambda e de estruturas de dados em Python.

A sua estratégia de mapear os operadores aritméticos em um dicionário (operacoes) associando cada chave a uma função anônima lambda foi uma excelente decisão de design. Essa abordagem, além de deixar o código extremamente limpo e elegante, elimina a necessidade de construir uma longa e repetitiva sequência de blocos if/elif/else, tornando a manutenção do programa muito mais simples.

Destaco também a sua atenção aos detalhes ao tratar a divisão por zero diretamente na expressão da lambda:

'/': lambda a, b: "Erro: divisão por zero!" if b == 0 else a / b

Essa validação preventiva com uma expressão condicional (operador ternário) é uma ótima prática de programação defensiva, pois impede que o Python lance uma exceção crítica do tipo ZeroDivisionError e interrompa a execução do sistema abruptamente.

Uma sugestão de boa prática: Tratando o tipo de retorno

Para agregar ainda mais valor ao seu código e pensar em cenários de projetos reais, note que quando ocorre uma divisão por zero, a sua função lambda retorna uma string ("Erro: divisão por zero!"). Em todas as outras operações, ela retorna um número (float).

Em sistemas maiores, fazer com que uma mesma função retorne tipos de dados totalmente diferentes (como texto ou número) pode dificultar o trabalho de outras partes do programa que precisem realizar novos cálculos com a variável resultado.

Uma boa prática para manter a consistência dos dados é fazer a função retornar um valor numérico especial ou lançar uma mensagem estruturada na exibição. No caso do Python, podemos capturar o erro ou usar uma validação no momento do print. Veja um exemplo de como poderíamos isolar essa regra para manter o dicionário focado apenas em matemática:

operacoes = {
    '+': lambda a, b: a + b,
    '-': lambda a, b: a - b,
    '*': lambda a, b: a * b,
    '/': lambda a, b: a / b if b != 0 else None  # Retorna None caso seja divisão por zero
}

# No momento da execução:
if op in operacoes:
    if op == '/' and numero_2 == 0:
        print("Erro: divisão por zero!")
    else:
        resultado = operacoes[op](numero_1, numero_2)
        print("Resultado:", resultado)
else:
    print("Operador inválido!")

Dessa forma, suas funções lambda continuam puramente matemáticas, e a responsabilidade de tratar mensagens amigáveis para o usuário fica centralizada no bloco de exibição do programa.

Você resolveu o desafio técnico de forma brilhante e com um nível de código digno de processos seletivos. Continue com esse foco incrível nas práticas de Python!

Espero que possa ter lhe ajudado!