Projeto Calculadora

O primeiro projeto do guia: uma calculadora que roda no terminal. Ela pede um número, a operação e outro número, mostra o resultado e pergunta se você quer fazer outra conta. A conta em si é a parte fácil: o Python já sabe somar. O desafio é fazer o programa não quebrar quando alguém divide por zero, escolhe uma operação que não existe ou digita "seis" no lugar de um número.

O que vamos construir

Esta é a calculadora pronta, rodando no computador da Ana. O que aparece depois dos dois-pontos de cada pergunta foi digitado por ela (o 10, o +, o s…); o resto foi o programa que escreveu:

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 10
Operação (+ - * /): +
Segundo número: 5
10 + 5 = 15
Outra conta? (s/n): s
Primeiro número: seis
"seis" não é um número. Tente de novo.          « texto no lugar de número
Primeiro número: 6
Operação (+ - * /): %
Operação desconhecida: %                        « operação que não existe
Operação (+ - * /): *
Segundo número: 1.5
6 * 1.5 = 9
Outra conta? (s/n): s
Primeiro número: 2,5                            « com vírgula também vale
Operação (+ - * /): /
Segundo número: 0
Não dá para dividir por zero.                   « divisão por zero
Outra conta? (s/n): s
Primeiro número: 0.1
Operação (+ - * /): +
Segundo número: 0.2
0.1 + 0.2 = 0.3
Outra conta? (s/n): s
Primeiro número: 10
Operação (+ - * /): /
Segundo número: 3
10 / 3 = 3.333333
Outra conta? (s/n): n
Até logo!

Vamos chegar lá em quatro versões. No fim de cada uma, o programa roda; cada versão acrescenta uma coisa só:

1. Dois números e um operador (input, float, if/elif).
2. match e a divisão por zero.
3. Repetir até a pessoa sair (while True e break).
4. Funções e entrada validada (def, return, try/except).

Antes de começar

Você precisa saber criar e rodar um arquivo .py (Rodando um Programa), usar variáveis e f-strings. No seu computador, crie a pasta do projeto; o arquivo vai se chamar calculadora.py:

$ mkdir -p projetos/calculadora
$ cd projetos/calculadora

Em cada versão há também uma caixa Experimente, que roda Python de verdade aqui na página. Nas missões deste projeto, a caixa tem um campo Entrada, já preenchido com as respostas que o programa vai receber, uma por linha, como se alguém as digitasse (a missão diz quais são).

Antes da versão 1: o tropeço clássico

O jeito mais curto de pedir dois números e somar seria este:

print("=== Calculadora da Ana ===")
a = input("Primeiro número: ")
b = input("Segundo número: ")
print(f"{a} + {b} = {a + b}")

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 10
Segundo número: 5
10 + 5 = 105

10 + 5 = 105? Não deu erro nenhum, mas a conta está errada. O motivo: o input() sempre devolve um texto (uma str), mesmo que a pessoa tenha digitado só algarismos. Para o Python, a vale "10" e b vale "5", e o + entre dois textos junta os textos (veja Juntar e Repetir Textos): "10" + "5" é "105". Para fazer conta, é preciso converter o texto em número antes. É o primeiro passo da versão 1.

Versão 1 · Dois números e um operador

A calculadora pede o primeiro número, a operação e o segundo número. Os números passam pelo float(), que transforma o texto num número com casas decimais (um float, veja Números), porque a Ana quer fazer contas como 7.5 / 2. A operação fica como texto mesmo: "+", "-", "*" ou "/". Para escolher a conta, uma escada de if e elif.

print("=== Calculadora da Ana ===")
a = float(input("Primeiro número: "))
op = input("Operação (+ - * /): ")
b = float(input("Segundo número: "))

if op == "+":
    print(f"{a} + {b} = {a + b}")
elif op == "-":
    print(f"{a} - {b} = {a - b}")
elif op == "*":
    print(f"{a} * {b} = {a * b}")
