Elaborar um programa Python para calcular as raízes da equação do segundo grau. Seu programa deverá perguntar ao usuário se deseja fazer outro cálculo e só terminará quando o usuário responder que não deseja continuar calcular as raízes de outras equações. Lembrando que, as raízes complexas também serão impressas.
Passo 1
O enunciado pede que eu elabore um programa em Python que:
- Pergunte ao usuário os coeficientes da equação do segundo grau (ou seja, os valores de
, e ). - Calcule as raízes da equação e as imprima — lembrando que raízes complexas também devem ser mostradas.
- Pergunte ao usuário se ele deseja fazer outro cálculo e só termine quando o usuário responder que não deseja continuar.
Informações relevantes fornecidas pelo enunciado:
- Precisamos lidar com equações do tipo
, com , , informados pelo usuário. - Devemos mostrar raízes reais e complexas.
- Deve existir um loop que repete o processo até o usuário dizer que não quer continuar.
Passo 2
Vamos entender a fórmula que realmente usamos para calcular as raízes. Para uma equação
(com
), definimos o discriminante
como
As raízes são dadas pela fórmula de Bhaskara:
Explicando cada símbolo:
-
, , são os coeficientes informados pelo usuário. -
indica a “natureza” das raízes: - Se
: duas raízes reais distintas. - Se
: uma raiz real dupla (raiz repetida). - Se
: duas raízes complexas conjugadas (por isso precisamos lidar com números complexos).
- Se
Passo 3
Como tratar
quando
? Em Python, o módulo padrão para radiciação retorna erro para raiz de número negativo se usarmos apenas floats. Para simplificar, usamos o módulo que já trabalha com números complexos: o módulo positivo, zero ou negativo — e o resultado será do tipo complexo quando necessário.
cmath. Com cmath.sqrt(\Delta) obtemos corretamente a raiz quadrada, seja
Passo 4
Devemos também considerar o caso em que o usuário, por engano, informa
. Nesse caso:
- Se
e : a equação não é quadrática, é linear e a solução é - Se
, e : qualquer é solução (infinitas soluções). - Se
, e : não existe solução (contradição é falsa).
É importante deixar claro isso para que o programa trate bem entradas inesperadas.
Passo 5
Estrutura do programa (em palavras, passo a passo):
- Abrir um loop principal que só termina quando o usuário responder que não quer continuar.
- Pedir
, e ao usuário. Converter para número (usar floatpara permitir termos decimais). - Tratar o caso
(ver Passo 4). - Para
: - Calcular
. - Calcular
com cmath.sqrt. - Calcular
e por - Imprimir as raízes. Se a parte imaginária for praticamente zero (por exemplo, muito próxima de zero por erro numérico), podemos imprimir só a parte real para ficar mais legível.
- Calcular
- Perguntar ao usuário se deseja repetir. Aceitar respostas como ‘s’, ‘sim’, ‘n’, ‘não’ (tratando maiúsculas/minúsculas). Repetir a pergunta até receber uma resposta válida.
Passo 6
Boas práticas de entrada/saída:
- Envolver a conversão em
try/exceptpara capturar entradas inválidas (por exemplo, o usuário digitou “abc” em vez de um número). - Usar mensagens informativas ao imprimir o resultado, por exemplo: “Raízes: x1 = …, x2 = …”.
- Quando as raízes forem complexas, imprimir no formato Python (ex.:
) ou formatar para se preferir; aqui usaremos o formato padrão de complexos do Python (com j).
Passo 7
Exemplos numéricos para fixar:
- Se o usuário der
, , , então . As raízes serão - Se der
, , , então e a raiz dupla é . - Se der
, , , então e as raízes são complexas: - Se der
, , , trataremos como linear e a raiz será .
Esses exemplos ajudam a conferir se o programa está funcionando.
Passo 8
Dicas finais para a prova (rápido e prático):
- Memorize a expressão do discriminante
e a fórmula de Bhaskara. - Se precisar programar no exame, lembre-se de usar
cmathpara raízes de. - Sempre verifique
antes de aplicar a fórmula quadrática.
Vai dar certo — respira, faz um exercício de cada vez e treina alguns exemplos parecidos com os do Passo 7 para fixar.
Resposta
import cmath
def calcular_raizes():
while True:
# Leitura dos coeficientes
try:
a = float(input("Coeficiente a: ").strip())
b = float(input("Coeficiente b: ").strip())
c = float(input("Coeficiente c: ").strip())
except ValueError:
print("Entrada inválida. Por favor, digite números (ex.: 1, 2.5, -3).")
continue
# Caso a == 0: tratar como linear ou casos degenerados
if a == 0.0:
if b == 0.0:
if c == 0.0:
print("Infinitas soluções (equação 0 = 0).")
else:
print("Sem solução (equação inconsistente).")
else:
x = -c / b
print(f"Equação linear. Raiz: x = {x}")
else:
# Calcula discriminante e raízes usando cmath para suportar complexos
delta = b * b - 4 * a * c
raiz_delta = cmath.sqrt(delta)
x1 = (-b + raiz_delta) / (2 * a)
x2 = (-b - raiz_delta) / (2 * a)
# Se a parte imaginária for numericamente quase zero, mostrar só a parte real
def limpa_complex(z):
if abs(z.imag) < 1e-12:
return z.real
return z
x1_print = limpa_complex(x1)
x2_print = limpa_complex(x2)
print(f"Raízes: x1 = {x1_print}, x2 = {x2_print}")
# Pergunta ao usuário se deseja continuar
while True:
resp = input("Deseja calcular outra equação? (s/n): ").strip().lower()
if resp in ("s", "sim"):
break # volta ao início do loop principal
if resp in ("n", "nao", "não", "nao"):
print("Encerrando o programa. Até mais!")
return
print("Resposta inválida. Digite 's' para sim ou 'n' para não.")
if __name__ == "__main__":
calcular_raizes()