00_revisao_apc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estrutura de Dados - Revisão de APC\n",
    "==========================================\n",
    "\n",
    "Esta disciplina é uma continuação de introdução à ciência da computação ou algoritmos e programação de computadores.\n",
    "\n",
    "Nela, são vistos diversos tipos de estruturas de dados e algoritmos que as manipulam.\n",
    "\n",
    "Antes disto, iremos revisar alguns dos conceitos básicos de programação com Python e falar de boas práticas de desenvolvimento.\n",
    "\n",
    "Conteúdo\n",
    "========\n",
    "\n",
    "- Variáveis\n",
    "- Tipos: Inteiros, Ponto Flutuante, Bytes e Strings\n",
    "- Execução sequencial\n",
    "- Execução condicional\n",
    "- Execução com repetição\n",
    "- Funções\n",
    "- Recursão\n",
    "- Listas\n",
    "- Tuplas\n",
    "- Dicionários\n",
    "- Desenvolvimento Orientado à Testes (TDD)\n",
    "- Programação orientação à objetos (OOP)\n",
    "\n",
    "### Variáveis\n",
    "\n",
    "Variáveis são elementos nomeados que armazenam um dado valor intermediário sobre o qual operaremos.\n",
    "\n",
    "No exemplo abaixo, temos três variáveis: A, B e C."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-05T17:25:31.779813Z",
     "start_time": "2023-04-05T17:25:31.776653Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A 2\n",
      "B 1\n",
      "C 3\n"
     ]
    }
   ],
   "source": [
    "A = 2 # declara variável com valor 2\n",
    "B = 1 # declara variável com valor 1\n",
    "C = A + B # declara variável com C com valor A+B\n",
    "print(\"A\", A) # imprime valores das variáveis\n",
    "print(\"B\", B) # imprime valores das variáveis\n",
    "print(\"C\", C) # imprime valores das variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos: Inteiros, Ponto Flutuante, Bytes e Strings\n",
    "\n",
    "Tipos definem o tipo de representação contido em uma variável.\n",
    "\n",
    "No caso anterior, todos os números eram inteiros, portanto os tipos das\n",
    "variáveis correspondem a `int`.\n",
    "\n",
    "Caso fossem números reais, seriam representados com o tipo `float` para\n",
    "pontos flutuantes.\n",
    "\n",
    "Para dados lidos diretamente de arquivos ou da memória, tipicamente\n",
    "recebemos `bytes`, que podem ser codificados de diversas maneiras.\n",
    "A padrão do Python é `utf-8`.\n",
    "\n",
    "Para textos, utilizamos o tipo `string`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numero_inteiro <class 'int'>\n",
      "numero_real <class 'int'>\n",
      "bytes <class 'bytes'>\n",
      "bytes decodificados <class 'str'>\n",
      "string <class 'str'>\n",
      "string codificado <class 'bytes'>\n"
     ]
    }
   ],
   "source": [
    "numero_inteiro = 1\n",
    "print(\"numero_inteiro\", type(numero_inteiro))\n",
    "\n",
    "numero_real = 1\n",
    "print(\"numero_real\", type(numero_real))\n",
    "\n",
    "bytes = b\"CAFEBABE\"\n",
    "print(\"bytes\", type(bytes))\n",
    "print(\"bytes decodificados\", type(bytes.decode(\"utf-8\")))\n",
    "\n",
    "string = \"DEADBEEF\"\n",
    "print(\"string\", type(string))\n",
    "print(\"string codificado\", type(string.encode(\"utf-8\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execução sequencial\n",
    "\n",
    "Como visto nos exemplos anteriores, por padrão as instruções são executadas na sequência em que são listadas.\n",
    "\n",
    "Isto não necessariamente é verdade para outras linguagens, que podem utilizar, por exemplo, de programação assíncrona."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(1)\n",
    "print(2)\n",
    "print(3)\n",
    "print(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execução condicional\n",
    "\n",
    "Não é trivial escrever um programa que é executado único e exclusivamente com uma execução sequencial.\n",
    "\n",
    "Tipicamente queremos desviar o fluxo de control do programa para executar dado tipo de processamento dada alguma condição lógica.\n",
    "\n",
    "No exemplo abaixo, vemos este tipo de estrutura condicional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A >= 50: 71\n",
      "B >= 50: 74\n",
      "C < 50: 46\n"
     ]
    }
   ],
   "source": [
    "import random # importa biblioteca de números aleatórios\n",
    "\n",
    "A = random.randint(0, 100) # escolhe aleatóriamente um número de 0 até 100\n",
    "\n",
    "if A >= 50:\n",
    "    print(\"A >= 50:\", A)\n",
    "else:\n",
    "    print(\"A < 50:\", A)\n",
    "    \n",
    "B = random.randint(0, 100) # escolhe aleatóriamente um número de 0 até 100\n",
    "\n",
    "if B >= 50:\n",
    "    print(\"B >= 50:\", B)\n",
    "else:\n",
    "    print(\"B < 50:\", B)\n",
    "    \n",
    "C = random.randint(0, 100) # escolhe aleatóriamente um número de 0 até 100\n",
    "\n",
    "if C >= 50:\n",
    "    print(\"C >= 50:\", C)\n",
    "else:\n",
    "    print(\"C < 50:\", C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execução com repetição\n",
    "\n",
    "No exemplo acima, tivemos a repetição dos blocos de programa para diferentes variáveis. \n",
    "\n",
    "Isto atrapalha a manutenibilidade, legibilidade e correção do programa. \n",
    "\n",
    "Para mitigar isto, utilizamos estruturas mais elegantes de repetição.\n",
    "\n",
    "No Python, temos duas `for` e `while`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimativa de pi para 0:0.000800\n",
      "Estimativa de pi para 200:0.127175\n",
      "Estimativa de pi para 400:0.252749\n",
      "Estimativa de pi para 600:0.372725\n",
      "Estimativa de pi para 800:0.499900\n",
      "Estimativa de pi para 1000:0.626275\n",
      "Estimativa de pi para 1200:0.753449\n",
      "Estimativa de pi para 1400:0.878224\n",
      "Estimativa de pi para 1600:1.006199\n",
      "Estimativa de pi para 1800:1.129374\n",
      "Estimativa de pi para 2000:1.267746\n",
      "Estimativa de pi para 2200:1.397321\n",
      "Estimativa de pi para 2400:1.525295\n",
      "Estimativa de pi para 2600:1.657269\n",
      "Estimativa de pi para 2800:1.789242\n",
      "Estimativa de pi para 3000:1.916417\n",
      "Estimativa de pi para 3200:2.046791\n",
      "Estimativa de pi para 3400:2.165167\n",
      "Estimativa de pi para 3600:2.281944\n",
      "Estimativa de pi para 3800:2.413117\n",
      "Estimativa de pi para 4000:2.539492\n",
      "Estimativa de pi para 4200:2.672266\n",
      "Estimativa de pi para 4400:2.805839\n",
      "Estimativa de pi para 4600:2.937013\n",
      "Estimativa de pi para 4800:3.059388\n",
      "Estimativa de pi para 5000:3.189762\n"
     ]
    }
   ],
   "source": [
    "import random # importa biblioteca de números aleatórios\n",
    "\n",
    "\n",
    "N = 5001 # número de iterações\n",
    "\n",
    "estimativa_pi = 0 # declara variável para guardar o resultado da computação\n",
    "dentro_do_circulo = 0 # conta número de coordenadas dentro do círculo\n",
    "for i in range(N):\n",
    "    # estima o valor de Pi sorteando coordenadas dentro de um quadrado [0,1]\n",
    "    x = random.random()\n",
    "    y = random.random()\n",
    "    # calcula distância euclidiana do ponto até o centro [0.5, 0.5]\n",
    "    d = ((x-0.5)**2 + (y-0.5)**2)**0.5\n",
    "    # se a coordenada cair dentro do círculo, contabilize\n",
    "    if d <= 0.5:\n",
    "        dentro_do_circulo += 1\n",
    "    # se cair fora, não faz nada e continua para a próxima iteração i = i+1\n",
    "    else:\n",
    "        pass\n",
    "    \n",
    "    # imprime a cada 10 iterações\n",
    "    if i % 200 == 0:\n",
    "        # número de pontos que caem dentro do círculo tem que ser \n",
    "        # proporcional à área do círculo em relação à do quadrado\n",
    "        # Acirc = pi*(raio**2) = pi*0.25 ou pi/4\n",
    "        # Aquad = 1*1 = 1\n",
    "        print(\"Estimativa de pi para %d:%f\" % (i, 4*dentro_do_circulo/N)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funções\n",
    "\n",
    "\n",
    "Funções servem como um encapsulamento de um bloco de código. \n",
    "\n",
    "São utilizados para isolar funcionalidades bem definidas do resto do código e reduzir ainda mais a quantidade de código duplicado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raiz 1 = 1.0\n",
      "raiz 4 = 2.0\n",
      "raiz 9 = 3.0\n",
      "raiz 16 = 4.0\n"
     ]
    }
   ],
   "source": [
    "def raiz(a):\n",
    "    return a**0.5\n",
    "\n",
    "print(\"raiz 1 =\", raiz(1))\n",
    "print(\"raiz 4 =\", raiz(4))\n",
    "print(\"raiz 9 =\", raiz(9))\n",
    "print(\"raiz 16 =\", raiz(16))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recursão\n",
    "\n",
    "Recursão é o processo de invocar a mesma função dentro de si mesma, permitindo o particionamento da carga de trabalho até que tenha resolução trivial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n",
      "[2, 3, 4, 5, 6, 7, 8]\n",
      "[3, 4, 5, 6, 7, 8]\n",
      "[4, 5, 6, 7, 8]\n",
      "[5, 6, 7, 8]\n",
      "[6, 7, 8]\n",
      "[7, 8]\n",
      "maximo de [1, 2, 3, 4, 5, 6, 7, 8]  é: 8\n"
     ]
    }
   ],
   "source": [
    "def maximo(elementos):\n",
    "    print(elementos)\n",
    "    if len(elementos) > 2:\n",
    "        maximo_sublista = maximo(elementos[1:])\n",
    "        return elementos[0] if elementos[0] > maximo_sublista else maximo_sublista\n",
    "    elif len(elementos) == 2:\n",
    "        return elementos[0] if elementos[0] > elementos[1] else elementos[1]\n",
    "    else:\n",
    "        return elementos[0]\n",
    "    \n",
    "elementos = [1,2,3,4,5,6,7,8]\n",
    "\n",
    "print(\"maximo de\", elementos, \" é:\", maximo(elementos))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas\n",
    "\n",
    "Listas são estruturas para armazenamento de um conjunto de valores heterogêneos para dados MUTÁVEIS.\n",
    "\n",
    "Permitem o acesso a partir do índice da posição do valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "lista = [] # cria lista vazia\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'livro', 3.14]\n"
     ]
    }
   ],
   "source": [
    "lista.append(1)\n",
    "lista.append(\"livro\")\n",
    "lista.append(3.14)\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'livro']\n"
     ]
    }
   ],
   "source": [
    "lista.pop()\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['livro']\n"
     ]
    }
   ],
   "source": [
    "lista.pop(0)\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuplas\n",
    "\n",
    "Tuplas são estruturas de dados heterogêneas para dados IMUTÁVEIS.\n",
    "\n",
    "Similares à listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.22\n"
     ]
    }
   ],
   "source": [
    "tupla = (2.22, )\n",
    "\n",
    "print(tupla[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuplas são imutáveis\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    tupla[0] = 3.14\n",
    "except TypeError:\n",
    "    print(\"Tuplas são imutáveis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicionários\n",
    "\n",
    "Dicionários são estruturas que permitem o armazenamento de pares formados por chaves e valores.\n",
    "\n",
    "As chaves servem de endereçamento para acesso dos valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'chave1': 'valor1', 'chave2': 'valor2'}\n"
     ]
    }
   ],
   "source": [
    "dicionario = {}\n",
    "dicionario[\"chave1\"] = \"valor1\"\n",
    "dicionario[\"chave2\"] = \"valor2\"\n",
    "print(dicionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valor1\n"
     ]
    }
   ],
   "source": [
    "print(dicionario[\"chave1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'chaveInexistente'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_16336/3223101334.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdicionario\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"chaveInexistente\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'chaveInexistente'"
     ]
    }
   ],
   "source": [
    "print(dicionario[\"chaveInexistente\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'chave2': 'valor2'}\n"
     ]
    }
   ],
   "source": [
    "del dicionario[\"chave1\"]\n",
    "print(dicionario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desenvolvimento Orientado à Testes (TDD)\n",
    "\n",
    "Programação orientada a testes (TDD) tem se tornado uma prática cada vez mais comum.\n",
    "\n",
    "Esta prática de desenvolvimento consiste em especificar primeiros os testes com as saídas esperadas, para em seguida implementar de fato as funcionalidades."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.001s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "import unittest # biblioteca de testes Python\n",
    "\n",
    "# Classe com casos de teste\n",
    "class CasosDeTeste(unittest.TestCase):\n",
    "    # Cada subcaso de teste deve ser iniciado com o nome test_\n",
    "    def test_funcao_quadratica(self):\n",
    "        # Valores de entradas e saídas esperadas\n",
    "        casos_de_teste = {\n",
    "            # x : y(x) = x^2\n",
    "            1: 1,\n",
    "            2: 4,\n",
    "            3: 9,\n",
    "            4: 16,\n",
    "            5: 25,\n",
    "        }\n",
    "\n",
    "        # Função a ser avaliada\n",
    "        def funcao_quadratica(x):\n",
    "            return x*x\n",
    "\n",
    "        # Verifique se o resultado da função avaliada\n",
    "        # corresponde com os resultados esperados\n",
    "        for (entrada, saida) in casos_de_teste.items():\n",
    "            resultado = funcao_quadratica(entrada)\n",
    "            self.assertEqual(resultado, saida)\n",
    "\n",
    "\n",
    "def main():\n",
    "    loader = unittest.TestLoader()\n",
    "    suite = unittest.TestSuite()\n",
    "    suite.addTests(loader.loadTestsFromTestCase(CasosDeTeste))\n",
    "    runner = unittest.TextTestRunner(failfast=True)\n",
    "    runner.run(suite)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode utilizar a estrutura acima para implementar seu próprio CodeRunner localmente.\n",
    "\n",
    "Tente criar casos de teste adicionais para os exercícios do Aprender antes de submetê-los.\n",
    "\n",
    "Tipicamente, se criam casos para avaliar o comportamento nos limites esperados dos valores.\n",
    "\n",
    "Por exemplo no caso de se acessar um elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E\n",
      "======================================================================\n",
      "ERROR: test_pilha (__main__.CasosDeTeste)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"/tmp/ipykernel_16336/3979136957.py\", line 32, in test_pilha\n",
      "    self.assertEqual(None, funcao_valor_na_posição(5))\n",
      "  File \"/tmp/ipykernel_16336/3979136957.py\", line 20, in funcao_valor_na_posição\n",
      "    return vetor_de_valores[x]\n",
      "IndexError: list index out of range\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.002s\n",
      "\n",
      "FAILED (errors=1)\n"
     ]
    }
   ],
   "source": [
    "import unittest # biblioteca de testes Python\n",
    "\n",
    "# Classe com casos de teste\n",
    "class CasosDeTeste(unittest.TestCase):\n",
    "    # Cada subcaso de teste deve ser iniciado com o nome test_\n",
    "    def test_pilha(self):\n",
    "        # Valores de entradas e saídas esperadas\n",
    "        casos_de_teste = {\n",
    "            # posição : valor\n",
    "            0: 1,\n",
    "            1: 4,\n",
    "            2: 9,\n",
    "            3: 16,\n",
    "            4: 25,\n",
    "        }\n",
    "        vetor_de_valores = [1, 4, 9, 16, 25]\n",
    "\n",
    "        # Função a ser avaliada\n",
    "        def funcao_valor_na_posição(x):\n",
    "            return vetor_de_valores[x]\n",
    "\n",
    "        # Verifique se o resultado da função avaliada\n",
    "        # corresponde com os resultados esperados\n",
    "        for (entrada, saida) in casos_de_teste.items():\n",
    "            resultado = funcao_valor_na_posição(entrada)\n",
    "            self.assertEqual(resultado, saida)\n",
    "\n",
    "        # Agora teste os valores de borda, caso sejam acessadas as posições 0 e 6\n",
    "        # último valor da lista\n",
    "        self.assertEqual(funcao_valor_na_posição(-1), 25)\n",
    "        # tenta acessar valor além do fim da lista\n",
    "        self.assertEqual(None, funcao_valor_na_posição(5))\n",
    "\n",
    "\n",
    "def main():\n",
    "    loader = unittest.TestLoader()\n",
    "    suite = unittest.TestSuite()\n",
    "    suite.addTests(loader.loadTestsFromTestCase(CasosDeTeste))\n",
    "    runner = unittest.TextTestRunner(failfast=True)\n",
    "    runner.run(suite)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podem ver, o teste falhou. O que significa que ou o caso de teste está errado, ou a implementação está errada. Neste caso, poderiamos esperar, por exemplo, que a implementação retornasse None invés de uma exceção."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.001s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "import unittest # biblioteca de testes Python\n",
    "\n",
    "# Classe com casos de teste\n",
    "class CasosDeTeste(unittest.TestCase):\n",
    "    # Cada subcaso de teste deve ser iniciado com o nome test_\n",
    "    def test_pilha(self):\n",
    "        # Valores de entradas e saídas esperadas\n",
    "        casos_de_teste = {\n",
    "            # posição : valor\n",
    "            0: 1,\n",
    "            1: 4,\n",
    "            2: 9,\n",
    "            3: 16,\n",
    "            4: 25,\n",
    "        }\n",
    "        vetor_de_valores = [1, 4, 9, 16, 25]\n",
    "\n",
    "        # Função a ser avaliada\n",
    "        def funcao_valor_na_posição(x):\n",
    "            if x >= len(vetor_de_valores):\n",
    "                return None\n",
    "            return vetor_de_valores[x]\n",
    "\n",
    "        # Verifique se o resultado da função avaliada\n",
    "        # corresponde com os resultados esperados\n",
    "        for (entrada, saida) in casos_de_teste.items():\n",
    "            resultado = funcao_valor_na_posição(entrada)\n",
    "            self.assertEqual(resultado, saida)\n",
    "\n",
    "        # Agora teste os valores de borda, caso sejam acessadas as posições 0 e 6\n",
    "        # último valor da lista\n",
    "        self.assertEqual(funcao_valor_na_posição(-1), 25)\n",
    "        # tenta acessar valor além do fim da lista\n",
    "        self.assertEqual(None, funcao_valor_na_posição(5))\n",
    "\n",
    "\n",
    "def main():\n",
    "    loader = unittest.TestLoader()\n",
    "    suite = unittest.TestSuite()\n",
    "    suite.addTests(loader.loadTestsFromTestCase(CasosDeTeste))\n",
    "    runner = unittest.TextTestRunner(failfast=True)\n",
    "    runner.run(suite)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Programação orientação à objetos (OOP)\n",
    "\n",
    "Objetos são a combinação de estruturas de dados e dos algoritmos que os manipulam.\n",
    "\n",
    "São utilizados para modelar comportamentos diversos observados.\n",
    "\n",
    "Utilizemos como exemplo o de um controle remoto.\n",
    "\n",
    "Um controle é um objeto abstrato, e neste controle tipicamente existem botões que podem ser apertados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Controle:\n",
    "    # Método construtor Python, onde é definida a estrutura\n",
    "    # de dados de um objeto de classe Controle (neste caso)\n",
    "    def __init__(self):\n",
    "        self.botoes = {}\n",
    "\n",
    "    # Um controle abstrato sem botões não pode\n",
    "    # ter nenhum botão apertado, portanto não faça nada.\n",
    "    def apertarBotao(self, botao):\n",
    "        return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O controle acima pode ser especializado em diferentes tipos de controles, como um controle remoto de televisão ou de um videogame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ControleTV(Controle):\n",
    "    # Adiciona novos botões ao dicionário de botões\n",
    "    # O dicionário é composto pelos botões e a ação dos botões\n",
    "    def botao1(self):\n",
    "        print(\"Apertou 1\")\n",
    "    def botao2(self):\n",
    "        print(\"Apertou 2\")\n",
    "    def botao3(self):\n",
    "        print(\"Apertou 3\")\n",
    "    def botao4(self):\n",
    "        print(\"Apertou 4\")\n",
    "    def botao5(self):\n",
    "        print(\"Apertou 5\")\n",
    "    def botao6(self):\n",
    "        print(\"Apertou 6\")\n",
    "    def botao7(self):\n",
    "        print(\"Apertou 7\")\n",
    "    def botao8(self):\n",
    "        print(\"Apertou 8\")\n",
    "    def botao9(self):\n",
    "        print(\"Apertou 9\")\n",
    "    def botao0(self):\n",
    "        print(\"Apertou 0\")\n",
    "    def __init__(self):\n",
    "        # Chama o construtor da classe pai (Controle)\n",
    "        # Ele criará automaticamente self.botoes\n",
    "        super().__init__()\n",
    "\n",
    "        self.botoes.update({\n",
    "            1: self.botao1,\n",
    "            2: self.botao2,\n",
    "            3: self.botao3,\n",
    "            4: self.botao4,\n",
    "            5: self.botao5,\n",
    "            6: self.botao6,\n",
    "            7: self.botao7,\n",
    "            8: self.botao8,\n",
    "            9: self.botao9,\n",
    "            0: self.botao0\n",
    "        })\n",
    "    # Substitui o comportamento de apertarBotao\n",
    "    # definido na classe Controle\n",
    "    def apertarBotao(self, botao):\n",
    "        # Se tentar apertar um botão que não existe,\n",
    "        # não aconteceria nada na vida real, porém no código\n",
    "        # deve ser checado e tratado\n",
    "        if botao not in self.botoes:\n",
    "            raise Exception(\"Botão inexistente\")\n",
    "        # Aciona a função de tratamento de aperto do botão\n",
    "        self.botoes[botao]()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora apertemos estes botões para digitar o famoso número da rádio-taxi alvorada.\n",
    "Primeiro precisamos criar um controle do modelo (classe) ControleTV.\n",
    "Depois apertar o número 3218181."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apertou 3\n",
      "Apertou 2\n",
      "Apertou 1\n",
      "Apertou 8\n",
      "Apertou 1\n",
      "Apertou 8\n",
      "Apertou 1\n"
     ]
    }
   ],
   "source": [
    "controletv = ControleTV()\n",
    "controletv.apertarBotao(3)\n",
    "controletv.apertarBotao(2)\n",
    "controletv.apertarBotao(1)\n",
    "controletv.apertarBotao(8)\n",
    "controletv.apertarBotao(1)\n",
    "controletv.apertarBotao(8)\n",
    "controletv.apertarBotao(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos ter controles de videogames.\n",
    "E neste caso, modelaremos também o videogame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aperta botão 'a' no controle 0\n",
      "Controle não sincronizado\n",
      "Aperta botão 'b' no controle 0\n",
      "Controle não sincronizado\n",
      "Aperta botão 'x' no controle 0\n",
      "Controle não sincronizado\n",
      "Aperta botão 'y' no controle 0\n",
      "Controle não sincronizado\n"
     ]
    }
   ],
   "source": [
    "class ControleVideogame(Controle):\n",
    "    CONTADOR_INSTANCIAS = 0\n",
    "    def fazNada(self, id):\n",
    "        print(\"Controle não sincronizado\")\n",
    "\n",
    "    def __init__(self):\n",
    "        # Método construtor de Controle irá criar o dicionário self.botoes\n",
    "        super().__init__()\n",
    "\n",
    "        # Dá identificador único para este controle\n",
    "        self.id = ControleVideogame.CONTADOR_INSTANCIAS\n",
    "        ControleVideogame.CONTADOR_INSTANCIAS += 1\n",
    "\n",
    "        # Adicionamos os botões do controle, porém sem implementar nada\n",
    "        self.botoes.update({\"x\": self.fazNada,\n",
    "                            \"y\": self.fazNada,\n",
    "                            \"a\": self.fazNada,\n",
    "                            \"b\": self.fazNada\n",
    "                            })\n",
    "        # Adicionamos também uma variável de controle\n",
    "        # utilizada para indicar a qual console o controle já foi\n",
    "        # sincronizado (quando a implementação dos botões será definida)\n",
    "        self.consoleSincronizado = None\n",
    "\n",
    "    # Um console pode sincronizar com este controle\n",
    "    def sincronizaControle(self, console, mapeamentoBotoes: dict):\n",
    "        self.consoleSincronizado = console\n",
    "        self.botoes.update(mapeamentoBotoes)\n",
    "\n",
    "    # Chama a implementação do botão\n",
    "    def apertarBotao(self, botao):\n",
    "        print(f\"Aperta botão '{botao}' no controle {self.id}\")\n",
    "        self.botoes[botao](self.id)\n",
    "\n",
    "controleNaoSincronizado = ControleVideogame()\n",
    "controleNaoSincronizado.apertarBotao(\"a\")\n",
    "controleNaoSincronizado.apertarBotao(\"b\")\n",
    "controleNaoSincronizado.apertarBotao(\"x\")\n",
    "controleNaoSincronizado.apertarBotao(\"y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Precisamos agora sincronizar um controle a um console, que redefinirá a funcionalidade dos botões\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Aperta botão 'b' no controle 1\n",
      "Console imprime B: apertado por controle 1\n",
      "Aperta botão 'a' no controle 1\n",
      "Console imprime A: apertado por controle 1\n",
      "Aperta botão 'x' no controle 1\n",
      "Console imprime X: apertado por controle 1\n",
      "Aperta botão 'y' no controle 1\n",
      "Console imprime Y: apertado por controle 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Console:\n",
    "    # Um console pode ter mais de um controle associado\n",
    "    def __init__(self):\n",
    "        self.controles = []\n",
    "\n",
    "    def apertaX(self, controle):\n",
    "        print(f\"Console imprime X: apertado por controle {controle}\")\n",
    "    def apertaY(self, controle):\n",
    "        print(f\"Console imprime Y: apertado por controle {controle}\")\n",
    "    def apertaA(self, controle):\n",
    "        print(f\"Console imprime A: apertado por controle {controle}\")\n",
    "    def apertaB(self, controle):\n",
    "        print(f\"Console imprime B: apertado por controle {controle}\")\n",
    "\n",
    "    def sincronizaControle(self, controle: ControleVideogame):\n",
    "        self.controles.append(controle)\n",
    "        controle.sincronizaControle(self, {\"x\": self.apertaX,\n",
    "                                           \"y\": self.apertaY,\n",
    "                                           \"a\": self.apertaA,\n",
    "                                           \"b\": self.apertaB\n",
    "                                           }\n",
    "                                    )\n",
    "controleSincronizado = ControleVideogame()\n",
    "consoleXbox = Console()\n",
    "print()\n",
    "consoleXbox.sincronizaControle(controleSincronizado)\n",
    "controleSincronizado.apertarBotao(\"b\")\n",
    "controleSincronizado.apertarBotao(\"a\")\n",
    "controleSincronizado.apertarBotao(\"x\")\n",
    "controleSincronizado.apertarBotao(\"y\")\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As classes em Python também permitem que sejam comparadas as instâncias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n0 < n1 ? True\n"
     ]
    }
   ],
   "source": [
    "class Numero:\n",
    "    def __init__(self, valor=0):\n",
    "        self.valor = valor\n",
    "\n",
    "    def __lt__(self, other):\n",
    "        return self.valor < other.valor\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.valor}\"\n",
    "\n",
    "n0 = Numero(0)\n",
    "n1 = Numero(1)\n",
    "print(f\"n0 < n1 ? {n0<n1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se conseguimos determinar uma ordem, conseguimos ordenar.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "3\n",
      "5\n",
      "6\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "numeros = [\n",
    "    Numero(3),\n",
    "    Numero(1),\n",
    "    Numero(2),\n",
    "    Numero(9),\n",
    "    Numero(7),\n",
    "    Numero(6),\n",
    "    Numero(3),\n",
    "    Numero(5),\n",
    "]\n",
    "for numero in sorted(numeros):\n",
    "    print(numero)"
   ]
  }
 ],
 "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}