elif op == "/":
    print(f"{a} / {b} = {a / b}")
else:
    print(f"Operação desconhecida: {op}")

Rodando no terminal da Ana, duas vezes:

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 10
Operação (+ - * /): +
Segundo número: 5
10.0 + 5.0 = 15.0
$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 7.5
Operação (+ - * /): /
Segundo número: 2
7.5 / 2.0 = 3.75

Agora a conta está certa. Repare no 10.0 + 5.0 = 15.0: como os números passaram pelo float(), o Python os mostra com o .0 no fim. Está correto, só não é bonito; na versão 4 a calculadora vai mostrar 10 + 5 = 15. E uma operação que não existe cai no else:

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 3
Operação (+ - * /): x
Segundo número: 4
Operação desconhecida: x

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 0.1
Operação (+ - * /): +
Segundo número: 0.2
0.1 + 0.2 = 0.30000000000000004

Quando dá errado na versão 1

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: seis
Traceback (most recent call last):
  File "/home/ana/projetos/calculadora/calculadora.py", line 2, in <module>
    a = float(input("Primeiro número: "))
        ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: could not convert string to float: 'seis'

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 2,5
Traceback (most recent call last):
  File "/home/ana/projetos/calculadora/calculadora.py", line 2, in <module>
    a = float(input("Primeiro número: "))
        ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: could not convert string to float: '2,5'

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 1
Operação (+ - * /): /
Segundo número: 0
Traceback (most recent call last):
  File "/home/ana/projetos/calculadora/calculadora.py", line 13, in <module>
    print(f"{a} / {b} = {a / b}")
                         ~~^~~
ZeroDivisionError: division by zero

print("=== Calculadora da Ana ===")
a = float(input("Primeiro número: "))
op = input("Operação (+ - * /): ")
# peça e leia o segundo número

if op == "+":
    print(f"{a} + {b} = {a + b}")
elif op == "*":
    print(f"{a} * {b} = {a * b}")
elif op == "/":
    print(f"{a} / {b} = {a / b}")
else:
    print(f"Operação desconhecida: {op}")

print("=== Calculadora da Ana ===")
a = float(input("Primeiro número: "))
op = input("Operação (+ - * /): ")
b = float(input("Segundo número: "))

if op == "+":
    print(f"{a} + {b} = {a + b}")
elif op == "-":
    print(f"{a} - {b} = {a - b}")
elif op == "*":
    print(f"{a} * {b} = {a * b}")
elif op == "/":
    print(f"{a} / {b} = {a / b}")
else:
    print(f"Operação desconhecida: {op}")

Versão 2 · match e a divisão por zero

Duas mudanças. A primeira é só de forma: a escada de if/elif que compara a mesma variável com vários valores fica mais fácil de ler com match e case ("combinar" e "caso"). A segunda conserta um defeito: antes de dividir, a calculadora confere se o segundo número é zero.

print("=== Calculadora da Ana ===")
a = float(input("Primeiro número: "))
op = input("Operação (+ - * /): ")
b = float(input("Segundo número: "))

match op:
    case "+":
        print(f"{a} + {b} = {a + b}")
    case "-":
        print(f"{a} - {b} = {a - b}")
    case "*":
        print(f"{a} * {b} = {a * b}")
    case "/":
        if b == 0:
            print("Não dá para dividir por zero.")
        else:
            print(f"{a} / {b} = {a / b}")
    case _:
        print(f"Operação desconhecida: {op}")

match op:

"Compare o valor de op com os casos abaixo." O match existe desde o Python 3.10.

case "+":

Se op for "+", faz o bloco de baixo (indentado com mais 4 espaços) e pula todos os outros casos.

if b == 0:

Dentro do caso da divisão, um if comum: se o divisor for zero, avisa em vez de dividir. Um bloco pode ter qualquer coisa dentro, inclusive outro if (veja Condições Aninhadas).

case _:

