Implemente uma classe Parabola, considerando que os objetos do tipo Parabola:
- são construídos a partir de 3 números reais,
e
;
- possuem uma property coeficientes, que retorna uma lista com os valores de
e
;
- possuem uma property delta, que retorna o valor da expressão
;
- possuem uma property vertice, que retorna uma lista com os valores das expressões,
e
, onde
é o valor da property descrita no item anterior e
- possuem um método avaliar, que recebe um valor
e retorna o valor da expressão
, onde
e
são os valores dos atributos da classe.
Passo 1
O enunciado dá que precisamos implementar uma classe chamada Parabola com as seguintes características:
- É construída a partir de três números reais
, e . - Possui uma propriedade (property) chamada coeficientes que retorna uma lista com os valores de
, e . - Possui uma propriedade chamada delta que retorna o valor da expressão
. - Possui uma propriedade chamada vertice que retorna uma lista com os valores
e , onde é o valor da property delta. - Possui um método avaliar(x) que retorna o valor da expressão
para o valor dado de .
Esses são os requisitos exatos que implementaremos. Não há perguntas adicionais no enunciado.
Passo 2
Decidindo como mapear isso em Python (sem pular passos):
- Usaremos um construtor __init__(self, a, b, c) que guarda
, e como atributos da instância. - As propriedades serão implementadas com o decorador @property para permitir acesso como atributos (por exemplo, instancia.coeficientes).
- O método avaliar será um método normal que recebe um parâmetro
.
Vou implementar verificações mínimas para evitar divisão por zero nas fórmulas que usamno denominador (ou seja, quando ). Explicarei o porquê dessas verificações.
Passo 3
Explicando o construtor e armazenamento de atributos:
- O construtor recebe três números
, e . - Guardamos esses valores em atributos com nomes claros: self.a, self.b, self.c.
- É prática razoável converter entradas para float para evitar problemas com operações aritméticas inexplicadas (por ex., inteiros vs floats). Assim, faremos coercão para float:
, etc. - Observação: se o usuário passar algo que não possa virar float, o Python levantará TypeError/ValueError automaticamente — isso é aceitável e ajuda a detectar erros de uso.
Passo 4
Implementando a propriedade coeficientes:
- A property coeficientes deve retornar uma lista com os valores de
, e . - Em código isso é direto: retornar
. - Não há cálculos envolvidos aqui, apenas empacotar os atributos em uma lista para leitura.
Passo 5
Implementando a propriedade delta e explicando a fórmula:
- A expressão pedida é
. - Essa expressão é chamada discriminante em muitos contextos; ela indica, por exemplo, se a equação quadrática tem raízes reais ou complexas.
- Em código, depois de termos os atributos armazenados, calculamos:
- Retornamos esse valor como float. Não precisamos verificar
aqui, pois a expressão não divide por ; apenas usamos os valores armazenados.
Passo 6
Implementando a propriedade vertice e explicando as fórmulas usadas:
- Para uma parábola definida por
(com ), o vértice tem coordenadas: - coordenada
: , - coordenada
: , onde é o discriminante .
- coordenada
- Derivação rápida e intuitiva do
: o vértice ocorre onde a derivada da função vale zero. A derivada é . Igualando a zero, obtemos → . - Para
, podemos substituir na função ou usar a fórmula direta envolvendo . A fórmula com vem de manipular a expressão algébrica da função após completar o quadrado; o resultado é . - Importante: essas fórmulas usam divisão por
. Portanto, precisamos garantir que . Se , a função não é uma parábola (fica linear) e pedir o vértice ou avaliar a fórmula do vértice causaria divisão por zero. Neste caso, é apropriado lançar uma exceção (por exemplo, ValueError) explicando que não pode ser zero para operações que assumem parábola.
Passo 7
Implementando o método avaliar(x) e explicando passo a passo:
- A expressão é
. - Em código, com os atributos armazenados e o argumento
, calculamos: - Convertendo
para float (ou deixando como está se já for numérico) evita surpresas; faremos float(x) para coerção. - Esse método funciona mesmo se
; nesse caso a expressão representa uma função linear , então avaliar ainda faz sentido.
Passo 8
Decisões de design e comportamento diante de casos limites:
- Se alguém construir Parabola(0, b, c), tecnicamente não é uma parábola. Decidi:
- permitir a construção (não impedir), pois o enunciado não proíbe
; - porém, nas propriedades que requerem divisão por
(vertice), lançar uma exceção ValueError com mensagem clara; para delta e avaliar não há problema.
- permitir a construção (não impedir), pois o enunciado não proíbe
- Retornos: coeficientes e vertice serão listas de floats; delta será float; avaliar retorna float.
- Tudo isso permite comportamento previsível na prova e no uso prático.
Resposta
class Parabola:
def init(self, a, b, c):
# Armazenamos os coeficientes como floats
self.a = float(a)
self.b = float(b)
self.c = float(c)
def init(self, a, b, c):
# Armazenamos os coeficientes como floats
self.a = float(a)
self.b = float(b)
self.c = float(c)
@property
def coeficientes(self):
# Retorna lista com [a, b, c]
return [self.a, self.b, self.c]
@property
def delta(self):
# Calcula Delta = b^2 - 4ac
return self.b * self.b - 4 * self.a * self.c
@property
def vertice(self):
# Verifica se a != 0, pois há divisão por a nas fórmulas do vértice
if self.a == 0:
raise ValueError("Coeficiente 'a' é zero: a classe não representa uma parábola quando a == 0")
xv = -self.b / (2 * self.a)
yv = -self.delta / (4 * self.a)
return [xv, yv]
def avaliar(self, x):
# Avalia ax^2 + bx + c
xv = float(x)
return self.a * xv * xv + self.b * xv + self.c