# -*- coding: utf-8 -*-

# -----------------------------------------------------------------------------

# Sistema de Gerenciamento de Estoque

# -----------------------------------------------------------------------------

# --- Variáveis Globais ---

# Usaremos uma lista de dicionários para armazenar os produtos.

# Cada dicionário representará um produto.

Estoque = []

Proximo_id_produto = 1 # Para gerar Ids únicos automaticamente

# --- Funções Auxiliares (Validação e Utilitários) ---

Def obter_inteiro_valido(mensagem_prompt):

“””Solicita um inteiro ao usuário e valida a entrada.”””

While True:

Try:

Valor = int(input(mensagem_prompt))

Return valor

Except ValueError:

Print(“Entrada inválida. Por favor, digite um número inteiro.”)

Def obter_float_valido(mensagem_prompt):

“””Solicita um float ao usuário e valida a entrada.”””

While True:

Try:

Valor = float(input(mensagem_prompt))

If valor < 0:
Print(“O valor não pode ser negativo. Tente novamente.”)

Continue

Return valor

Except ValueError:

Print(“Entrada inválida. Por favor, digite um número (ex: 10.50).”)

Def buscar_produto_por_id(id_produto):

“””Busca um produto na lista de estoque pelo seu ID.”””

For produto in estoque:

If produto[“ID”] == id_produto:

Return produto

Return None

Def exibir_detalhes_produto(produto):

“””Exibe os detalhes de um produto de forma formatada.”””

Print(“\n--- Detalhes do Produto ---“)

Print(f”ID: {produto[‘ID’]}”)

Print(f”Nome: {produto[‘nome’]}”)

Print(f”Categoria: {produto[‘categoria’]}”)

Print(f”Quantidade em Estoque: {produto[‘quantidade’]}”)

Print(f”Preço: R$ {produto[‘preco’]:.2f}”)

Print(f”Estoque Mínimo: {produto[‘estoque_minimo’]}”)

Print(“---------------------------“)

Def verificar_alerta_estoque_baixo(produto):

“””Verifica se a quantidade do produto está abaixo do mínimo e emite alerta.”””

If produto[“quantidade”] < produto[“estoque_minimo”]:

Print(f”\n!!! ALERTA: Estoque baixo para o produto ‘{produto[‘nome’]}’ (ID:
{produto[‘ID’]}) !!!”)

Print(f” Quantidade atual: {produto[‘quantidade’]}, Mínimo:

{produto[‘estoque_minimo’]}”)

# --- Funcionalidades Principais ---

Def adicionar_produto():

“””Adiciona um novo produto ao estoque.”””

Global proximo_id_produto

Print(“\n--- Adicionar Novo Produto ---“)

Nome = input(“Nome do produto: “).strip()

Categoria = input(“Categoria do produto: “).strip()

Quantidade = obter_inteiro_valido(“Quantidade em estoque: “)

Preco = obter_float_valido(“Preço do produto (R$): “)

Estoque_minimo = obter_inteiro_valido(“Estoque mínimo desejado: “)

If not nome or not categoria:

Print(“Erro: Nome e categoria não podem ser vazios.”)

Return

If quantidade < 0:

Print(“Erro: A quantidade em estoque não pode ser negativa.”)

Return

