Introdução

Neste projeto, vamos criar um sistema simples de gestão de inventário utilizando Programação Orientada a Objetos (POO) em Python. Este projeto permitirá que solidifiquem os vossos conhecimentos em POO e explorem o uso de ficheiros para armazenar dados sem recorrer a bases de dados. Iremos trabalhar com conceitos importantes, como classes, objetos, métodos e encapsulamento.

Objetivos do Projeto

1. Compreender os conceitos de POO aplicados à gestão de inventário.
2. Criar classes e objetos para representar itens de inventário.
3. Implementar métodos para adicionar, remover e procurar itens no inventário.
4. Usar ficheiros para persistir os dados de inventário.

Estrutura do Projeto

Definição das Classes

Vamos começar por definir uma classe Item, que representa cada item no inventário, e uma classe Inventario, que irá gerir os vários objetos Item.

class Item:
    def __init__(self, nome, quantidade, preco):
        self.nome = nome
        self.quantidade = quantidade
        self.preco = preco
    
    def __str__(self):
        return f"{self.nome} - Quantidade: {self.quantidade}, Preço: {self.preco}"

Neste exemplo, a classe Item possui três atributos: nome, quantidade, e preco. O método especial __str__ permite que uma representação textual do objeto seja devolvida.

Agora, podemos definir a classe Inventario:

class Inventario:
    def __init__(self):
        self.itens = []

    def adicionar_item(self, item):
        self.itens.append(item)
        print(f"Item {item.nome} adicionado com sucesso!")

    # Método incompleto para ser preenchido:
    def remover_item(self, nome):
        # Implementa a lógica para remover um item pelo nome

Adicionando Funcionalidades

Agora, podemos implementar o método para remover um item do inventário:

class Inventario:
    # ... (outros métodos)

    def remover_item(self, nome):
        for item in self.itens:
            if item.nome == nome:
                self.itens.remove(item)
                print(f"Item {nome} removido com sucesso!")
                return
        print(f"Item {nome} não encontrado.")

Além dos métodos adicionar_item e remover_item, podemos adicionar um método que permite procurar itens no inventário:

    def procurar_item(self, nome):
        for item in self.itens:
            if item.nome == nome:
                print(f"Item encontrado: {item}")
                return item
        print(f"Item {nome} não encontrado.")
        return None

Persistência de Dados

Para garantir que o inventário persiste entre execuções, podemos guardar os dados num ficheiro de texto. Vamos criar dois métodos na classe Inventario para guardar e carregar o inventário.

    def guardar_ficheiro(self, nome_ficheiro):
        with open(nome_ficheiro, 'w') as f:
            for item in self.itens:
                f.write(f"{item.nome},{item.quantidade},{item.preco}\n")

    def carregar_ficheiro(self, nome_ficheiro):
        self.itens = []  # Limpar o inventário antes de carregar
        try:
            with open(nome_ficheiro, 'r') as f:
                for linha in f:
                    nome, quantidade, preco = linha.strip().split(',')
                    self.adicionar_item(Item(nome, int(quantidade), float(preco)))
        except FileNotFoundError:
            print(f"{nome_ficheiro} não encontrado, começando com inventário vazio.")

Testando o Programa

Vamos testar o nosso programa através de um pequeno script que mostra os métodos em funcionamento.

def main():
    inventario = Inventario()
    inventario.carregar_ficheiro('inventario.txt')
    
    item1 = Item("Caneta", 20, 0.50)
    item2 = Item("Caderno", 15, 3.00)
    
    inventario.adicionar_item(item1)
    inventario.adicionar_item(item2)
    
    inventario.procurar_item("Caneta")
    inventario.remover_item("Caderno")
    inventario.guardar_ficheiro('inventario.txt')

if __name__ == "__main__":
    main()

Exemplo de saída:

Item Caneta adicionado com sucesso!
Item Caderno adicionado com sucesso!
Item encontrado: Caneta - Quantidade: 20, Preço: 0.5
Item Caderno removido com sucesso!

Solução alternativa

Implemente uma solução alternativa utilizando atributos e métodos de classe

Resumo

Neste capítulo, desenvolvemos um sistema básico de gestão de inventário utilizando POO em Python. Criámos classes para representar itens e gerir o inventário, implementámos métodos para adicionar, remover e procurar itens, e garantimos a persistência dos dados utilizando ficheiros de texto. Estes conceitos são fundamentais em muitas aplicações da vida real, desde lojas a armazéns, onde o controlo eficaz do inventário é crucial.

Quiz

1. O que é encapsulamento e como foi aplicado neste projeto?
2. Como podem ser utilizados os métodos guardar_ficheiro e carregar_ficheiro para garantir a persistência dos dados de inventário?
3. Explique como o método remover_item funciona. Qual é a sua lógica principal?
4. Descreva como adicionar um novo atributo à classe Item e garantir que este é devidamente tratado ao guardar e carregar os dados num ficheiro.
5. Qual é a função do método especial __str__ e como ele foi implementado na classe Item?

Explore os conceitos discutidos e teste os seus conhecimentos para consolidar o que aprendeu neste capítulo!