O sublinhado é o "qualquer outra coisa": combina com tudo, por isso fica por último. Faz o papel do else.

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 1
Operação (+ - * /): /
Segundo número: 0
Não dá para dividir por zero.
$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 9
Operação (+ - * /): -
Segundo número: 12
9.0 - 12.0 = -3.0

Em vez do traceback da versão 1, uma frase que a Ana entende. Isso é prevenir o erro: o programa confere antes de fazer a conta perigosa. (A outra estratégia, tratar o erro depois que ele acontece, com try/except, aparece na versão 4.)

print("=== Calculadora da Ana ===")
a = float(input("Primeiro número: "))
op = input("Operação (+ - * /): ")
b = float(input("Segundo número: "))

match op:
    case "+":
        print(f"{a} + {b} = {a + b}")
    case "-":
        print(f"{a} - {b} = {a - b}")
    case "*":
        print(f"{a} * {b} = {a * b}")
    case "/":
        print(f"{a} / {b} = {a / b}")
    case _:
        print(f"Operação desconhecida: {op}")

print("=== Calculadora da Ana ===")
a = float(input("Primeiro número: "))
op = input("Operação (+ - * /): ")
b = float(input("Segundo número: "))

match op:
    case "+":
        print(f"{a} + {b} = {a + b}")
    case "-":
        print(f"{a} - {b} = {a - b}")
    case "*":
        print(f"{a} * {b} = {a * b}")
    case "/":
        if b == 0:
            print("Não dá para dividir por zero.")
        else:
            print(f"{a} / {b} = {a / b}")
    case _:
        print(f"Operação desconhecida: {op}")

Versão 3 · Repetir até a pessoa sair

Até agora, cada conta exige rodar o programa de novo. A Ana quer fazer várias contas seguidas. A solução é colocar tudo dentro de um laço while ("enquanto") e, no fim de cada volta, perguntar se ela quer continuar.

print("=== Calculadora da Ana ===")

while True:
    a = float(input("Primeiro número: "))
    op = input("Operação (+ - * /): ")
    b = float(input("Segundo número: "))

    match op:
        case "+":
            print(f"{a} + {b} = {a + b}")
        case "-":
            print(f"{a} - {b} = {a - b}")
        case "*":
            print(f"{a} * {b} = {a * b}")
        case "/":
            if b == 0:
                print("Não dá para dividir por zero.")
            else:
                print(f"{a} / {b} = {a / b}")
        case _:
            print(f"Operação desconhecida: {op}")

    continuar = input("Outra conta? (s/n): ").strip().lower()
    if continuar != "s":
        break

print("Até logo!")

while True:

"Enquanto verdadeiro": um laço que, sozinho, nunca termina. Tudo o que está indentado embaixo dele se repete. Quem decide a hora de parar é o break lá dentro.

(o bloco inteiro andou 4 espaços)

As perguntas e o match agora estão dentro do while, por isso ganharam mais um nível de indentação. É a indentação que diz ao Python o que faz parte do laço (veja Sintaxe e Indentação).

input("Outra conta? (s/n): ").strip().lower()

Três passos em fila: pergunta, tira os espaços das pontas (strip, "aparar") e passa para minúsculas (lower, "mais baixo"). Assim, S, s e " s " viram todos "s". Veja Métodos de Texto.

if continuar != "s":

"Se a resposta for diferente de s". Qualquer outra coisa (n, não, só Enter) encerra.

break

"Quebrar": sai do laço na hora. O programa continua na primeira linha depois do while (veja break e continue).

print("Até logo!")

Fora do laço (sem indentação): roda uma vez só, quando o break acontece.

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 10
Operação (+ - * /): +
Segundo número: 5
10.0 + 5.0 = 15.0
Outra conta? (s/n): s
Primeiro número: 3
Operação (+ - * /): *
Segundo número: 4
3.0 * 4.0 = 12.0
Outra conta? (s/n): S                « maiúsculo também vale, graças ao lower()
Primeiro número: 100
Operação (+ - * /): /
Segundo número: 8
100.0 / 8.0 = 12.5
Outra conta? (s/n): n
Até logo!

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 10
Operação (+ - * /): ^CTraceback (most recent call last):
  File "/home/ana/projetos/calculadora/calculadora.py", line 5, in <module>
    op = input("Operação (+ - * /): ")
         ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^