Novo_produto = {

“ID”: proximo_id_produto,

“nome”: nome,

“categoria”: categoria,
“quantidade”: quantidade,

“preco”: preco,

“estoque_minimo”: estoque_minimo

[Link](novo_produto)

Proximo_id_produto += 1

Print(f”Produto ‘{nome}’ (ID: {novo_produto[‘ID’]}) adicionado com sucesso!”)

Verificar_alerta_estoque_baixo(novo_produto)

Def remover_produto():

“””Remove um produto do estoque pelo ID.”””

Print(“\n--- Remover Produto ---“)

If not estoque:

Print(“Não há produtos cadastrados para remover.”)

Return

Id_remover = obter_inteiro_valido(“Digite o ID do produto a ser removido: “)

Produto_encontrado = buscar_produto_por_id(id_remover)

If produto_encontrado:

[Link](produto_encontrado)

Print(f”Produto ‘{produto_encontrado[‘nome’]}’ (ID: {id_remover}) removido com

sucesso.”)

Else:

Print(f”Produto com ID {id_remover} não encontrado.”)

Def editar_produto():

“””Edita as informações de um produto existente no estoque.”””

Print(“\n--- Editar Produto ---“)

If not estoque:

Print(“Não há produtos cadastrados para editar.”)

Return

Id_editar = obter_inteiro_valido(“Digite o ID do produto a ser editado: “)

Produto = buscar_produto_por_id(id_editar)

If produto:

Print(f”Editando produto: {produto[‘nome’]} (ID: {produto[‘ID’]})”)

# Manter valor antigo se entrada for vazia

Novo_nome = input(f”Novo nome ({produto[‘nome’]}): “).strip()

If novo_nome: produto[‘nome’] = novo_nome

Nova_categoria = input(f”Nova categoria ({produto[‘categoria’]}): “).strip()

If nova_categoria: produto[‘categoria’] = nova_categoria

Try:

Nova_quantidade_str = input(f”Nova quantidade ({produto[‘quantidade’]}):

“).strip()

If nova_quantidade_str:

Nova_quantidade = int(nova_quantidade_str)

If nova_quantidade < 0:

Print(“Quantidade não pode ser negativa. Mantendo valor anterior.”)

Else:

Produto[‘quantidade’] = nova_quantidade

Except ValueError:

Print(“Entrada de quantidade inválida. Mantendo valor anterior.”)

Try:

Novo_preco_str = input(f”Novo preço ({produto[‘preco’]:.2f}): “).strip()

If novo_preco_str:

Novo_preco = float(novo_preco_str)

If novo_preco < 0:

Print(“Preço não pode ser negativo. Mantendo valor anterior.”)

Else:

Produto[‘preco’] = novo_preco

Except ValueError:

Print(“Entrada de preço inválida. Mantendo valor anterior.”)

Try:

Novo_estoque_minimo_str = input(f”Novo estoque mínimo

({produto[‘estoque_minimo’]}): “).strip()

If novo_estoque_minimo_str:

Novo_estoque_minimo = int(novo_estoque_minimo_str)

If novo_estoque_minimo < 0:

Print(“Estoque mínimo não pode ser negativo. Mantendo valor anterior.”)

Else:

Produto[‘estoque_minimo’] = novo_estoque_minimo

Except ValueError:

Print(“Entrada de estoque mínimo inválida. Mantendo valor anterior.”)

Print(“Produto atualizado com sucesso!”)

Exibir_detalhes_produto(produto)

Verificar_alerta_estoque_baixo(produto)
Else:

Print(f”Produto com ID {id_editar} não encontrado.”)

Def registrar_entrada_estoque():

“””Registra a entrada de unidades de um produto no estoque.”””

Print(“\n--- Registrar Entrada de Estoque ---“)

If not estoque:

Print(“Não há produtos cadastrados.”)

Return

Id_produto = obter_inteiro_valido(“Digite o ID do produto: “)

Produto = buscar_produto_por_id(id_produto)

If produto:

Quantidade_entrada = obter_inteiro_valido(f”Digite a quantidade de

‘{produto[‘nome’]}’ que está entrando: “)

If quantidade_entrada > 0:

Produto[“quantidade”] += quantidade_entrada

Print(f”{quantidade_entrada} unidades de ‘{produto[‘nome’]}’ adicionadas ao

estoque.”)

Print(f”Nova quantidade em estoque: {produto[‘quantidade’]}”)

# Mesmo sendo entrada, o estoque mínimo pode ter sido alterado e o alerta ser
relevante

Verificar_alerta_estoque_baixo(produto)

Elif quantidade_entrada == 0:

Print(“Nenhuma unidade adicionada.”)

Else:

Print(“Quantidade de entrada deve ser um número positivo.”)

Else:
Print(f”Produto com ID {id_produto} não encontrado.”)

Def registrar_saida_estoque():

“””Registra a saída de unidades de um produto do estoque.”””

Print(“\n--- Registrar Saída de Estoque ---“)

If not estoque:

Print(“Não há produtos cadastrados.”)

Return

Id_produto = obter_inteiro_valido(“Digite o ID do produto: “)

Produto = buscar_produto_por_id(id_produto)

If produto:

Quantidade_saida = obter_inteiro_valido(f”Digite a quantidade de

‘{produto[‘nome’]}’ que está saindo: “)

If quantidade_saida > 0:

If produto[“quantidade”] >= quantidade_saida:

Produto[“quantidade”] -= quantidade_saida

Print(f”{quantidade_saida} unidades de ‘{produto[‘nome’]}’ removidas do

estoque.”)

Print(f”Nova quantidade em estoque: {produto[‘quantidade’]}”)

Verificar_alerta_estoque_baixo(produto)

Else:

Print(f”Erro: Quantidade de saída ({quantidade_saida}) maior que o estoque

disponível ({produto[‘quantidade’]}).”)

Elif quantidade_saida == 0:

Print(“Nenhuma unidade removida.”)

Else:

Print(“Quantidade de saída deve ser um número positivo.”)

Else:

Print(f”Produto com ID {id_produto} não encontrado.”)

Def consultar_produtos():

“””Permite consultar produtos por ID, nome ou categoria.”””

Print(“\n--- Consultar Produtos ---“)

If not estoque:

Print(“Não há produtos cadastrados para consulta.”)

Return

Print(“Opções de consulta:”)

Print(“1. Por ID”)

Print(“2. Por Nome”)

Print(“3. Por Categoria”)

Escolha_consulta = input(“Escolha o tipo de consulta (1-3): “)

Resultados_encontrados = []

If escolha_consulta == ‘1’:

Id_busca = obter_inteiro_valido(“Digite o ID do produto: “)

Produto = buscar_produto_por_id(id_busca)

If produto:

Resultados_encontrados.append(produto)

Elif escolha_consulta == ‘2’:

Nome_busca = input(“Digite o nome (ou parte do nome) do produto:

“).strip().lower()

If not nome_busca:

Print(“Nome para busca não pode ser vazio.”)

Return

For produto in estoque:

If nome_busca in produto[“nome”].lower():

Resultados_encontrados.append(produto)

Elif escolha_consulta == ‘3’:

Categoria_busca = input(“Digite a categoria (ou parte da categoria) do produto:

“).strip().lower()

If not categoria_busca:

Print(“Categoria para busca não pode ser vazia.”)

Return

For produto in estoque:

If categoria_busca in produto[“categoria”].lower():

Resultados_encontrados.append(produto)

Else:

Print(“Opção de consulta inválida.”)

Return

If resultados_encontrados:

Print(f”\n--- {len(resultados_encontrados)} Produto(s) Encontrado(s) ---“)

For produto in resultados_encontrados:

Exibir_detalhes_produto(produto)

Else:

Print(“Nenhum produto encontrado com os critérios fornecidos.”)

Def gerar_relatorio_estoque_completo():

“””Gera um relatório com todos os produtos em estoque.”””

Print(“\n--- Relatório de Estoque Completo ---“)

If not estoque:
Print(“Estoque vazio. Nenhum produto para listar.”)

Return

For produto in estoque:

Exibir_detalhes_produto(produto)

# Adiciona uma verificação de alerta aqui também, para o relatório ser informativo

If produto[“quantidade”] < produto[“estoque_minimo”]:

Print(f” -> ALERTA: Estoque baixo! (Atual: {produto[‘quantidade’]}, Mínimo:

{produto[‘estoque_minimo’]})”)

Print(“----“) # Separador visual entre produtos no relatório

Def gerar_relatorio_baixo_estoque():

“””Gera um relatório de produtos com quantidade abaixo do estoque mínimo.”””

Print(“\n--- Relatório de Produtos com Baixo Estoque ---“)

Produtos_com_baixo_estoque = []

For produto in estoque:

If produto[“quantidade”] < produto[“estoque_minimo”]:

Produtos_com_baixo_estoque.append(produto)

If produtos_com_baixo_estoque:

Print(f”Encontrado(s) {len(produtos_com_baixo_estoque)} produto(s) com baixo

estoque:”)

For produto in produtos_com_baixo_estoque:

Exibir_detalhes_produto(produto)

Else:

Print(“Nenhum produto com baixo estoque encontrado. Tudo certo!”)

# --- Menu Principal ---

Def exibir_menu():

“””Exibe o menu principal do sistema.”””

Print(“\n--- Sistema de Gerenciamento de Estoque ---“)

Print(“1. Adicionar Produto”)

Print(“2. Remover Produto”)

Print(“3. Editar Produto”)

Print(“4. Registrar Entrada de Estoque”)

Print(“5. Registrar Saída de Estoque”)

Print(“6. Consultar Produtos”)

Print(“7. Relatório de Estoque Completo”)

Print(“8. Relatório de Produtos com Baixo Estoque”)

Print(“0. Sair do Sistema”)

Print(“-------------------------------------------“)

# --- Execução Principal ---

If __name__ == “__main__”:

# Exemplo de produtos iniciais (para teste)

# Descomente as linhas abaixo para iniciar com alguns produtos

# [Link]({“ID”: proximo_id_produto, “nome”: “Caneta Azul”, “categoria”:

“Material Escritório”, “quantidade”: 100, “preco”: 1.50, “estoque_minimo”: 20});
proximo_id_produto+=1

