Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

10
respostas

ERRO NA EXECUÇÃO

Fala Galera!
Putz aparentemente tudo certo, mas o terminal não traz a saída como está na aula.

from modelos.restaurante import Restaurante
from modelos.cardapio.bebidas import Bebidas
from modelos.cardapio.prato import Prato

restaurante_praca = Restaurante('praça', 'gourmet')
bebida_suco = Bebidas('Suco de Laranja', 5.0, 'grande')
bebida_suco.aplicar_desconto()
prato_paozinho = Prato('Pãozinho', 2.0, 'O melhor pão da cidade')
prato_paozinho.aplicar_desconto()
restaurante_praca.adicionar_no_cardapio(bebida_suco)
restaurante_praca.adicionar_no_cardapio(prato_paozinho)

def main():
restaurante_praca.exibir_cardapio

if name == "main":
main()

_________________________________________________________________________________


# class Restaurante:

from avaliacao import Avaliacao
from cardapio.item_cardapio import ItemCardapio

class Restaurante:

restaurantes = []

 # nome da classe por convenção sempre com a primeira letra maiuscula
def __init__(self, nome, categoria):  #o self é a referência 
    self._nome = nome.title() #vai .alterar o nome para a primeira letra do nome para maiuscula
    self._categoria = categoria.upper()  #vai alterar todas as .letras para maiúscula
    self._ativo = False   #A boa prática é todos os atributos com underline ( nome, categoria, ativo)
    self._avaliacao = []
    self._cardapio = []
    Restaurante.restaurantes.append(self)

def __str__(self):
    return f'{self._nome} | {self._categoria}'

@classmethod  
def listar_restaurantes(cls):
    print(f'{'Nome do restaurante'.ljust(25)} |{'Categoria'.ljust(25)} | {'Avaliação'.ljust(25)} | {'Status'}')
    for restaurante in cls.restaurantes:
        
        print(f'{restaurante._nome.ljust(25)} | {restaurante._categoria.ljust(25)} | {str(restaurante.media_avaliacoes).ljust(25)} | {restaurante.ativo}')
@property  
def ativo(self):
    return '☒' if self._ativo else '☐'

def alternar_estado(self):
    self._ativo = not self._ativo

def receber_avaliacao(self, cliente, nota):
    if 0 < nota <= 5:
        avaliacao = Avaliacao(cliente, nota)
        self._avaliacao.append(avaliacao)

@property   
def media_avaliacoes(self):
    if not self._avaliacao:
        return '-'
    soma_das_notas = sum(avaliacao._notas for avaliacao in self._avaliacao)
    
    quantidade_de_notas = len(self._avaliacao)
    
    media = round(soma_das_notas/quantidade_de_notas, 1)
    return media


def adicionar_no_cardapio(self, item):
    if isinstance(item, ItemCardapio):   
        self._cardapio.append(item)

@property
def exibir_cardapio(self):
    print(f'Cardapio do restaurante {self._nome}\n')
    for i, item in enumerate(self._cardapio, start=1):
   
        if hasattr(item, 'descrição'):  #hasattr - se tem determinado atributo, faça isso, aqui está sendo usado para se tiver tamanho e bebida se tiver descrição é prato
            mensagem_prato = f'{i}. Nome:{item._nome}  |  Preço: R${item._preco}  | Descrição: {item.descricao}'
            print(mensagem_prato)
        else:
            mensagem_bebida = f'{i}. Nome:{item._nome}  |  Preço: R${item._preco}  | Descrição: {item.descricao}'
            print(mensagem_bebida)

        

from abc import ABC, abstractmethod

class ItemCardapio(ABC):
def init(self, nome, preco):
self._nome = nome
self._preco = preco

@abstractmethod
def aplicar_desconto(self):
    pass

from cardapio.item_cardapio import ItemCardapio

class Prato(ItemCardapio):
def init(self, nome, preco, descricao):
super().init(nome, preco)
self.descricao = descricao

def __str__(self):
    return self._nome

def aplicar_desconto(self):
    self._preco -= (self._preco * 0.08)

from cardapio.item_cardapio import ItemCardapio

class Bebidas(ItemCardapio):
def init(self, nome, preco, tamanho):
super().init(nome, preco)
self.tamanho = tamanho

def __str__(self):
    return self._nome

def aplicar_desconto(self):
    self._preco -= (self._preco * 0.05)
    
    
    _______________________________________________