KeyboardInterrupt

print("=== Calculadora da Ana ===")

a = float(input("Primeiro número: "))
op = input("Operação (+ - * /): ")
b = float(input("Segundo número: "))

match op:
    case "+":
        print(f"{a} + {b} = {a + b}")
    case "-":
        print(f"{a} - {b} = {a - b}")
    case "*":
        print(f"{a} * {b} = {a * b}")
    case "/":
        if b == 0:
            print("Não dá para dividir por zero.")
        else:
            print(f"{a} / {b} = {a / b}")
    case _:
        print(f"Operação desconhecida: {op}")

continuar = input("Outra conta? (s/n): ").strip().lower()

print("Até logo!")

print("=== Calculadora da Ana ===")

while True:
    a = float(input("Primeiro número: "))
    op = input("Operação (+ - * /): ")
    b = float(input("Segundo número: "))

    match op:
        case "+":
            print(f"{a} + {b} = {a + b}")
        case "-":
            print(f"{a} - {b} = {a - b}")
        case "*":
            print(f"{a} * {b} = {a * b}")
        case "/":
            if b == 0:
                print("Não dá para dividir por zero.")
            else:
                print(f"{a} / {b} = {a / b}")
        case _:
            print(f"Operação desconhecida: {op}")

    continuar = input("Outra conta? (s/n): ").strip().lower()
    if continuar != "s":
        break

print("Até logo!")

Versão 4 · Funções e entrada validada

A versão 3 já faz várias contas, mas ainda quebra com seis, com 2,5 e com qualquer coisa que não seja número. E o programa ficou comprido: está tudo misturado num bloco só. A versão 4 resolve as duas coisas de uma vez: cada tarefa vira uma função com nome, e a função que lê números insiste até receber um número de verdade.

OPERACOES = "+-*/"


def ler_numero(pergunta):
    """Pergunta até a pessoa digitar um número; aceita vírgula ou ponto."""
    while True:
        texto = input(pergunta).strip()
        try:
            return float(texto.replace(",", "."))
        except ValueError:
            print(f'"{texto}" não é um número. Tente de novo.')


def ler_operacao():
    """Pergunta até a pessoa digitar uma das quatro operações."""
    while True:
        op = input("Operação (+ - * /): ").strip()
        if len(op) == 1 and op in OPERACOES:
            return op
        print(f"Operação desconhecida: {op}")


def formatar(numero):
    """Mostra 15 em vez de 15.0, com no máximo 6 casas decimais."""
    numero = round(numero, 6)
    if numero.is_integer():
        return str(int(numero))
    return str(numero)


def calcular(a, op, b):
    """Faz a conta e devolve o resultado (ou None, se for dividir por zero)."""
    match op:
        case "+":
            return a + b
        case "-":
            return a - b
        case "*":
            return a * b
        case "/":
            if b == 0:
                return None
            return a / b


print("=== Calculadora da Ana ===")

while True:
    a = ler_numero("Primeiro número: ")
    op = ler_operacao()
    b = ler_numero("Segundo número: ")

    resultado = calcular(a, op, b)
    if resultado is None:
        print("Não dá para dividir por zero.")
    else:
        print(f"{formatar(a)} {op} {formatar(b)} = {formatar(resultado)}")

    continuar = input("Outra conta? (s/n): ").strip().lower()
    if continuar != "s":
        break

print("Até logo!")

Parece muito código novo, mas o "programa principal" (do print do título até o fim) ficou mais curto e mais fácil de ler do que na versão 3: ele só chama funções com nomes que dizem o que fazem. Vamos às peças.