# [Link]({“ID”: proximo_id_produto, “nome”: “Caderno 96fl”,

“categoria”: “Material Escritório”, “quantidade”: 15, “preco”: 12.00,
“estoque_minimo”: 30}); proximo_id_produto+=1

# [Link]({“ID”: proximo_id_produto, “nome”: “Mouse Gamer”,

“categoria”: “Informática”, “quantidade”: 50, “preco”: 150.75, “estoque_minimo”:
10}); proximo_id_produto+=1

While True:
Exibir_menu()

Escolha = input(“Escolha uma opção: “).strip()

If escolha == ‘1’:

Adicionar_produto()

Elif escolha == ‘2’:

Remover_produto()

Elif escolha == ‘3’:

Editar_produto()

Elif escolha == ‘4’:

Registrar_entrada_estoque()

Elif escolha == ‘5’:

Registrar_saida_estoque()

Elif escolha == ‘6’:

Consultar_produtos()

Elif escolha == ‘7’:

Gerar_relatorio_estoque_completo()

Elif escolha == ‘8’:

Gerar_relatorio_baixo_estoque()

Elif escolha == ‘0’:

Print(“Saindo do sistema de gerenciamento de estoque. Até logo!”)

Break

Else:

Print(“Opção inválida. Por favor, tente novamente.”)

