Programacao_Python_02.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python - Aula 02.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNk4gtD1RDZkO1FBhW0T326",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pablo-sampaio/espacos4.0_pe/blob/main/Programacao_Python_02.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python - Aula 2"
      ],
      "metadata": {
        "id": "BZkDNsZtUlAu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Configurações Iniciais\n",
        "\n",
        "Esta célula manda alguns comandos do sistema, para instalar bibliotecas (módulos) Python adicionais."
      ],
      "metadata": {
        "id": "0G02bEK-UwPD"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_U9uwfgGUdPh"
      },
      "outputs": [],
      "source": [
        "from IPython.display import clear_output\n",
        "!pip install gTTS\n",
        "!pip install googletrans==3.1.0a0\n",
        "clear_output()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1 - Relembrando Tipos de Dados\n",
        "\n",
        "Vimos sobre tipos de dados no Notebook 1, e agora, vamos relembrar e aprofundar.\n",
        "\n",
        "Lembre-se que cada tipo de dado tem operações específicas associadas ao tipo."
      ],
      "metadata": {
        "id": "3Z7FGOUkca2I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Numéricos"
      ],
      "metadata": {
        "id": "sXIDgUGRhc0U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vimos dois tipos numéricos: inteiros (que Python chama da `int`) e com casas decimais (`float`)."
      ],
      "metadata": {
        "id": "4ABrR7Y_XBZG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num1 = 2022\n",
        "num2 = 3.14"
      ],
      "metadata": {
        "id": "bh_bPiuohbvK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(num1)\n",
        "print(num2)\n",
        "num2"
      ],
      "metadata": {
        "id": "gf6wqoYLhk6V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O comando `type()` exibe o tipo de uma variável ou um de um valor literal (que é um valor dado \"diretamente\")."
      ],
      "metadata": {
        "id": "N1HlCUrbXNdm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "type(num1)"
      ],
      "metadata": {
        "id": "sma39Ij7hoD1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(12)"
      ],
      "metadata": {
        "id": "rv7byZqnXkWv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(num2)"
      ],
      "metadata": {
        "id": "8iHHH4s2hrnm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "num1 + num2"
      ],
      "metadata": {
        "id": "A97yCrlT34Vf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Textuais / Strings"
      ],
      "metadata": {
        "id": "Iq6UMu1whz6g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Esse é o tipo que guarda dados textuais. Python o chama de `str`."
      ],
      "metadata": {
        "id": "OdA_UXH4XYhl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "texto1 = \"Esta é uma string\""
      ],
      "metadata": {
        "id": "DxHL6od2h3zE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(texto1)"
      ],
      "metadata": {
        "id": "BkVqDYKph9e-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "texto2 = texto1 + texto1"
      ],
      "metadata": {
        "id": "OkcQpGFZh981"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Classes\n",
        "\n",
        "São tipos acrescentados à linguagem. Podem:\n",
        "\n",
        "* Vir de uma biblioteca (que alguém criou)\n",
        "* Ou podem ser criados por você, programador\n",
        "\n",
        "Vimos, na aula 1, duas classes específicas vindas de bibliotecas: tabela (com a classe `DataFrame`) e imagem (classe `Image`). \n",
        "\n",
        "Vamos ver um pouco mais sobre as **tabelas** criadas com a classe **`DataFrame`**. \n",
        "\n",
        "Abaixo, nós importamos esta classe (este tipo) do pacote pandas. Também importamos o comando `read_csv()`do mesmo pacote.\n",
        "\n"
      ],
      "metadata": {
        "id": "ofgwTdDiiATh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pandas import DataFrame, read_csv"
      ],
      "metadata": {
        "id": "UyRIyG9Oh_Ht"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Poderíamos criar um objeto da classe `DataFrame` da forma indicada abaixo. Depois, teríamos que inserir os dados um a um, o que seria trabalhoso."
      ],
      "metadata": {
        "id": "O_a2rKx3tiM6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tabela0 = DataFrame()\n",
        "tabela0.loc[\"linha1\", \"coluna1\"] = 11\n",
        "tabela0.loc[\"linha1\", \"coluna2\"] = 22"
      ],
      "metadata": {
        "id": "9tY0Jz6XnIEO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tabela0"
      ],
      "metadata": {
        "id": "xzcMjcfWtJEp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos usar uma forma mais fácil de carregar uma tabela a partir de um arquivo \".csv\". (Que pode ser salvo a partir do Excel).\n",
        "\n",
        "O comando `read_csv()` recebe um dado textual que indica o caminho do arquivo \".csv\". Ele automaticamente cria um DataFrame e carrega os dados do arquivo nele."
      ],
      "metadata": {
        "id": "Yt8Ap6YAt3cN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tabela1 = read_csv(\"/content/sample_data/california_housing_train.csv\")"
      ],
      "metadata": {
        "id": "TkIFeWWEitFu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tabela1"
      ],
      "metadata": {
        "id": "YtDo0peAjsPN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(tabela1)"
      ],
      "metadata": {
        "id": "1el7MwHKvzpa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Esse tipo tem suas operações próprias, acessadas com **`<variável>.<operação>`**. Veremos duas operações:\n",
        "- `.describe()` - gera estatísticas para cada coluna da tabela - contagem (*count*), média (*mean*), mínimo (*min*), máximo (*max*), etc.\n",
        "- `.get(coluna)` - retorna apenas os dados da coluna indicada (como string)\n"
      ],
      "metadata": {
        "id": "HyUEUgDouv-B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tabela1.describe()"
      ],
      "metadata": {
        "id": "OZEp68ahj0Vn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "coluna_valor_casa = tabela1.get(\"median_house_value\")\n",
        "coluna_valor_casa"
      ],
      "metadata": {
        "id": "Ly0Avq3FkRGF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Na variável `coluna_valor_casa` podemos chamar a operação `.plot.kde()`para gerar um gráfico mostrando a distribuição dos valores (ou seja, quais valores são mais frequentes e quais valores são menos frequentes)."
      ],
      "metadata": {
        "id": "C9c6rba8wwY6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "coluna_valor_casa.plot.kde()"
      ],
      "metadata": {
        "id": "KtjaXxaWwRBk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2 - Coleções / Tipos Sequenciais"
      ],
      "metadata": {
        "id": "bcPyHaSenU_V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Às vezes, queremos manter o registro de várias dados relacionados juntos.\n",
        "\n",
        "Por exemplo, podemos desejar manter um registro dos alunos (para processar isso de alguma forma depois)."
      ],
      "metadata": {
        "id": "xavN6Z98ypV5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "aluno0 = \"João\"\n",
        "aluno1 = \"Pablo\"\n",
        "aluno2 = \"Maria\"\n",
        "aluno3 = \"Júlia\"\n",
        "aluno4 = \"Laura\"\n"
      ],
      "metadata": {
        "id": "ufrx5MMctM5-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Da forma indicada acima, seriam necessárias diversas variáveis.\n",
        "\n",
        "Para esse tipo de situação, podemos usar um tipo de variável que agrupa dados. Veremos dois **tipos de dados** que permitem fazer isso: \n",
        "- tuplas (`tuple`)\n",
        "- e listas (tipo `list`)\n",
        "\n",
        "Ambos guardam dados em sequências. Vamos começar vendo como criar uma tupla:"
      ],
      "metadata": {
        "id": "HKc40snIy2up"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# cria uma tupla com os dados acima e com alguns números\n",
        "tupla1 = (\"João\", \"Pablo\", \"Maria\", 12, \"Júlia\", 1.7)\n",
        "print(tupla1)"
      ],
      "metadata": {
        "id": "NyOyDbdDncff"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(tupla1)"
      ],
      "metadata": {
        "id": "qM6VasJyRJGk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos acessar os elementos por \"índices\" que iniciam em 0 (zero). Ou seja:\n",
        "- o primeiro elemento está no índice `0`\n",
        "- o segundo elemento está no índice `1`\n",
        "- o terceiro elemento está no índice `2`\n",
        "- e assim sucessivamente\n",
        "\n",
        "Acessamentos o índice informando-o entre colchetes assim: `<variável>`**[**`<índice>`**]**.\n",
        "\n",
        "Veja os exemplos:"
      ],
      "metadata": {
        "id": "4eUdbiDw-SlN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tupla1[0]"
      ],
      "metadata": {
        "id": "isfXK7Uk-M2q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tupla1[3]"
      ],
      "metadata": {
        "id": "xmJhBzWL-hiI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A lista é similar às tuplas, mas a representação de uma lista literal é delimitada por colchetes (`[` e `]`):"
      ],
      "metadata": {
        "id": "Y0ewHOkZRGDP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista1 = [\"João\", \"Pablo\", \"Maria\", 12, \"Júlia\"]"
      ],
      "metadata": {
        "id": "7pvqqQxIt0nM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(lista1)"
      ],
      "metadata": {
        "id": "OilNAc3LuGIe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos acessar os elementos usando índices da mesma forma que fizemos com as tuplas:"
      ],
      "metadata": {
        "id": "hfE1KYRFRagN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista1[0]"
      ],
      "metadata": {
        "id": "wVB7C2ma_WWs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista1[3]"
      ],
      "metadata": {
        "id": "jNXWmrjw_YZO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O diferencial das listas é que elas *podem ser alteradas* (as tuplas não podem). \n",
        "\n",
        "Por exemplo, podemos acessar uma posição da lista (por meio de um índice) e atribuir um valor àquela posição, como se fosse uma variável individual. Veja abaixo:"
      ],
      "metadata": {
        "id": "CaMgadkARmG2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista1[0] = \"Inaldo\""
      ],
      "metadata": {
        "id": "s8dpq_3rqtI_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista1"
      ],
      "metadata": {
        "id": "fAUz63vn1lse"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Também podemos alterá-las com essas operações (entre outras):\n",
        "- `.append()` - acrescenta um elemento à direita da lista\n",
        "- `.clear()` - limpa a lista, removendo tudo"
      ],
      "metadata": {
        "id": "Zt868R1c1odr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista1.append(\"Paulo\")"
      ],
      "metadata": {
        "id": "ZIPCr5no-30V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista1"
      ],
      "metadata": {
        "id": "thN67vB6_QOi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista1.clear()"
      ],
      "metadata": {
        "id": "vdWpNtbD_cTu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista1"
      ],
      "metadata": {
        "id": "xjg_kHLR_fUN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3 - Revendo o \"for\""
      ],
      "metadata": {
        "id": "AZefZbZ8nc7Z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "O comando `for`serve para percorrer os elementos de uma lista.\n",
        "\n",
        "Note que a variável x vai receber cada um dos valores dados na lista:"
      ],
      "metadata": {
        "id": "cU1XGuheR85W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in [0, 1, 2, 3, 4]:\n",
        "  print(\"PROG -\", x)"
      ],
      "metadata": {
        "id": "K5vaKmyGngeU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O código abaixo é idêntico ao anterior. Isso porque `range(5)` ou `range(0,5)` é um tipo de dado similar a uma lista contendo os itens de 0 a 4 (nunca inclui o último número indicado nos parâmetros)."
      ],
      "metadata": {
        "id": "slXIhFCFSdK2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in range(5):\n",
        "  print(\"PROG -\", x)"
      ],
      "metadata": {
        "id": "1PMihkjgSaN4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Importamos esse comando `sleep()` para fazer o código abaixo \"dormir\" (esperar) por alguns segundos, para acompanharmos o funcionamento do `for`."
      ],
      "metadata": {
        "id": "eQwRmvUxSEgj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from time import sleep"
      ],
      "metadata": {
        "id": "AjC6u3O1AO2k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for z in [\"manga\", 1, \"banana\", 3.14]:  \n",
        "  print(z)\n",
        "  sleep(2)"
      ],
      "metadata": {
        "id": "nwhgd6hwoxWE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note que `z` é uma variável que vai receber os valores da lista dada, um por vez. Também podemos usar uma tupla para fornecer os valores:"
      ],
      "metadata": {
        "id": "5hivtPVJTAZe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for z in (\"manga\", 1, \"banana\", 3.14):  \n",
        "  print(z)\n",
        "  sleep(2)"
      ],
      "metadata": {
        "id": "pRJYtfHXS3S2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4 - Algoritmos"
      ],
      "metadata": {
        "id": "6AjL0ak0oyH1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "É uma visão mais teórica-matemática da computação em que pensamos como criar programas para resolver certos **problemas**. \n",
        "\n",
        "- cada problema tem **entradas**, que são dados iniciais;\n",
        "- e tem **saída** esperada, que é a resposta desejada, para as entradas dadas.\n",
        "\n",
        "Abaixo, mostramos alguns problemas e os algoritmos que os solucionam."
      ],
      "metadata": {
        "id": "f3RrtZ-jYO6V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Como **trocar dois itens** de uma lista?\n",
        "* **Entradas**: lista, índice1, índice2\n",
        "* **Saída**: lista (com os valores trocados)\n",
        "\n",
        "Vamos mostrar o algoritmo que resolve esse problema, com entradas de exemplo dadas (mas serve para quaisquer outras entradas)."
      ],
      "metadata": {
        "id": "W4aLpwRFo1Tk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Entradas\n",
        "i1 = 1\n",
        "i2 = 2\n",
        "lista1 = [\"João\", \"Pablo\", \"Maria\", 12, \"Júlia\"]"
      ],
      "metadata": {
        "id": "uG_trioJpBdX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "auxiliar = lista1[i1]"
      ],
      "metadata": {
        "id": "Y8yhv73aBfgv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista1[i1] = lista1[i2]\n",
        "print(lista1)"
      ],
      "metadata": {
        "id": "Na8I__RqB21Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista1[i2] = auxiliar\n",
        "print(lista1)"
      ],
      "metadata": {
        "id": "6ZLMkb-fBP17"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Como achar o **máximo** de uma lista de números?\n",
        "* **Entrada**: lista de números\n",
        "* **Saída**: valor máximo\n",
        "\n",
        "Segue o algoritmo abaixo, para uma entrada de exemplo."
      ],
      "metadata": {
        "id": "rVIBOOK5pBv9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Entrada\n",
        "lista_numeros = [3, 7, 1, 3, 2, 5, 7, 8, 11, -1, -4]"
      ],
      "metadata": {
        "id": "Pzh7YYaHpRb9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "num_max = lista_numeros[0]  # começo assumindo que o primeiro elemento é o máximo\n",
        "\n",
        "# depois, analiso todo elemento \"x\" a lista\n",
        "# se outro elemento for maior, atribuo ele ao máximo\n",
        "for x in lista_numeros:\n",
        "  if x > num_max:\n",
        "    num_max = x\n",
        "  #print(\"O máximo encontrado até aqui: \", num_max)\n",
        "  #sleep(3)"
      ],
      "metadata": {
        "id": "CI20_qbFDpOO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Saída\n",
        "num_max"
      ],
      "metadata": {
        "id": "lOrYOLtvE9-M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Como **ordenar** uma lista?\n",
        "* **Entradas**: lista\n",
        "* **Saída**: lista (ordenada)\n"
      ],
      "metadata": {
        "id": "Zx93GJlqpRyM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Entrada\n",
        "lista = [ 4, 1, 3, 2, 5, 0]"
      ],
      "metadata": {
        "id": "rDDGIgEvp13M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Você pode usar a operação `.sort()` que, internamente, já implementa um algoritmo para esse problema.\n",
        "\n",
        "O código abaixo está comentado (desativado). Remova o `#` se quiser testar."
      ],
      "metadata": {
        "id": "irKTtuHZsDQZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#lista.sort()"
      ],
      "metadata": {
        "id": "Hn4BBUIIpc1l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(lista)"
      ],
      "metadata": {
        "id": "ZH8jpsUAwHoW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ou você pode tentar implementar um algoritmo você mesmo. \n",
        "\n",
        "Existem vários algoritmos para ordenação. Abaixo, implementamos o algoritmo chamado **bubble sort** (ordenação por bolhas). \n",
        "\n",
        "Não precisa entender os detalhes. Se quiser uma explicação dele, veja em: https://panda.ime.usp.br/panda/static/pythonds_pt/05-OrdenacaoBusca/OBubbleSort.html."
      ],
      "metadata": {
        "id": "1etwoB9EsOHU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "trocou_elementos = True\n",
        "tamanho_lista = len(lista)\n",
        "\n",
        "while trocou_elementos:\n",
        "  trocou_elementos = False\n",
        "  for i in range(tamanho_lista-1):\n",
        "    if lista[i] > lista[i+1]:\n",
        "      temp = lista[i+1]\n",
        "      lista[i+1] = lista[i]\n",
        "      lista[i] = temp\n",
        "      trocou_elementos = True"
      ],
      "metadata": {
        "id": "rh4Ak5TOp3s9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista"
      ],
      "metadata": {
        "id": "avZF0Tw_GgpK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5 - Usando \"IA Pronta\""
      ],
      "metadata": {
        "id": "Wvaot4oCUeLX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vou mostrar alguns comandos interessantes.\n",
        "\n",
        "Quero que pense em ***\"como funcionam, internamente, esses algoritmos?\"***\n",
        "\n",
        "Que passos você faria para produzir esses resultados?"
      ],
      "metadata": {
        "id": "MvDFK3JTlBF1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.1 Para Traduzir"
      ],
      "metadata": {
        "id": "DXpSzHOzlW7_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from googletrans import Translator"
      ],
      "metadata": {
        "id": "58gIUM0gnEnt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Crie uma classe (um novo tipo de dado) `Translator` da forma mostrada abaixo, indicando como parâmetro o site de tradução do Google que será usado."
      ],
      "metadata": {
        "id": "Zx_IP1szwpoc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tradutor = Translator(['translate.googleapis.com'])"
      ],
      "metadata": {
        "id": "aNsfnEIXlAW2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(tradutor)"
      ],
      "metadata": {
        "id": "IoAVLVJXqvbe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Detectar Idioma"
      ],
      "metadata": {
        "id": "WO9iGLZAqz4Z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Como a variável da classe `Translator`, podemos detectar o idioma de um texto usando o comando `detect()` e passando como parâmetro a string contendo o texto. \n",
        "\n",
        "Vamos analisar a frase \"Ich sprech kein deutsche\"."
      ],
      "metadata": {
        "id": "V0YyMN68w8oO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "resultado = tradutor.detect(\"Ich sprech kein deutsche\")"
      ],
      "metadata": {
        "id": "nD6yTXJ3k-ze"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ao imprimir o resultado, vamos que ele indica o código do idioma logo ao lado da palavra **\"lang=\"**. \n",
        "- No caso o código é **\"de\"** que é usado para o idioma \"alemão\". \n",
        "- Consulte outros códigos aqui: https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes\n",
        "\n",
        "O número após **\"confidence=\"** indica o percentual de confiança que o algoritmo de detecção tem nessa resposta."
      ],
      "metadata": {
        "id": "xl2SjnrXxN4d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(resultado)"
      ],
      "metadata": {
        "id": "kAKJ2WEVHhtz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "No exemplo abaixo, vemos que ele indica o idioma Português (\"pt\") com 100% de confiança."
      ],
      "metadata": {
        "id": "iONL6AUyyqdG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "resultado = tradutor.detect(\"Olá, caro professor executor dos Espaços 4.0!\")\n",
        "print(resultado)"
      ],
      "metadata": {
        "id": "njv2cmVqnKHd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Traduzir"
      ],
      "metadata": {
        "id": "Fa0JGsgyq3Z8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para traduzir, usamos o comando `translate()` passando dois parâmetros, nesta ordem:\n",
        "- O texto, na forma de string \n",
        "- e o código do idioma de destino, também como string. \n",
        "\n",
        "Vamos usar \"pt\" para traduzir para Português."
      ],
      "metadata": {
        "id": "Wcpq9oxIzLHS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "traducao1 = tradutor.translate(\"Hello, how are you?\", \"pt\")\n",
        "print(traducao1)"
      ],
      "metadata": {
        "id": "UZLccq4KlxEt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O resultado tem várias informações da tradução, como pode ser visto acima. Mas podemos obter o texto traduzido acessando `<resultado>.text`."
      ],
      "metadata": {
        "id": "NMl59olOzQQg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(traducao1.text)"
      ],
      "metadata": {
        "id": "GTUo9SgeIwhM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Quer saber a tradução para o português do texto alemão indicado antes?"
      ],
      "metadata": {
        "id": "LX0zAsuszkBn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "traducao2 = tradutor.translate(\"Ich sprech kein deutsche\", \"pt\")\n",
        "print(traducao2.text)"
      ],
      "metadata": {
        "id": "1_yxKxijncc1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.2 Para Gerar Áudio a partir de Texto\n",
        "\n"
      ],
      "metadata": {
        "id": "TtBblXkck6h-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos importar o comando `gTTS()` para gerar áudio a partir de texto. Atenção: você precisa chamar esse comando exatamente assim, tendo apenas o \"g\" minúsculo e o restante em maiúscula."
      ],
      "metadata": {
        "id": "z2Iz_ZLr0FRC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from gtts import gTTS\n",
        "from IPython.display import Audio"
      ],
      "metadata": {
        "id": "I21HX0KaX3V-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Parâmetros:\n",
        "\n",
        "* Texto a ser convertido para áudio\n",
        "* Final do site (translate.google.`<final>`) - basta passar o parâmetro \"com\"\n",
        "* Código do idioma - use \"pt\" para Português, e \"en\" para Inglês"
      ],
      "metadata": {
        "id": "cJl7YgBAX8ql"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "audio1 = gTTS(\"Bem vindo ao curso de programação Python!\", 'com', 'pt')"
      ],
      "metadata": {
        "id": "PXR1fS42U8lK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O resultado não toca diretamente aqui no Colab. Ao colocá-lo na última linha, o Colab apenas imprime o um resultado esquisito (que tem a ver com o nome completo da classe e o endereço na memória RAM)."
      ],
      "metadata": {
        "id": "gw2UdJoM0X8d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "audio1"
      ],
      "metadata": {
        "id": "tg8xc2wj7V3g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Então, vamos salvá-lo em arquivo e carregar o mesmo arquivo por meio de uma classe chamada `Audio`, que pode ser tocada aqui!"
      ],
      "metadata": {
        "id": "8tBY0mWV0fNK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "audio1.save('audio_saida1.wav')"
      ],
      "metadata": {
        "id": "SAVkqeO0rkAV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "audio1_tocavel = Audio('audio_saida1.wav', autoplay=True)\n",
        "audio1_tocavel"
      ],
      "metadata": {
        "id": "7HUENURVVWyS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Veja outro exemplo abaixo:"
      ],
      "metadata": {
        "id": "5qSmVW1g1Y_a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "audio2 = gTTS('Welcome to this Python programming course!', 'com', 'en')\n",
        "audio2.save('audio_saida2.wav')"
      ],
      "metadata": {
        "id": "Jon7S81gnmxz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Audio('audio_saida2.wav', autoplay=False)"
      ],
      "metadata": {
        "id": "Y9uxHZGBn3lG"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}