As funções, uma por uma

Conferindo no modo interativo as peças novas, uma de cada vez:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> float("2,5".replace(",", "."))
2.5
>>> float("  7.5  ")
7.5
>>> round(0.1 + 0.2, 6)
0.3
>>> (15.0).is_integer()
True
>>> "%" in "+-*/"
False
>>> "+-" in "+-*/"
True
>>> exit()

A última linha explica o len(op) == 1: o in, entre textos, procura um pedaço. "+-" é um pedaço de "+-*/", então daria True, e a calculadora aceitaria a "operação" +-. Exigir um caractere só fecha essa porta. (O float() já ignora espaços nas pontas, como mostra o " 7.5 "; o strip() em ler_numero serve para a mensagem de erro mostrar o texto sem eles.)

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 10
Operação (+ - * /): +
Segundo número: 5
10 + 5 = 15
Outra conta? (s/n): s
Primeiro número: seis
"seis" não é um número. Tente de novo.
Primeiro número: 6
Operação (+ - * /): %
Operação desconhecida: %
Operação (+ - * /): *
Segundo número: 1.5
6 * 1.5 = 9
Outra conta? (s/n): s
Primeiro número: 2,5
Operação (+ - * /): /
Segundo número: 0
Não dá para dividir por zero.
Outra conta? (s/n): s
Primeiro número: 0.1
Operação (+ - * /): +
Segundo número: 0.2
0.1 + 0.2 = 0.3
Outra conta? (s/n): s
Primeiro número: 10
Operação (+ - * /): /
Segundo número: 3
10 / 3 = 3.333333
Outra conta? (s/n): n
Até logo!

É a sessão do começo da página. Tudo o que derrubava a versão 1 agora tem resposta.

$ python3 calculadora.py
=== Calculadora da Ana ===
Traceback (most recent call last):
  File "/home/ana/projetos/calculadora/calculadora.py", line 4, in <module>
    a = ler_numero("Primeiro número: ")
        ^^^^^^^^^^
NameError: name 'ler_numero' is not defined

OPERACOES = "+-*/"


def ler_numero(pergunta):
    """Pergunta até a pessoa digitar um número; aceita vírgula ou ponto."""
    while True:
        texto = input(pergunta).strip()
        return float(texto.replace(",", "."))


def ler_operacao():
    """Pergunta até a pessoa digitar uma das quatro operações."""
    while True:
        op = input("Operação (+ - * /): ").strip()
        if len(op) == 1 and op in OPERACOES:
            return op
        print(f"Operação desconhecida: {op}")


def formatar(numero):
    """Mostra 15 em vez de 15.0, com no máximo 6 casas decimais."""
    numero = round(numero, 6)
    if numero.is_integer():
        return str(int(numero))
    return str(numero)


def calcular(a, op, b):
    """Faz a conta e devolve o resultado (ou None, se for dividir por zero)."""
    match op:
        case "+":
            return a + b
        case "-":
            return a - b
        case "*":
            return a * b
        case "/":
            if b == 0:
                return None
            return a / b


print("=== Calculadora da Ana ===")

while True:
    a = ler_numero("Primeiro número: ")
    op = ler_operacao()
    b = ler_numero("Segundo número: ")

    resultado = calcular(a, op, b)
    if resultado is None:
        print("Não dá para dividir por zero.")
    else:
        print(f"{formatar(a)} {op} {formatar(b)} = {formatar(resultado)}")

    continuar = input("Outra conta? (s/n): ").strip().lower()
    if continuar != "s":
        break

print("Até logo!")

OPERACOES = "+-*/"


def ler_numero(pergunta):
    """Pergunta até a pessoa digitar um número; aceita vírgula ou ponto."""
    while True:
        texto = input(pergunta).strip()
        try:
            return float(texto.replace(",", "."))
        except ValueError:
            print(f'"{texto}" não é um número. Tente de novo.')


