Stacks.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "de5e442f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Pilhas\n",
    "            \n",
    "        Conceitos Básicos\n",
    "\n",
    "            Definição e Estrutura: Entender o que é uma pilha e como ela é organizada.\n",
    "            \n",
    "\n",
    "Pilhas: Pilhas são uma estrutura de dados linear que segue o princípio \n",
    "de Last In First Out (LIFO). Isso significa que o último elemento inserido \n",
    "na pilha será o primeiro a ser removido. As operações básicas associadas \n",
    "às pilhas são: push (adicionar um item ao topo) e pop (remover o item do topo).\n",
    "\n",
    "\n",
    "Definição e Estrutura:\n",
    "\n",
    "\n",
    "1 - Definição: \n",
    "\n",
    "Uma pilha é uma coleção ordenada de itens na qual a adição \n",
    "de novos itens e a remoção de itens existentes sempre ocorrem no mesmo \n",
    "final. Esse final é comumente referido como o \"topo\". O final oposto da \n",
    "pilha é conhecido como \"base\".\n",
    "\n",
    "\n",
    "2 - Características:\n",
    "\n",
    "A pilha é uma estrutura LIFO (Last In, First Out).\n",
    "\n",
    "Somente o elemento no topo da pilha é acessível. Para acessar \n",
    "outros elementos, você teria que remover os que estão no topo primeiro.\n",
    "\n",
    "\n",
    "3 - Operações Básicas:\n",
    "\n",
    "push(): Adiciona um item ao topo da pilha.\n",
    "\n",
    "pop(): Remove e retorna o item do topo da pilha.\n",
    "\n",
    "peek() ou top(): Retorna o item do topo sem removê-lo.\n",
    "\n",
    "is_empty(): Verifica se a pilha está vazia.\n",
    "\n",
    "size(): Retorna o número de elementos na pilha.\n",
    "\n",
    "\n",
    "Em Python, podemos implementar pilhas usando listas ou através da \n",
    "classe deque da biblioteca collections\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b713e64",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "51d757ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adicionando Prato 1\n",
      "Adicionando Prato 2\n",
      "Topo da pilha: Prato 3\n",
      "Removendo: Prato 3\n",
      "Removendo: Prato 2\n",
      "Adicionando Prato 4\n",
      "Topo da pilha: Prato 4\n",
      "A pilha tem pratos.\n",
      "A pilha tem 2 pratos.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "\n",
    "Pilhas\n",
    "            \n",
    "        Conceitos Básicos\n",
    "\n",
    "            Last In, First Out (LIFO): Compreensão do princípio \n",
    "            fundamental que rege as operações de uma pilha.\n",
    "\n",
    "            \n",
    "Vamos começar com uma analogia simples e, em seguida, \n",
    "apresentar um exemplo prático em Python.\n",
    "\n",
    "Analogia:\n",
    "\n",
    "Imagine uma pilha de pratos. Quando você adiciona (lava) um prato, \n",
    "você o coloca no topo da pilha. E quando você precisa pegar um \n",
    "prato (para usar), você sempre pega o do topo da pilha, que é o \n",
    "último prato que foi colocado lá. Portanto, o último prato que você \n",
    "colocou (Last In) é o primeiro que você pega (First Out).\n",
    "\n",
    "\n",
    "Exemplo Prático em Python:\n",
    "\n",
    "Vamos usar a implementação de pilha que fizemos anteriormente \n",
    "e demonstrar o princípio LIFO.\n",
    "\"\"\"\n",
    "\n",
    "# Define uma classe chamada 'Pilha'\n",
    "class Pilha:\n",
    "    \n",
    "    # Construtor da classe, que é chamado quando um objeto desta classe é criado\n",
    "    def __init__(self):\n",
    "        \n",
    "        # Cria uma lista vazia chamada 'pratos' para representar a pilha\n",
    "        self.pratos = []\n",
    "        \n",
    "    # Método para adicionar (push) um elemento ao topo da pilha\n",
    "    def adicionar(self, prato):\n",
    "        \n",
    "        # Usa o método 'append' da lista para adicionar \n",
    "        # o elemento ao final (topo da pilha)\n",
    "        self.pratos.append(prato)\n",
    "\n",
    "    # Método para remover (pop) o elemento do topo da pilha\n",
    "    def remover(self):\n",
    "        \n",
    "        # Primeiro, verifica se a pilha não está vazia\n",
    "        if not self.esta_vazia():\n",
    "            \n",
    "            # Usa o método 'pop' da lista para remover \n",
    "            # e retornar o elemento do final (topo da pilha)\n",
    "            return self.pratos.pop()\n",
    "        \n",
    "        # Se a pilha estiver vazia, retorna None (ou seja, nada)\n",
    "        return None\n",
    "\n",
    "    # Método auxiliar para verificar se a pilha está vazia\n",
    "    def esta_vazia(self):\n",
    "        \n",
    "        # Retorna True se a lista 'pratos' estiver \n",
    "        # vazia, caso contrário retorna False\n",
    "        return len(self.pratos) == 0\n",
    "    \n",
    "    # Método para visualizar (não remover) o elemento do topo da pilha\n",
    "    def ver_topo(self):\n",
    "        \n",
    "        # Primeiro, verifica se a pilha não está vazia\n",
    "        if not self.esta_vazia():\n",
    "            \n",
    "            # Retorna o último elemento da lista 'pratos' (topo da pilha) \n",
    "            # usando índice -1\n",
    "            return self.pratos[-1]\n",
    "        \n",
    "        # Se a pilha estiver vazia, retorna None (ou seja, nada)\n",
    "        return None\n",
    "    \n",
    "    # Método para obter o número de elementos na pilha (tamanho da pilha)\n",
    "    def quantidade(self):\n",
    "        \n",
    "        # Retorna o número de elementos na lista 'pratos' (tamanho da pilha)\n",
    "        return len(self.pratos)\n",
    "    \n",
    "# Inicializa (cria) uma nova instância da classe Pilha, criando uma pilha vazia\n",
    "minha_pilha = Pilha()\n",
    "\n",
    "# Usa o método 'adicionar' da instância 'minha_pilha' para adicionar\n",
    "# o \"Prato 1\" ao topo da pilha\n",
    "minha_pilha.adicionar(\"Prato 1\")\n",
    "\n",
    "# Imprime uma mensagem para informar que o \"Prato 1\" foi adicionado à pilha\n",
    "print(\"Adicionando: Prato 1\")\n",
    "\n",
    "# Usa o método 'adicionar' da instância 'minha_pilha' para adicionar \n",
    "# o \"Prato 2\" ao topo da pilha\n",
    "minha_pilha.adicionar(\"Prato 2\")\n",
    "\n",
    "# Imprime uma mensagem para informar que o \"Prato 2\" foi adicionado à pilha\n",
    "print(\"Adicionando: Prato 2\")\n",
    "\n",
    "# Usa o método 'adicionar' da instância 'minha_pilha' para adicionar \n",
    "# o \"Prato 3\" ao topo da pilha\n",
    "minha_pilha.adicionar(\"Prato 3\")\n",
    "\n",
    "# Imprime uma mensagem para informar que o \"Prato 3\" foi adicionado à pilha\n",
    "print(\"Adicionando: Prato 3\")\n",
    "\n",
    "# Usa o método 'ver_topo' para obter o item no topo da \n",
    "# pilha (neste caso, \"Prato 3\") e imprime-o\n",
    "print(\"Topo da pilha:\", minha_pilha.ver_topo())  # A saída esperada é \"Prato 3\"\n",
    "\n",
    "\n",
    "# Usa o método 'remover' da instância 'minha_pilha' para remover o item no topo da pilha\n",
    "prato_removido = minha_pilha.remover()\n",
    "\n",
    "# Imprime uma mensagem informando qual prato foi removido da pilha\n",
    "print(\"Removendo:\", prato_removido)  # A saída esperada é \"Prato 3\"\n",
    "\n",
    "# Repete o processo: remove o item do topo da pilha\n",
    "prato_removido = minha_pilha.remover()\n",
    "\n",
    "# Imprime uma mensagem informando qual prato foi removido da pilha\n",
    "print(\"Removendo:\", prato_removido)  # A saída esperada é \"Prato 2\"\n",
    "\n",
    "# Usa o método 'adicionar' da instância 'minha_pilha' para adicionar o\n",
    "# \"Prato 4\" ao topo da pilha\n",
    "minha_pilha.adicionar(\"Prato 4\")\n",
    "\n",
    "# Imprime uma mensagem para informar que o \"Prato 4\" foi adicionado à pilha\n",
    "print(\"Adicionando: Prato 4\")\n",
    "\n",
    "# Usa o método 'ver_topo' para obter o item no topo da \n",
    "# pilha (neste caso, \"Prato 4\") e imprime-o\n",
    "print(\"Topo da pilha:\", minha_pilha.ver_topo())  # A saída esperada é \"Prato 4\"\n",
    "\n",
    "# Usa o método 'esta_vazia' para verificar se a pilha está vazia\n",
    "if minha_pilha.esta_vazia():\n",
    "    \n",
    "    # Se o resultado for True, imprime que a pilha está vazia\n",
    "    print(\"A pilha está vazia.\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Se o resultado for False, imprime que a pilha tem pratos\n",
    "    print(\"A pilha tem pratos.\")\n",
    "\n",
    "# Usa o método 'quantidade' para obter o número de itens na pilha\n",
    "num_pratos = minha_pilha.quantidade()\n",
    "\n",
    "# Imprime o número total de pratos presentes na pilha\n",
    "print(f\"A pilha tem {num_pratos} pratos.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83e8693f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2b411708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O bibliotecário guardou: ['Livro E', 'Livro D', 'Livro C']\n",
      "O segundo bibliotecário guardou: ['Livro G', 'Livro F']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Simulação de Livros em uma Biblioteca\n",
    "\n",
    "Imagine uma mesa em uma biblioteca onde os estudantes colocam os \n",
    "livros que já leram. A mesa foi projetada de forma que só pode conter \n",
    "uma pilha de livros. Cada vez que um estudante lê um livro, ele o coloca \n",
    "no topo da pilha. E cada vez que um bibliotecário precisa guardar um \n",
    "livro de volta na estante, ele sempre pega o livro do topo da pilha.\n",
    "\n",
    "Tarefas:\n",
    "\n",
    "    1. Crie uma classe PilhaDeLivros:\n",
    "    \n",
    "        - A classe deve ter uma lista privada _livros \n",
    "            que inicialmente está vazia.\n",
    "        \n",
    "        - Deve ter métodos para adicionar_livro, \n",
    "                                remover_livro, \n",
    "                                ver_topo, \n",
    "                                esta_vazia e quantidade.\n",
    "\n",
    "    2. Simule o seguinte cenário usando a classe PilhaDeLivros:\n",
    "\n",
    "        a. Cinco estudantes leram, em sequência, os \n",
    "            livros: \"Livro A\", \"Livro B\", \"Livro C\", \"Livro D\" e \"Livro E\". \n",
    "            Eles colocam cada livro na pilha após a leitura.\n",
    "\n",
    "        b. Um bibliotecário vem e precisa guardar três livros de volta na \n",
    "            estante. Ele pega os livros do topo da pilha. Quais são os livros \n",
    "            que ele guardou?\n",
    "\n",
    "        c. Dois estudantes vêm e colocam os livros \"Livro F\" e \"Livro G\" na \n",
    "            pilha, respectivamente.\n",
    "\n",
    "        d. Outro bibliotecário vem e pega dois livros do topo para guardá-los. Quais \n",
    "            são os livros?\n",
    "\n",
    "    Perguntas para reflexão:\n",
    "    \n",
    "        - Qual foi o último livro lido pelos estudantes e qual foi o primeiro a \n",
    "              ser guardado pelos bibliotecários?\n",
    "        \n",
    "        - Qual é o estado final da pilha após todas as ações?\n",
    "        \n",
    "        - Baseado nesse exercício, você pode explicar o conceito \n",
    "              de Last In, First Out (LIFO)?\n",
    "\n",
    "Objetivo:\n",
    "\n",
    "Este exercício ajuda a entender o conceito fundamental do LIFO, onde \n",
    "o último item adicionado à pilha é o primeiro a ser removido dela. Ao \n",
    "simular o cenário com livros em uma biblioteca, podem visualizar e \n",
    "compreender melhor a natureza da pilha e suas operações.\n",
    "\"\"\"\n",
    "\n",
    "# Solução\n",
    "\n",
    "\"\"\"\n",
    "1. Crie uma classe PilhaDeLivros:\n",
    "    \n",
    "        - A classe deve ter uma lista privada _livros \n",
    "            que inicialmente está vazia.\n",
    "        \n",
    "        - Deve ter métodos para adicionar_livro, \n",
    "                                remover_livro, \n",
    "                                ver_topo, \n",
    "                                esta_vazia e quantidade.\n",
    "\"\"\" \n",
    "\n",
    "# Define uma nova classe chamada \"PilhaDeLivros\"\n",
    "class PilhaDeLivros:\n",
    "    \n",
    "        # Método construtor para inicializar uma nova instância da classe\n",
    "        def __init__(self):\n",
    "\n",
    "            \"\"\"\n",
    "            - A classe deve ter uma lista privada _livros \n",
    "                que inicialmente está vazia.\n",
    "            \"\"\"\n",
    "\n",
    "            # Define um atributo privado chamado '_livros' para a classe\n",
    "            # Este atributo é uma lista que vai armazenar os livros na pilha\n",
    "            # O prefixo de sublinhado (_) indica que é uma convenção em Python\n",
    "            # para denotar que este atributo deve ser tratado como \"privado\"\n",
    "            # ou seja, não deve ser acessado diretamente fora da classe\n",
    "            self._livros = []\n",
    "\n",
    "\n",
    "            \"\"\"\n",
    "            - Deve ter métodos para adicionar_livro, \n",
    "                                        remover_livro, \n",
    "                                        ver_topo, \n",
    "                                        esta_vazia e quantidade.\n",
    "            \"\"\"\n",
    "\n",
    "        # Define um método chamado 'adicionar_livro' para a classe PilhaDeLivros\n",
    "        def adicionar_livro(self, livro):\n",
    "            \n",
    "            # Utiliza o método 'append' da lista para adicionar o livro passado como \n",
    "            # argumento ao final da lista '_livros', que simula o topo da pilha.\n",
    "            self._livros.append(livro)\n",
    "            \n",
    "        # Define um método chamado 'remover_livro' para a classe PilhaDeLivros\n",
    "        def remover_livro(self):\n",
    "           \n",
    "            # Verifica se a pilha (lista '_livros') está vazia usando o método 'esta_vazia' \n",
    "            # (que ainda não foi definido neste código, mas assume-se que esteja presente na classe)\n",
    "            if not self.esta_vazia():\n",
    "                \n",
    "                # Se a pilha não estiver vazia, utiliza o método 'pop' da lista para remover \n",
    "                # e retornar o último item da lista '_livros', que simula o topo da pilha.\n",
    "                return self._livros.pop()\n",
    "            \n",
    "            else:\n",
    "                \n",
    "                # Se a pilha estiver vazia, retorna None, indicando que não há livro para remover.\n",
    "                return None\n",
    "            \n",
    "        # Define um método chamado 'ver_topo' para a classe PilhaDeLivros\n",
    "        def ver_topo(self):\n",
    "            \n",
    "            # Verifica se a pilha (lista '_livros') está vazia usando o método 'esta_vazia'\n",
    "            if not self.esta_vazia():\n",
    "                \n",
    "                # Se a pilha não estiver vazia, retorna o último livro da lista '_livros'\n",
    "                # (ou seja, o livro no topo da pilha) usando a indexação '-1'\n",
    "                return self._livros[-1]\n",
    "            \n",
    "            else:\n",
    "                \n",
    "                # Se a pilha estiver vazia, retorna None, indicando que não há livro no topo.\n",
    "                return None\n",
    "\n",
    "            \n",
    "        # Define um método chamado 'esta_vazia' para a classe PilhaDeLivros\n",
    "        def esta_vazia(self):\n",
    "            \n",
    "            # Retorna True se o comprimento da lista '_livros' for 0 (indicando que a pilha está vazia)\n",
    "            # e False caso contrário\n",
    "            return len(self._livros) == 0\n",
    "        \n",
    "        \n",
    "        # Define um método chamado 'quantidade' para a classe PilhaDeLivros\n",
    "        def quantidade(self):\n",
    "            \n",
    "            # Retorna o número de livros na pilha (ou seja, o comprimento da lista '_livros')\n",
    "            return len(self._livros)\n",
    "        \n",
    "\n",
    "\"\"\"\n",
    "2. Simule o seguinte cenário usando a classe PilhaDeLivros:\n",
    "\n",
    "        a. Cinco estudantes leram, em sequência, os \n",
    "            livros: \"Livro A\", \"Livro B\", \"Livro C\", \"Livro D\" e \"Livro E\". \n",
    "            Eles colocam cada livro na pilha após a leitura.\n",
    "\n",
    "        b. Um bibliotecário vem e precisa guardar três livros de volta na \n",
    "            estante. Ele pega os livros do topo da pilha. Quais são os livros \n",
    "            que ele guardou?\n",
    "\n",
    "        c. Dois estudantes vêm e colocam os livros \"Livro F\" e \"Livro G\" na \n",
    "            pilha, respectivamente.\n",
    "\n",
    "        d. Outro bibliotecário vem e pega dois livros do topo para guardá-los. Quais \n",
    "            são os livros?\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "a. Cinco estudantes leram, em sequência, os \n",
    "            livros: \"Livro A\", \"Livro B\", \"Livro C\", \"Livro D\" e \"Livro E\". \n",
    "            Eles colocam cada livro na pilha após a leitura.\n",
    "\"\"\"\n",
    "\n",
    "# Cria uma nova instância da classe PilhaDeLivros e armazena-a na variável chamada 'pilha'\n",
    "pilha = PilhaDeLivros()\n",
    "\n",
    "# Usa o método 'adicionar_livro' da instância 'pilha' para adicionar \"Livro A\" ao topo da pilha de livros\n",
    "pilha.adicionar_livro(\"Livro A\")\n",
    "\n",
    "# Novamente, usa o método 'adicionar_livro' para adicionar \"Livro B\" ao topo da pilha\n",
    "# Agora, \"Livro B\" está no topo e \"Livro A\" fica logo abaixo dele\n",
    "pilha.adicionar_livro(\"Livro B\")\n",
    "\n",
    "# Continua a adicionar livros à pilha. Cada novo livro é colocado no topo, \n",
    "# acima dos livros anteriormente adicionados\n",
    "pilha.adicionar_livro(\"Livro C\")\n",
    "\n",
    "# Adiciona \"Livro D\" ao topo da pilha\n",
    "pilha.adicionar_livro(\"Livro D\")\n",
    "\n",
    "# Adiciona \"Livro E\" ao topo da pilha. Agora, a ordem da pilha, de baixo para \n",
    "# cima, é: A, B, C, D, E\n",
    "pilha.adicionar_livro(\"Livro E\")\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "b. Um bibliotecário vem e precisa guardar três livros de volta na \n",
    "            estante. Ele pega os livros do topo da pilha. Quais são os livros \n",
    "            que ele guardou?\n",
    "\"\"\"\n",
    "\n",
    "# livros_guardados1 = [pilha.remover_livro() for _ in range(3)]\n",
    "\n",
    "# Inicializa uma lista vazia chamada 'livros_guardados1'. \n",
    "# Esta lista será usada para armazenar os livros que o bibliotecário irá guardar.\n",
    "livros_guardados1 = []\n",
    "\n",
    "# O loop 'for' irá rodar 3 vezes porque queremos que o bibliotecário guarde 3 livros.\n",
    "for _ in range(3):\n",
    "\n",
    "    # Dentro do loop, o método 'remover_livro' é chamado na instância 'pilha'.\n",
    "    # Isso irá remover o livro do topo da pilha (devido ao comportamento LIFO da pilha) \n",
    "    # e o valor retornado (o livro removido) é armazenado na variável 'livro'.\n",
    "    livro = pilha.remover_livro()\n",
    "\n",
    "    # O livro removido é então adicionado à lista 'livros_guardados1' usando o método 'append'.\n",
    "    livros_guardados1.append(livro)\n",
    "\n",
    "# Após o loop terminar, a lista 'livros_guardados1' contém os 3 livros que o bibliotecário guardou.\n",
    "# Estes são impressos na tela.\n",
    "print(\"O bibliotecário guardou:\", livros_guardados1)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "c. Dois estudantes vêm e colocam os livros \"Livro F\" e \"Livro G\" na \n",
    "            pilha, respectivamente.\n",
    "\"\"\"\n",
    "\n",
    "# Aqui, estamos chamando o método 'adicionar_livro' na instância 'pilha' e \n",
    "# passando o argumento \"Livro F\".\n",
    "# Isso irá adicionar \"Livro F\" no topo da pilha. \n",
    "# Lembre-se, a pilha tem um comportamento LIFO (Last In, First Out), então o \n",
    "# último livro adicionado\n",
    "# fica no topo e será o primeiro a ser removido.\n",
    "pilha.adicionar_livro(\"Livro F\")\n",
    "\n",
    "# Agora, estamos adicionando \"Livro G\" ao topo da pilha da mesma maneira.\n",
    "# Como \"Livro G\" é adicionado após \"Livro F\", ele agora será o livro no topo da pilha.\n",
    "pilha.adicionar_livro(\"Livro G\")\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "d. Outro bibliotecário vem e pega dois livros do topo para guardá-los. Quais \n",
    "            são os livros?\n",
    "\"\"\"\n",
    "# livros_guardados2 = [pilha.remover_livro() for _ in range(2)]\n",
    "\n",
    "# Aqui, estamos inicializando uma lista vazia chamada 'livros_guardados2'. \n",
    "# Esta lista será usada para armazenar os livros que o segundo bibliotecário guarda.\n",
    "livros_guardados2 = []\n",
    "\n",
    "# O 'for' loop irá rodar exatamente 2 vezes. Isto é indicado por 'range(2)'.\n",
    "# Para cada iteração (rodada) deste loop, nós faremos as seguintes ações:\n",
    "for _ in range(2):\n",
    "    \n",
    "    # Aqui, estamos chamando o método 'remover_livro' na instância 'pilha'.\n",
    "    # Isso removerá e retornará o livro do topo da pilha.\n",
    "    livro = pilha.remover_livro()\n",
    "\n",
    "    # Agora, estamos adicionando o livro retornado (ou seja, o livro removido do topo da pilha)\n",
    "    # à lista 'livros_guardados2'.\n",
    "    livros_guardados2.append(livro)\n",
    "\n",
    "# Após o loop terminar (ou seja, após 2 livros serem removidos da pilha e adicionados à lista),\n",
    "# nós imprimimos os livros que o segundo bibliotecário guardou.\n",
    "print(\"O segundo bibliotecário guardou:\", livros_guardados2)\n",
    "\n",
    "# Perguntas para reflexão:\n",
    "\n",
    "\"\"\"\n",
    "    Qual foi o último livro lido pelos estudantes e qual foi o primeiro a \n",
    "    ser guardado pelos bibliotecários?\n",
    "\n",
    "        Resposta: O último livro lido pelos estudantes foi o \"Livro G\". O primeiro \n",
    "        livro a ser guardado pelos bibliotecários foi o \"Livro E\" (pois é o último \n",
    "        adicionado e o primeiro a ser removido devido ao princípio LIFO).\n",
    "\n",
    "    Qual é o estado final da pilha após todas as ações?\n",
    "\n",
    "        Resposta: Após todas as ações, os livros remanescentes na pilha, do \n",
    "        topo para a base, são: [\"Livro A\", \"Livro B\"].\n",
    "\n",
    "    Baseado nesse exercício, você pode explicar o conceito de Last In, First Out (LIFO)?\n",
    "\n",
    "        Resposta: Sim. Last In, First Out (LIFO) significa que o último item inserido \n",
    "        em uma pilha será o primeiro a ser removido dela. No cenário, o último livro \n",
    "        que os estudantes leram e colocaram no topo da pilha foi sempre o primeiro \n",
    "        a ser guardado pelos bibliotecários. Isso demonstra claramente o princípio \n",
    "        LIFO em ação, onde a última ação de \"inserção\" (adicionar um livro) tem sua \n",
    "        correspondente ação de \"remoção\" (remover um livro) ocorrendo antes de qualquer \n",
    "        ação de inserção anterior.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51c04699",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3c8353a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Exercicio Gestão de Pilha Interativa com Tkinter\n",
    "\n",
    "Enunciado:\n",
    "\n",
    "A estrutura de dados \"pilha\" é uma das mais fundamentais em ciência da computação. \n",
    "Sua característica principal é ser uma coleção de itens onde o último elemento \n",
    "inserido é o primeiro a ser removido (Last In, First Out - LIFO).\n",
    "\n",
    "Seu desafio é criar uma aplicação gráfica usando o módulo Tkinter em Python \n",
    "para interagir e gerenciar uma pilha de números inteiros. A aplicação deve \n",
    "fornecer as seguintes funcionalidades:\n",
    "\n",
    "    - Adicionar à pilha: O usuário deve ser capaz de digitar um número inteiro\n",
    "        em um campo de texto e, ao clicar em um botão, adicionar esse número \n",
    "        ao topo da pilha.\n",
    "        \n",
    "    - Remover da pilha: O usuário deve ser capaz de clicar em um botão para \n",
    "        remover o número no topo da pilha. Após a remoção, uma janela de mensagem \n",
    "        deve mostrar o número removido.\n",
    "        \n",
    "    - Visualizar o topo da pilha: O usuário deve ser capaz de clicar em um botão \n",
    "        para visualizar o número atual no topo da pilha.\n",
    "    \n",
    "    - Verificar se a pilha está vazia: Ao clicar em um botão, o usuário deve ser \n",
    "        informado se a pilha está vazia ou não.\n",
    "        \n",
    "    - Obter o tamanho da pilha: Ao clicar em um botão, uma janela de mensagem \n",
    "        deve mostrar o tamanho atual da pilha.\n",
    "        \n",
    "    - Visualizar a pilha inteira: A aplicação deve mostrar a pilha atualizada \n",
    "        em tempo real em uma lista. O topo da pilha deve ser claramente identificado \n",
    "        como o primeiro item da lista.\n",
    "\n",
    "\n",
    "Boa sorte!\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "# Solução\n",
    "\n",
    "# Primeiro, importamos os módulos necessários:\n",
    "# `tkinter` é o módulo padrão em Python para criar interfaces \n",
    "# gráficas e `messagebox` e `ttk` são submódulos específicos de `tkinter`.\n",
    "\n",
    "import tkinter as tk\n",
    "from tkinter import messagebox, ttk\n",
    "\n",
    "# Em seguida, definimos uma classe chamada 'Pilha'. Esta classe \n",
    "# representa a estrutura de dados chamada pilha, que é uma coleção \n",
    "# de itens que segue o princípio LIFO (Last In, First Out).\n",
    "\n",
    "class Pilha:\n",
    "    \n",
    "    # O método `__init__` é o construtor da classe. Ele é executado \n",
    "    # automaticamente cada vez que um novo objeto desta classe é criado.\n",
    "    # O objetivo deste construtor é inicializar a pilha como uma lista vazia.\n",
    "    def __init__(self):\n",
    "        self.itens = []  # `self.itens` é uma lista vazia que armazenará os itens da pilha.\n",
    "    \n",
    "    # O método `push` é usado para adicionar (ou empurrar) um novo item para o topo da pilha.\n",
    "    def push(self, item):\n",
    "        \n",
    "        # Aqui, utilizamos o método `append` das listas para adicionar o novo item ao final da lista.\n",
    "        # Como estamos usando uma lista para representar a pilha, o final da lista é, essencialmente, o topo da pilha.\n",
    "        self.itens.append(item)\n",
    "        \n",
    "    # O método `pop` é usado para remover (ou retirar) o item do topo da pilha e retorná-lo.\n",
    "    def pop(self):\n",
    "        \n",
    "        # Usamos uma construção condicional em uma única linha.\n",
    "        # Primeiro, verifica-se com `self.isEmpty()` se a pilha está vazia.\n",
    "        # Se não estiver vazia (`not self.isEmpty()`), usamos o método `pop` \n",
    "        # da lista para remover e retornar o último item.\n",
    "        # Se a pilha estiver vazia, retornamos `None` para indicar que não havia nada\n",
    "        # para ser removido.\n",
    "        return self.itens.pop() if not self.isEmpty() else None\n",
    "    \n",
    "    # O método `peek` é usado para visualizar (ou espiar) o item no topo da pilha sem removê-lo.\n",
    "    def peek(self):\n",
    "        \n",
    "        # Semelhante ao método anterior, primeiro verificamos se a pilha não está vazia.\n",
    "        # Se não estiver vazia, retornamos o último item da lista (ou seja, o topo da pilha) com `self.itens[-1]`.\n",
    "        # Se estiver vazia, retornamos `None`.\n",
    "        return self.itens[-1] if not self.isEmpty() else None\n",
    "    \n",
    "    \n",
    "    # O método `isEmpty` é uma função auxiliar que verifica se a pilha está vazia.\n",
    "    # Ele faz isso verificando se o comprimento da lista de itens é 0.\n",
    "    def isEmpty(self):\n",
    "        \n",
    "        # Retorna True se a pilha estiver vazia e False caso contrário.\n",
    "        return len(self.itens) == 0\n",
    "    \n",
    "    \n",
    "    # O método `getSize` retorna o número atual de itens na pilha.\n",
    "    # Como estamos usando uma lista para representar a pilha, podemos usar o \n",
    "    # método `len` do Python para obter esse número.\n",
    "    def getSize(self):\n",
    "        \n",
    "        # Retorna o número de itens na pilha.\n",
    "        return len(self.itens)\n",
    "        \n",
    "        \n",
    "# Esta é a classe responsável por criar a interface gráfica \n",
    "# para gerenciar a pilha.\n",
    "class PilhaApp:\n",
    "\n",
    "    # O construtor da classe (__init__) é o método que é chamado quando \n",
    "    # criamos uma nova instância desta classe.\n",
    "    # Neste caso, ele espera um argumento: 'master', que é o widget principal \n",
    "    # ou janela da aplicação tkinter.\n",
    "    def __init__(self, master):\n",
    "        \n",
    "        # Armazena uma referência ao widget principal (geralmente é a janela \n",
    "        # principal da aplicação).\n",
    "        self.master = master\n",
    "        \n",
    "        # Define o título da janela principal usando o método 'title' de 'master'.\n",
    "        self.master.title(\"Gestão de Pilha Interativa\")\n",
    "        \n",
    "        # Cria uma nova instância da classe 'Pilha'. Esta será a pilha que \n",
    "        # será gerenciada pela interface.\n",
    "        self.pilha = Pilha()\n",
    "\n",
    "        # Abaixo, vamos criar alguns widgets para a interface:\n",
    "\n",
    "        # Criação de um rótulo (label) para exibir o título da aplicação.\n",
    "        # 'text' define o que será exibido no rótulo.\n",
    "        # 'font' especifica a fonte e o tamanho do texto no rótulo.\n",
    "        self.title_label = tk.Label(self.master, \n",
    "                                    text=\"Gestão de Pilha Interativa\", \n",
    "                                    font=(\"Arial\", 20))\n",
    "        \n",
    "        # 'pack' é um método usado para posicionar e exibir o widget na janela principal.\n",
    "        # 'pady' é um argumento que adiciona espaço acima e abaixo do \n",
    "        # widget (para melhorar a estética).\n",
    "        self.title_label.pack(pady=20)\n",
    "\n",
    "        # Criação de outro rótulo para instruir o usuário a digitar um número.\n",
    "        self.entry_label = tk.Label(self.master, \n",
    "                                    text=\"Digite um número:\")\n",
    "        \n",
    "        # Exibe o rótulo na janela principal.\n",
    "        self.entry_label.pack(pady=5)\n",
    "        \n",
    "        # Criação de um widget de entrada (Entry) onde os usuários podem digitar\n",
    "        # informações (neste caso, números).\n",
    "        self.number_entry = tk.Entry(self.master)\n",
    "        \n",
    "        # Exibe o entry na janela principal.\n",
    "        self.number_entry.pack(pady=5)\n",
    "\n",
    "        # Criação de um botão (Button) que, quando clicado, executará a função \n",
    "        # 'push_item' para adicionar um item à pilha.\n",
    "        # 'text' define o que será exibido no botão.\n",
    "        # 'command' especifica a função que será chamada quando o botão for clicado.\n",
    "        self.push_btn = tk.Button(self.master, \n",
    "                                  text=\"Adicionar à pilha (push)\", \n",
    "                                  command=self.push_item)\n",
    "\n",
    "        # Posiciona o botão 'push_btn' na janela principal.\n",
    "        self.push_btn.pack(pady=5)\n",
    "        \n",
    "        \n",
    "        # Criação de outro botão que, quando clicado, executará a função \n",
    "        # 'pop_item' para remover um item do topo da pilha.\n",
    "        self.pop_btn = tk.Button(self.master, \n",
    "                                 text=\"Remover da pilha (pop)\", \n",
    "                                 command=self.pop_item)\n",
    "\n",
    "        # Posiciona o botão 'pop_btn' na janela principal.\n",
    "        self.pop_btn.pack(pady=5)\n",
    "        \n",
    "        \n",
    "        # Criação de um botão que, quando clicado, executará a função\n",
    "        # 'peek_item' para visualizar o item do topo da pilha.\n",
    "        self.peek_btn = tk.Button(self.master, \n",
    "                                  text=\"Visualizar topo da pilha (peek)\", \n",
    "                                  command=self.peek_item)\n",
    "\n",
    "        # Posiciona o botão 'peek_btn' na janela principal.\n",
    "        self.peek_btn.pack(pady=5)\n",
    "        \n",
    "        \n",
    "        # Criação de um botão para verificar se a pilha está vazia.\n",
    "        self.is_empty_btn = tk.Button(self.master, \n",
    "                                      text=\"A pilha está vazia?\", \n",
    "                                      command=self.is_empty)\n",
    "\n",
    "        # Posiciona o botão 'is_empty_btn' na janela principal.\n",
    "        self.is_empty_btn.pack(pady=5)\n",
    "        \n",
    "        \n",
    "        \n",
    "        # Criação de um botão para obter e mostrar o tamanho da pilha.\n",
    "        self.size_btn = tk.Button(self.master, \n",
    "                                  text=\"Obter tamanho da pilha\", \n",
    "                                  command=self.get_size)\n",
    "\n",
    "        # Posiciona o botão 'size_btn' na janela principal.\n",
    "        self.size_btn.pack(pady=5)\n",
    "\n",
    "        \n",
    "        # Criação de um rótulo (Label) para indicar que a Listbox abaixo mostrará os itens da pilha.\n",
    "        self.listbox_label = tk.Label(self.master, \n",
    "                                      text=\"Pilha Atual:\")\n",
    "\n",
    "        # Posiciona o rótulo 'listbox_label' na janela principal.\n",
    "        self.listbox_label.pack(pady=10)\n",
    "        \n",
    "        \n",
    "        # Criação de uma caixa de listagem (Listbox) para exibir os itens da pilha.\n",
    "        # 'height' define a altura da caixa de listagem (número de linhas visíveis).\n",
    "        # 'width' define a largura da caixa de listagem em caracteres.\n",
    "        # 'font' especifica a fonte e o tamanho do texto dentro da Listbox.\n",
    "        self.pilha_display = tk.Listbox(self.master, \n",
    "                                        height=10, \n",
    "                                        width=50, \n",
    "                                        font=(\"Arial\", 20))\n",
    "\n",
    "        # Posiciona a caixa de listagem 'pilha_display' na janela principal.\n",
    "        self.pilha_display.pack(pady=5)\n",
    "        \n",
    "    \n",
    "    # Método para atualizar a exibição da pilha na interface gráfica.\n",
    "    def update_display(self):\n",
    "        \n",
    "        # Deleta todos os itens da Listbox.\n",
    "        # 'delete' é um método da Listbox que remove um ou mais itens.\n",
    "        # Aqui, deletamos todos os itens, do primeiro (index 0) ao último (tk.END).\n",
    "        self.pilha_display.delete(0, tk.END)\n",
    "        \n",
    "        # Itera sobre os itens da pilha em ordem inversa (o topo da pilha será o primeiro).\n",
    "        # A pilha é representada por uma lista em Python, e 'reversed' inverte a ordem dos itens.\n",
    "        for item in reversed(self.pilha.itens):\n",
    "            \n",
    "            # 'insert' é um método da Listbox que adiciona um item.\n",
    "            # Aqui, estamos adicionando cada item ao final (tk.END) da Listbox.\n",
    "            self.pilha_display.insert(tk.END, item)\n",
    "            \n",
    "        \n",
    "    # Método para adicionar (push) um item à pilha.\n",
    "    def push_item(self):\n",
    "        \n",
    "        try:\n",
    "            \n",
    "            # Tenta pegar o valor digitado pelo usuário no widget de entrada (Entry).\n",
    "            # 'get' é um método do widget Entry que retorna o texto nele.\n",
    "            # A seguir, tentamos converter esse texto para um número inteiro.\n",
    "            num = int(self.number_entry.get())\n",
    "\n",
    "            # Se a conversão foi bem-sucedida, o número é adicionado à pilha.\n",
    "            self.pilha.push(num)\n",
    "\n",
    "            # Atualiza a exibição da pilha na interface gráfica.\n",
    "            self.update_display()\n",
    "\n",
    "            # Limpa o widget de entrada (Entry) para o usuário poder digitar um novo número.\n",
    "            # 'delete' é usado para remover texto do widget Entry. Aqui, remove-se todo o texto.\n",
    "            self.number_entry.delete(0, tk.END)\n",
    "            \n",
    "        except ValueError:\n",
    "            \n",
    "            # Caso ocorra um erro na conversão do texto para um número (ValueError),\n",
    "            # uma mensagem de erro é exibida para o usuário.\n",
    "            # 'showerror' é um método de 'messagebox' que mostra uma janela de erro.\n",
    "            messagebox.showerror(\"Erro\", \"Por favor, digite um número válido.\")\n",
    "            \n",
    "            \n",
    "            \n",
    "    # Método para remover (pop) um item do topo da pilha.\n",
    "    def pop_item(self):\n",
    "        \n",
    "        # Invoca o método 'pop' da pilha.\n",
    "        item = self.pilha.pop()\n",
    "\n",
    "        # Verifica se o item obtido não é None. Se não for, significa que havia um \n",
    "        # item para remover.\n",
    "        if item is not None:\n",
    "            \n",
    "            # Atualiza a visualização da pilha na interface gráfica.\n",
    "            self.update_display()\n",
    "            \n",
    "            # Exibe uma mensagem informando o número que foi removido do topo da pilha.\n",
    "            messagebox.showinfo(\"Pop\", f\"Número {item} removido do topo da pilha!\")\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            # Se o item obtido é None, significa que a pilha estava vazia e não havia \n",
    "            # nada para remover.\n",
    "            # Exibe uma mensagem informando que a pilha está vazia.\n",
    "            messagebox.showinfo(\"Pilha Vazia\", \"A pilha já está vazia!\")\n",
    "            \n",
    "    # Método para visualizar o item no topo da pilha sem removê-lo.\n",
    "    def peek_item(self):\n",
    "        \n",
    "        # Invoca o método 'peek' da pilha para obter o item do topo.\n",
    "        item = self.pilha.peek()\n",
    "\n",
    "        # Se o item obtido não for None, mostra uma mensagem com o número que está no topo.\n",
    "        if item is not None:\n",
    "            \n",
    "            messagebox.showinfo(\"Peek\", f\"Número no topo da pilha: {item}\")\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            # Se o item for None, a pilha está vazia.\n",
    "            messagebox.showinfo(\"Pilha Vazia\", \"A pilha está vazia!\")\n",
    "            \n",
    "    \n",
    "    # Método para verificar se a pilha está vazia.\n",
    "    def is_empty(self):\n",
    "        \n",
    "        # Verifica se a pilha está vazia invocando o método 'isEmpty'.\n",
    "        if self.pilha.isEmpty():\n",
    "            \n",
    "            # Se estiver vazia, exibe uma mensagem informando o fato.\n",
    "            messagebox.showinfo(\"Pilha Vazia\", \"A pilha está vazia!\")\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            # Caso contrário, informa que a pilha não está vazia.\n",
    "            messagebox.showinfo(\"Pilha\", \"A pilha não está vazia!\")\n",
    "            \n",
    "            \n",
    "    # Método para obter e exibir o tamanho atual da pilha.\n",
    "    def get_size(self):\n",
    "        \n",
    "        # Obtém o tamanho da pilha invocando o método 'getSize'.\n",
    "        size = self.pilha.getSize()\n",
    "        \n",
    "        # Exibe uma mensagem informando o tamanho atual da pilha.\n",
    "        messagebox.showinfo(\"Tamanho da Pilha\", f\"Tamanho da pilha: {size}\")\n",
    "        \n",
    "            \n",
    "\n",
    "# Verifica se este script é o ponto de entrada principal. Em outras \n",
    "# palavras, verifica se o script está sendo executado diretamente e não \n",
    "# sendo importado como um módulo.\n",
    "if __name__ == \"__main__\":\n",
    "    \n",
    "    # Cria a janela principal do tkinter.\n",
    "    root = tk.Tk()\n",
    "    \n",
    "    # Instancia o aplicativo, passando a janela principal como argumento. \n",
    "    # Isso efetivamente inicializa toda a interface gráfica do nosso aplicativo de pilha.\n",
    "    app = PilhaApp(root)\n",
    "    \n",
    "    # Inicia o loop principal da interface gráfica. \n",
    "    # Isso mantém a janela aberta e ouve por eventos, como cliques de botão, \n",
    "    # até que a janela seja fechada.\n",
    "    root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4c7539f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d1c33f1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f98fef8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d89da14",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c53468b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}