Insira aqui a descrição dessa imagem para ajudar na acessibilidade

10 respostas

Olá amigo.
Precisamos analisar está linha que está acusando o erro ou a linha anterior.

  • AttributteError: 'Bebidas' object has no attribute 'descricao'
  • Verifique se está importando a classe Bebidas e se os caminhos estão corretos.
    E verifique está parte do código:
//confirma se é descrição ou descricao
  if hasattr(item, 'descrição'):  #hasattr - se tem determinado atributo, faça isso, aqui está sendo usado para se tiver tamanho e bebida se tiver descrição é prato

Se quiser que eu anlise seu código disponibilize ele no github.
Não esqueça de inserir um requeriments.txt e um gitignore.
Aguardo seu feedback.
Bons estudos.

sim está tudo ok, vou tentar enviar o código no github, porém nunca fiz

Para ficar mais facil.
Cola ele por aqui mesmo.
Até...

Fala Ronaldo,

Não consegui achar um jeito de carregar a pasta, vou mandar por etapas. Agradeço sua ajuda.
Abaixo o print com a estrutura das pastas e tela da aba restaurantes.

Insira aqui a descrição dessa imagem para ajudar na acessibilidade
Insira aqui a descrição dessa imagem para ajudar na acessibilidade

O código abaixo não apresenta erro na saída do terminal

from avaliacao import Avaliacao
from cardapio.item_cardapio import ItemCardapio

class Restaurante:

restaurantes = []

 # nome da classe por convenção sempre com a primeira letra maiuscula
def __init__(self, nome, categoria):  #o self é a referência 
    self._nome = nome.title() #vai .alterar o nome para a primeira letra do nome para maiuscula
    self._categoria = categoria.upper()  #vai alterar todas as .letras para maiúscula
    self._ativo = False   #A boa prática é todos os atributos com underline ( nome, categoria, ativo)
    self._avaliacao = []
    self._cardapio = []
    Restaurante.restaurantes.append(self)

def __str__(self):
    return f'{self._nome} | {self._categoria}'

@classmethod  #por convenção usamos o class method para trazer todos os atributos dessa classe
def listar_restaurantes(cls):
    print(f'{'Nome do restaurante'.ljust(25)} |{'Categoria'.ljust(25)} | {'Avaliação'.ljust(25)} | {'Status'}')
    for restaurante in cls.restaurantes:
        #aqui não estamos usando o self por que estamos apenas pegando o restaurante na lista restaurante
        print(f'{restaurante._nome.ljust(25)} | {restaurante._categoria.ljust(25)} | {str(restaurante.media_avaliacoes).ljust(25)} | {restaurante.ativo}')
@property  #decorator serve para mostrar algum atributo de forma diferente, nesse caso estamos decorando o ativo
def ativo(self):
    return '☒' if self._ativo else '☐'

def alternar_estado(self):
    self._ativo = not self._ativo

def receber_avaliacao(self, cliente, nota):
    if 0 < nota <= 5:
        avaliacao = Avaliacao(cliente, nota)
        self._avaliacao.append(avaliacao)

@property   #tenho que ser capaz de ler as informações por isso chamo o property
def media_avaliacoes(self):
    if not self._avaliacao:
        return '-'
    soma_das_notas = sum(avaliacao._notas for avaliacao in self._avaliacao)
    #Aqui estou indo com avaliacao._notas lá na pasta avalicao pegar os resultados
    quantidade_de_notas = len(self._avaliacao)
    #Aqui para pegar o quantidade de notas vou na lista que criei com o len
    media = round(soma_das_notas/quantidade_de_notas, 1)
    return media

# def adicionar_bebida_no_cardapio(self, bebida):
#     self._cardapio.append(bebida)

# def adicionar_prato_no_cardapio(self, prato):
#     self._cardapio.append(prato)

def adicionar_no_cardapio(self, item):
    if isinstance(item, ItemCardapio):   #se o item que vc estiver tentando adicionar for uma instância do cardápio, lá da pasta onde criou a Herança, entao adiciona ao cardápio
        self._cardapio.append(item)

