1
resposta

[Minha Resposta] 08 Hora da prática: instância de uma classe

# 1- Crie uma Classe Pai (Veiculo): Implemente uma classe chamada Veiculo com um construtor que aceita dois parâmetros, marca e modelo.


class Vehicle:
    def __init__(self, make: str, model: str):
        self.make = make
        self.model = model
        # 2- A classe deve ter um atributo protegido _ligado inicializado como False por padrão.
        self._started = False

    # 2- Construa o Método Especial str: Adicione um método especial str à classe Veiculo que retorna uma mensagem formatada com a marca, modelo e o estado de ligado/desligado do veículo.
    def __str__(self):
        start = "on" if self._started else "off"
        return f"Make: {self.make} | Model: {self.model} | Vehicle is: {start}"
from vehicle import Vehicle

# 3 Crie uma Classe Filha (Carro): Agora, crie uma classe chamada Carro que herda da classe Veiculo.


class Car(Vehicle):
    # 4 - No construtor da classe Carro, inclua um novo atributo chamado portas que indica a quantidade de portas do carro.
    def __init__(self, make: str, model: str, doors: int):
        super().__init__(make, model)
        self.doors = doors

    # 5 - Implemente o Método Especial str na Classe Filha: Adicione um método especial str à classe Carro que estenda o método da classe pai (Veiculo) e inclua a informação sobre a quantidade de portas do carro.
    def __str__(self):
        return f"{super().__str__()} | doors: {self.doors}"
from vehicle import Vehicle

# 6- Crie uma Classe Filha (Moto): Similarmente, crie uma classe chamada Moto que também herda de Veiculo. Adicione um novo atributo chamado tipo ao construtor, indicando se a moto é esportiva ou casual.


class Motorcycle(Vehicle):
    def __init__(self, make: str, model: str, motorcycle_type: str):
        super().__init__(make, model)
        self.motorcycle_type = motorcycle_type

    # 7- Implemente o Método Especial str na Classe Filha (Moto): Adicione um método especial str à classe Moto que estenda o método da classe pai (Veiculo) e inclua a informação sobre o tipo da moto.
    def __str__(self):
        return f"{super().__str__()} | Motorcycle type: {self.motorcycle_type}"
# 8- Crie um Arquivo Main (main.py): Crie um arquivo chamado main.py no mesmo diretório que suas classes.
# 9- Importe e Instancie Objetos: No arquivo main.py, importe as classes Carro e Moto.

from cars import Car
from motorcycles import Motorcycle
from vehicle import Vehicle


# 10-  Em seguida, crie três instâncias de Carro e Moto com diferentes marcas, modelos, quantidade de portas e tipos(esportiva ou casual).

# Car
fusca = Car("Volkswagen", "Fusca", 2)
clio = Car("Renault", "Clio", 4)
pegeout_2008 = Car("Pegeout", "Pegeout 2008", 4)

# Motorcycle
suzuki = Motorcycle("Suzuki", "Hayabusa", "sports")
honda = Motorcycle("Honda", "CB1000 Hornet", "casual")
kawasaki = Motorcycle("Kawasaki", "Ninja 400", "sports")


# 11- Exiba as Informações: Para cada instância, imprima no console as informações utilizando o método str.

print(fusca)
print(clio)
print(pegeout_2008)
print()
print(suzuki)
print(honda)
print(kawasaki)
print()

# answer 11 better way:
print("VEHICLES:\n")
vehicle_list = [fusca, clio, pegeout_2008, suzuki, honda, kawasaki]
for vehicle in vehicle_list:
    if isinstance(vehicle, Vehicle):
        print(f"{(type(vehicle).__name__).upper()} - {vehicle}")
    else:
        raise Exception("Object is not a valid vehicle.")
1 resposta

Olá, Thaís! Como vai?

Parabéns pela resolução da atividade!

Observei que você explorou o uso de herança para estruturar as classes, utilizou muito bem o método especial __str__ para personalizar a saída e ainda compreendeu a importância de atributos específicos em subclasses para diferenciar os tipos de veículos.

Uma dica interessante para o futuro é implementar métodos adicionais que simulem ações dos veículos, como ligar e desligar. Assim:

class Vehicle:
    def __init__(self, make: str, model: str):
        self.make = make
        self.model = model
        self._started = False

    def start(self):
        self._started = True
        print(f"{self.make} {self.model} foi ligado.")

    def stop(self):
        self._started = False
        print(f"{self.make} {self.model} foi desligado.")

    def __str__(self):
        start = "on" if self._started else "off"
        return f"Make: {self.make} | Model: {self.model} | Vehicle is: {start}"

Isso faz com que os objetos não apenas exibam informações, mas também tenham comportamentos que simulam ações reais de veículos, tornando o código mais interativo e próximo de aplicações práticas.

Fico à disposição! E se precisar, conte sempre com o apoio do fórum.

Abraço e bons estudos!

AluraConte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!