Implemente uma classe Parabola, considerando que os objetos do tipo Parabola:
  • são construídos a partir de 3 números reais, a, b e c;
  • possuem uma property coeficientes, que retorna uma lista com os valores de a, b e c;
  • possuem uma property delta, que retorna o valor da expressão b^{2}-4 a c;
  • possuem uma property vertice, que retorna uma lista com os valores das expressões, \frac{-b}{2 a} e \frac{-\Delta}{4 a}, onde \Delta é o valor da property descrita no item anterior e
  • possuem um método avaliar, que recebe um valor x e retorna o valor da expressão a x^{2}+b x+c, onde a, b e c 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 a, b e c.
  • Possui uma propriedade (property) chamada coeficientes que retorna uma lista com os valores de a, b e c.
  • Possui uma propriedade chamada delta que retorna o valor da expressão b^{2}-4ac.
  • Possui uma propriedade chamada vertice que retorna uma lista com os valores \frac{-b}{2a} e \frac{-\Delta}{4a}, onde \Delta é o valor da property delta.
  • Possui um método avaliar(x) que retorna o valor da expressão ax^{2}+bx+c para o valor dado de x.
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 a, b e c 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 x.
    Vou implementar verificações mínimas para evitar divisão por zero nas fórmulas que usam a no denominador (ou seja, quando a = 0). Explicarei o porquê dessas verificações.

Passo 3

Explicando o construtor e armazenamento de atributos:
  • O construtor recebe três números a, b e c.
  • 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: \text{self.a} = float(a), 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 a, b e c.
  • Em código isso é direto: retornar [\text{self.a}, \text{self.b}, \text{self.c}].
  • 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 é \Delta = b^{2} - 4ac.
  • 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: \Delta = (\text{self.b})^{2} - 4 \cdot \text{self.a} \cdot \text{self.c}
  • Retornamos esse valor como float. Não precisamos verificar a=0 aqui, pois a expressão não divide por a; apenas usamos os valores armazenados.

Passo 6

Implementando a propriedade vertice e explicando as fórmulas usadas:
  • Para uma parábola definida por y = ax^{2} + bx + c (com a \neq 0), o vértice tem coordenadas:
    • coordenada x: \displaystyle x_v = \frac{-b}{2a},
    • coordenada y: \displaystyle y_v = \frac{-\Delta}{4a}, onde \Delta é o discriminante b^{2}-4ac.
  • Derivação rápida e intuitiva do x_v: o vértice ocorre onde a derivada da função vale zero. A derivada é y' = 2ax + b. Igualando a zero, obtemos 2ax + b = 0 x = -b/(2a).
  • Para y_v, podemos substituir x_v na função ou usar a fórmula direta envolvendo \Delta. A fórmula com \Delta vem de manipular a expressão algébrica da função após completar o quadrado; o resultado é \displaystyle y_v = -\frac{\Delta}{4a}.
  • Importante: essas fórmulas usam divisão por a. Portanto, precisamos garantir que \text{self.a} \neq 0. Se \text{self.a} = 0, 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 a 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 é ax^{2} + bx + c.
  • Em código, com os atributos armazenados e o argumento x, calculamos: \text{valor} = \text{self.a} \cdot x^{2} + \text{self.b} \cdot x + \text{self.c}
  • Convertendo x 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 \text{self.a} = 0; nesse caso a expressão representa uma função linear bx + c, 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 a=0;
    • porém, nas propriedades que requerem divisão por a (vertice), lançar uma exceção ValueError com mensagem clara; para delta e avaliar não há problema.
  • 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)
@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

Exercícios relacionados