def ler_operacao():
    """Pergunta até a pessoa digitar uma das quatro operações."""
    while True:
        op = input("Operação (+ - * /): ").strip()
        if len(op) == 1 and op in OPERACOES:
            return op
        print(f"Operação desconhecida: {op}")


def formatar(numero):
    """Mostra 15 em vez de 15.0, com no máximo 6 casas decimais."""
    numero = round(numero, 6)
    if numero.is_integer():
        return str(int(numero))
    return str(numero)


def calcular(a, op, b):
    """Faz a conta e devolve o resultado (ou None, se for dividir por zero)."""
    match op:
        case "+":
            return a + b
        case "-":
            return a - b
        case "*":
            return a * b
        case "/":
            if b == 0:
                return None
            return a / b


print("=== Calculadora da Ana ===")

while True:
    a = ler_numero("Primeiro número: ")
    op = ler_operacao()
    b = ler_numero("Segundo número: ")

    resultado = calcular(a, op, b)
    if resultado is None:
        print("Não dá para dividir por zero.")
    else:
        print(f"{formatar(a)} {op} {formatar(b)} = {formatar(resultado)}")

    continuar = input("Outra conta? (s/n): ").strip().lower()
    if continuar != "s":
        break

print("Até logo!")

Formas diferentes de escolher a conta

A calculadora usou if/elif e depois match. Há um terceiro jeito, que você vai encontrar em programas prontos: um dicionário que liga cada símbolo a uma função. O módulo operator (da biblioteca do Python) já traz as funções das contas: operator.add soma, operator.mul multiplica, e assim por diante.

import operator

a, op, b = 10.0, "*", 3.0

# Forma 1: if/elif
if op == "+":
    print("if/elif:", a + b)
elif op == "*":
    print("if/elif:", a * b)

# Forma 2: match/case
match op:
    case "+":
        print("match:", a + b)
    case "*":
        print("match:", a * b)

# Forma 3: um dicionário de funções
contas = {
    "+": operator.add,
    "-": operator.sub,
    "*": operator.mul,
    "/": operator.truediv,
}
print("dicionário:", contas[op](a, b))

$ python3 formas.py
if/elif: 30.0
match: 30.0
dicionário: 30.0

Na forma 3, contas[op] busca no dicionário a função ligada a "*" (a operator.mul), e o (a, b) logo depois a chama com os dois números.

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> eval("10 + 5")
15
>>> eval("2,5")
(2, 5)
>>> exit()

Desafio extra: resto e potência

A Ana quer mais duas operações: o resto da divisão (%) e a potência (**, "elevado a"), que você conhece da aula Operadores Aritméticos. O ** tem dois caracteres, então o teste len(op) == 1 and op in OPERACOES não serve mais. Com uma lista de operações, o in compara itens inteiros (e não pedaços de texto), e o len deixa de ser necessário:

OPERACOES = ["+", "-", "*", "/", "%", "**"]

Com as mudanças da missão abaixo, a Ana testou assim:

$ python3 calculadora.py
=== Calculadora da Ana ===
Primeiro número: 10
Operação (+ - * / % **): %
Segundo número: 3
10 % 3 = 1
Outra conta? (s/n): s
Primeiro número: 2
Operação (+ - * / % **): **
Segundo número: 10
2 ** 10 = 1024
Outra conta? (s/n): s
Primeiro número: 7
Operação (+ - * / % **): %
Segundo número: 0
Não dá para dividir por zero.
Outra conta? (s/n): n
Até logo!

O resto também é uma divisão: 7 % 0 dá o mesmo ZeroDivisionError que 7 / 0, por isso o caso "%" também confere o zero.

OPERACOES = "+-*/"


def ler_numero(pergunta):
    """Pergunta até a pessoa digitar um número; aceita vírgula ou ponto."""
    while True:
        texto = input(pergunta).strip()
        try:
            return float(texto.replace(",", "."))
        except ValueError:
            print(f'"{texto}" não é um número. Tente de novo.')