Input(“\nPressione Enter para continuar...”) # Pausa para o usuário ler a saída

Explicação:
Este código em Python implementa um sistema básico de gerenciamento de
estoque.

Linhas Iniciais:

* # -*- coding: utf-8 -*-: Esta linha define a codificação de caracteres do arquivo
como UTF-8, o que permite o uso de caracteres especiais, como os da língua
portuguesa (acentos, cedilha, etc.).

* Os comentários subsequentes apenas descrevem o sistema e separam as

seções do código para melhor organização.

Estrutura Principal:

O código organiza as funcionalidades do sistema em diferentes seções:

* Variáveis Globais: Define estoque (uma lista para armazenar os produtos como
dicionários) e proximo_id_produto (para gerar Ids únicos).

* Funções Auxiliares: Contém funções para validar entradas do usuário

(obter_inteiro_valido, obter_float_valido), buscar produtos por ID
(buscar_produto_por_id), exibir detalhes de um produto (exibir_detalhes_produto)
e verificar alertas de estoque baixo (verificar_alerta_estoque_baixo).

* Funcionalidades Principais: Implementa as ações do sistema, como adicionar

(adicionar_produto), remover (remover_produto), editar (editar_produto), registrar
entrada (registrar_entrada_estoque) e saída (registrar_saida_estoque) de estoque,
consultar produtos (consultar_produtos) e gerar relatórios
(gerar_relatorio_estoque_completo, gerar_relatorio_baixo_estoque).

* Menu Principal: A função exibir_menu mostra as opções disponíveis para o

usuário.

* Execução Principal (if __name__ == “__main__”☺: Este bloco de código é

executado quando o script é rodado diretamente. Ele apresenta um loop while que
exibe o menu, recebe a escolha do usuário e chama a função correspondente até
que o usuário escolha sair.

Em resumo, o código cria um sistema interativo via terminal que permite ao

usuário:

* Adicionar, remover e editar informações de produtos.

* Registrar entradas e saídas de itens do estoque.

* Consultar produtos por diferentes critérios.

* Gerar relatórios do estoque completo e de produtos com baixo estoque.

É um exemplo prático de como usar listas e dicionários em Python para gerenciar
dados de forma organizada e implementar funcionalidades através de funções.