@property
def exibir_cardapio(self):
    print(f'Cardapio do restaurante {self._nome}\n')
    for i, item in enumerate(self._cardapio, start=1):
    # para cada i ndice, em item, enumerate o self daquele restaurante, começando em 1
        if hasattr(item, 'descrição'):  #hasattr - se tem determinado atributo, faça isso, aqui está sendo usado para se tiver tamanho e bebida se tiver descrição é prato
            mensagem_prato = f'{i}. Nome:{item._nome}  |  Preço: R${item._preco}  | Descrição: {item.descricao}'
            print(mensagem_prato)
        else:
            mensagem_bebida = f'{i}. Nome:{item._nome}  |  Preço: R${item._preco}  | Descrição: {item.descricao}'
            print(mensagem_bebida)

from modelos.restaurante import Restaurante
from modelos.cardapio.bebidas import Bebidas
from modelos.cardapio.prato import Prato

restaurante_praca = Restaurante('praça', 'gourmet')
bebida_suco = Bebidas('Suco de Laranja', 5.0, 'grande')
bebida_suco.aplicar_desconto()
prato_paozinho = Prato('Pãozinho', 2.0, 'O melhor pão da cidade')
prato_paozinho.aplicar_desconto()
restaurante_praca.adicionar_no_cardapio(bebida_suco)
restaurante_praca.adicionar_no_cardapio(prato_paozinho)

def main():
restaurante_praca.exibir_cardapio

if name == "main":
main()