def ler_operacao():
    """Pergunta até a pessoa digitar uma das operações."""
    while True:
        op = input("Operação (+ - * /): ").strip()
        if len(op) == 1 and op in OPERACOES:
            return op
        print(f"Operação desconhecida: {op}")


def formatar(numero):
    """Mostra 15 em vez de 15.0, com no máximo 6 casas decimais."""
    numero = round(numero, 6)
    if numero.is_integer():
        return str(int(numero))
    return str(numero)


def calcular(a, op, b):
    """Faz a conta e devolve o resultado (ou None, se for dividir por zero)."""
    match op:
        case "+":
            return a + b
        case "-":
            return a - b
        case "*":
            return a * b
        case "/":
            if b == 0:
                return None
            return a / b


print("=== Calculadora da Ana ===")

while True:
    a = ler_numero("Primeiro número: ")
    op = ler_operacao()
    b = ler_numero("Segundo número: ")

    resultado = calcular(a, op, b)
    if resultado is None:
        print("Não dá para dividir por zero.")
    else:
        print(f"{formatar(a)} {op} {formatar(b)} = {formatar(resultado)}")

    continuar = input("Outra conta? (s/n): ").strip().lower()
    if continuar != "s":
        break

print("Até logo!")

OPERACOES = ["+", "-", "*", "/", "%", "**"]


def ler_numero(pergunta):
    """Pergunta até a pessoa digitar um número; aceita vírgula ou ponto."""
    while True:
        texto = input(pergunta).strip()
        try:
            return float(texto.replace(",", "."))
        except ValueError:
            print(f'"{texto}" não é um número. Tente de novo.')


def ler_operacao():
    """Pergunta até a pessoa digitar uma das operações."""
    while True:
        op = input("Operação (+ - * / % **): ").strip()
        if op in OPERACOES:
            return op
        print(f"Operação desconhecida: {op}")


def formatar(numero):
    """Mostra 15 em vez de 15.0, com no máximo 6 casas decimais."""
    numero = round(numero, 6)
    if numero.is_integer():
        return str(int(numero))
    return str(numero)


def calcular(a, op, b):
    """Faz a conta e devolve o resultado (ou None, se for dividir por zero)."""
    match op:
        case "+":
            return a + b
        case "-":
            return a - b
        case "*":
            return a * b
        case "/":
            if b == 0:
                return None
            return a / b
        case "%":
            if b == 0:
                return None
            return a % b
        case "**":
            return a ** b


print("=== Calculadora da Ana ===")

while True:
    a = ler_numero("Primeiro número: ")
    op = ler_operacao()
    b = ler_numero("Segundo número: ")

    resultado = calcular(a, op, b)
    if resultado is None:
        print("Não dá para dividir por zero.")
    else:
        print(f"{formatar(a)} {op} {formatar(b)} = {formatar(resultado)}")

    continuar = input("Outra conta? (s/n): ").strip().lower()
    if continuar != "s":
        break

print("Até logo!")

Outras ideias para continuar sozinho: guardar cada conta numa lista e mostrar o histórico quando a Ana sair; aceitar a conta inteira numa linha só (10 + 5), separando as partes com split().

Referência rápida do projeto

Exercícios

Resumo

• O input() sempre devolve texto. Para fazer conta, converta com float() (ou int()); sem isso, "10" + "5" dá "105".
• if/elif e match/case escolhem a conta; o case _ pega o que sobrou.
• A divisão por zero dá ZeroDivisionError: previna com if b == 0.
• while True com break repete até a pessoa pedir para sair; .strip().lower() deixa a resposta tolerante.
• Texto que não é número dá ValueError: trate com try/except dentro de um laço que pergunta de novo.
• Funções com nomes claros deixam o programa principal curto. Elas precisam ser criadas (def) antes de serem chamadas.
• Nunca use eval() no que a pessoa digita.