![Insira aqui a descrição dessa imagem para ajudar na acessibilidade](https://cdn1.gnarususercontent.com.br/1/7925219/95414e47-e7f7-452c-92b3-64568a7f4ae8.png)  

Ola amigo.
Me envie os código dentro de cada arquivo seguindo a sequencia.
Exemplo:

  • app.py
    • < codigo aqui dentro/>
  • avaliacao.py
    • < codigo aqui dentro/>
  • restaurante.py
    • < codigo aqui dentro/>
  • cardapio.py
    • < codigo aqui dentro/>
  • outros arquivos se tiver...
    • < codigo aqui dentro/>

Assim eu consigo analisar seu codigo e lhe dar uma resposta mais correta.
Aguardo...

Ola amigo.
Vou lhe enviar arquivo por arquivo seguindo a hierarquia abaixo:
Compara os códigos com o seu arquivo a arquivo para identificar os erros.
app.py:

from restaurante import Restaurante
from cardapio.bebidas import Bebidas
from cardapio.prato import Prato

restaurante_praca = Restaurante('praça', 'gourmet')
bebida_suco = Bebidas('Suco de Laranja', 5.0, 'grande')
bebida_suco.aplicar_desconto()
prato_paozinho = Prato('Pãozinho', 2.0, 'O melhor pão da cidade')
prato_paozinho.aplicar_desconto()
restaurante_praca.adicionar_no_cardapio(bebida_suco)
restaurante_praca.adicionar_no_cardapio(prato_paozinho)

def main():
    restaurante_praca.exibir_cardapio

if __name__ == "__main__":
    main()

avaliacao.py:

class Avaliacao:
    def __init__(self, cliente, nota):
        self._cliente = cliente
        self._notas = nota  # o nome segue o mesmo que é usado em restaurante.py

    def __str__(self):
        return f'Avaliação de {self._cliente}: {self._notas} estrelas'

restaurante.py:


from avaliacao import Avaliacao
from cardapio.item_cardapio import ItemCardapio

class Restaurante:


    restaurantes = []

    # nome da classe por convenção sempre com a primeira letra maiuscula
    def __init__(self, nome, categoria):  #o self é a referência 
        self._nome = nome.title() #vai .alterar o nome para a primeira letra do nome para maiuscula
        self._categoria = categoria.upper()  #vai alterar todas as .letras para maiúscula
        self._ativo = False   #A boa prática é todos os atributos com underline ( nome, categoria, ativo)
        self._avaliacao = []
        self._cardapio = []
        Restaurante.restaurantes.append(self)

    def __str__(self):
        return f'{self._nome} | {self._categoria}'

    @classmethod  #por convenção usamos o class method para trazer todos os atributos dessa classe
    def listar_restaurantes(cls):
        print(f'{'Nome do restaurante'.ljust(25)} |{'Categoria'.ljust(25)} | {'Avaliação'.ljust(25)} | {'Status'}')
        for restaurante in cls.restaurantes:
            #aqui não estamos usando o self por que estamos apenas pegando o restaurante na lista restaurante
            print(f'{restaurante._nome.ljust(25)} | {restaurante._categoria.ljust(25)} | {str(restaurante.media_avaliacoes).ljust(25)} | {restaurante.ativo}')
    @property  #decorator serve para mostrar algum atributo de forma diferente, nesse caso estamos decorando o ativo
    def ativo(self):
        return '☒' if self._ativo else '☐'

    def alternar_estado(self):
        self._ativo = not self._ativo

    def receber_avaliacao(self, cliente, nota):
        if 0 < nota <= 5:
            avaliacao = Avaliacao(cliente, nota)
            self._avaliacao.append(avaliacao)

    @property   #tenho que ser capaz de ler as informações por isso chamo o property
    def media_avaliacoes(self):
        if not self._avaliacao:
            return '-'
        soma_das_notas = sum(avaliacao._notas for avaliacao in self._avaliacao)
        #Aqui estou indo com avaliacao._notas lá na pasta avalicao pegar os resultados
        quantidade_de_notas = len(self._avaliacao)
        #Aqui para pegar o quantidade de notas vou na lista que criei com o len
        media = round(soma_das_notas/quantidade_de_notas, 1)
        return media

    def adicionar_bebida_no_cardapio(self, bebida):
        self._cardapio.append(bebida)

    def adicionar_prato_no_cardapio(self, prato):
        self._cardapio.append(prato)

    def adicionar_no_cardapio(self, item):
        if isinstance(item, ItemCardapio):   #se o item que vc estiver tentando adicionar for uma instância do cardápio, lá da pasta onde criou a Herança, entao adiciona ao cardápio
            self._cardapio.append(item)

    @property
    def exibir_cardapio(self):
        print(f'Cardapio do restaurante {self._nome}\n')
        for i, item in enumerate(self._cardapio, start=1):
        # para cada i ndice, em item, enumerate o self daquele restaurante, começando em 1
            if hasattr(item, 'descrição'):  #hasattr - se tem determinado atributo, faça isso, aqui está sendo usado para se tiver tamanho e bebida se tiver descrição é prato
                mensagem_prato = f'{i}. Nome:{item._nome}  |  Preço: R${item._preco}  | Descrição: {item.descricao}'
                print(mensagem_prato)
            else:
                mensagem_bebida = f'{i}. Nome:{item._nome}  |  Preço: R${item._preco}  | Descrição: {item.descricao}'
            print(mensagem_bebida)

continua...

cardapio/bebidas.py:

from cardapio.item_cardapio import ItemCardapio

class Bebidas(ItemCardapio):
    def __init__(self, nome, preco, tamanho):
        super().__init__(nome, preco)
        self.tamanho = tamanho

    def aplicar_desconto(self):
        # Bebidas grandes ganham 5% de desconto
        if self.tamanho.lower() == 'grande':
            self._preco *= 0.95

    @property
    def descricao(self):
        return f'Tamanho: {self.tamanho}'

cardapio/prato.py:

from cardapio.item_cardapio import ItemCardapio

class Prato(ItemCardapio):
    def __init__(self, nome, preco, descricao):
        super().__init__(nome, preco)
        self.descricao = descricao

    def aplicar_desconto(self):
        # Todos os pratos ganham 8% de desconto
        self._preco *= 0.92

cardapio/item_cardapio:

class ItemCardapio:
    def __init__(self, nome, preco):
        self._nome = nome
        self._preco = preco

    def __str__(self):
        return f'{self._nome} - R${self._preco:.2f}'

    def aplicar_desconto(self):
        # Método genérico que pode ser sobrescrito nas subclasses
        pass

Analisa o codigo com calma, faz as correçoes necessarias e envia um feedback com o resultado.
Bons estudos.

Cara...nem acredito funcionou!

Só que pelo que vi nas alterações, mas pelo que vi com essas alterações, eliminaram o conteudo sobre o @abastractmethod.

Qual a diferença do conteúdo sem o abastract agora? Será que vai impactar no código mais pra frente sem ele?

Insira aqui a descrição dessa imagem para ajudar na acessibilidade

Ola amigo.
Fico feliz que tenha dado certo.
Respondendo sua pergunta:

  • Será que vai impactar no código mais pra frente sem ele?
    Acredito que não mas vai fazendo testes e anotando as mudanças.
    A melhor hora de aprender é agora sem medo de quebrar seu código.
    Explore a vontade e implemente o que achar necessario.
    Qualquer duvida comente ai.
    E peço que encerre este post marcando como solucionado.
    Bons estudos.