PYTHON1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/LeandroBarbosa753/Python/blob/main/PYTHON1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j50YOHyYku3m"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zN8CUsYzku8c"
      },
      "source": [
        "# INTRODUÇÃO AO PYTHON"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9UfPpQCCqJsp"
      },
      "outputs": [],
      "source": [
        "print(\"Hello wolrd!\")\n",
        "print(\"Olá mundo\")\n",
        "a=\"Leandro \"\n",
        "b=\"Barbosa\"\n",
        "print(a+b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jrvl4wv8mT1R"
      },
      "source": [
        "# Comentários em python"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3U-XIOKVmv09"
      },
      "outputs": [],
      "source": [
        "print(\"Olá!\")\n",
        "#print(\"😊\")  ##cerquilha##\n",
        "'''Comentário com mais de uma linha''' # (artifício, não necessariamente é como o comentário, as linhas dentro das 3 aspas simples não são executadas)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tZUWPxnFptw3"
      },
      "source": [
        "# Variáveis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5h5_rqtvqoui"
      },
      "outputs": [],
      "source": [
        "# Variáveis tipo string(Cadeia e caracter)\n",
        "# Python não faz distinção de aspas simples e duplas\n",
        "a = \"Leandro\"\n",
        "b = 'Barbosa'\n",
        "c = '''Vieira''' # aspas triplas não são utilizadas com essa função\n",
        "print(a+b+c) # python também aceita \",\" no lugar do \"+\",podendo ser print(a,b,c)\n",
        "print(a,b,c)\n",
        "print(a,b,c, sep='-') # o comando \"sep\" é um separador de variáveis\n",
        "print(a,b,c, sep='*')\n",
        "print(a,b,c, sep='*')\n",
        "print(a,b,c, sep=\"\\n\") #colocar o \"\\n\" dentro do comando \"sep\" resulta em um quebra de linha\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ABxWAh5vsD2O"
      },
      "outputs": [],
      "source": [
        "# Variáveis númericas em python\n",
        "# Os tipos são: double, byte, booleana, int, float, string\n",
        "# string - para letras\n",
        "# int - Números inteiros\n",
        "# float - Números flutuante(reais)\n",
        "# double - Números reais flutuante em dobro\n",
        "# byte - Tamanho de um byte\n",
        "# booleana - Valores de Verdadeiro(V) e Falso(F) --> em Inglês é true e false\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3uCIhqUxwFru"
      },
      "outputs": [],
      "source": [
        "# python aceita a quebra de linhas '\\n' para saltar uma linha\n",
        "nome = \"Rua Manoel Paiva \\nN°325\\nBairro Parque Piauí\\nTimon/MA\"\n",
        "print(nome)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zRTGjTJ4zj7l"
      },
      "outputs": [],
      "source": [
        "# separação de termos de uma string - slicing\n",
        "nome =\"LEANDRO\"\n",
        "print(nome,\"\\n\")\n",
        "print(len(nome),\"\\n\") # len é a abreviação de lenght, o comando \"len\" vai oferecer a quantidade de caracteres da variável\n",
        "print(nome[0])\n",
        "print(nome[1])\n",
        "print(nome[2])\n",
        "print(nome[3])\n",
        "print(nome[4])\n",
        "print(nome[5])\n",
        "print(nome[6])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v-dYRrKZ1SJH"
      },
      "outputs": [],
      "source": [
        "# pedaços do nome de uma string \n",
        "nome = \"Retângulo\"\n",
        "print(nome[3:]) # Valores ao lado esquerdo dos dois pontos são executados. A direita não.\n",
        "print(nome[:3])  # Valores ao lado direito dos dois pontos são exercutados. A esquerda não.\n",
        "print(nome[:-3])\n",
        "print(nome[-3:]) # Coloca os três últimos valores da string \n",
        "print(nome[:3] + nome[3:] )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FJx-TmvP4fXA"
      },
      "outputs": [],
      "source": [
        "# Teste: \n",
        "nome = \"Leandro\"\n",
        "valor = 7\n",
        "resultado = (valor)**(len(nome))\n",
        "print(resultado)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jon6xHHZ-Zx_"
      },
      "outputs": [],
      "source": [
        "# Outras formatações de strings\n",
        "print(\"A pontuação total de %s foi %s pontos\" % (\"Fernando\",\"10\"))\n",
        "# print(\"A pontuação total de %s foi %s pontos\" % (\"nome\",\"10\"))\n",
        "print(\"A pontuação total de {} foi {} pontos\".format(\"Fernando\",\"10\"))\n",
        "\n",
        "\"\"\" #Formatação\"\"\"\n",
        "# %s texto\n",
        "# %d inteiro \n",
        "# %f real"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ukfi0VhjBGYC"
      },
      "outputs": [],
      "source": [
        "# Variáveis Booleanas (False or true)\n",
        "a = 3\n",
        "b = 4\n",
        "c = 1\n",
        "print(a==b)\n",
        "print(a!= b)\n",
        "print(a+c==b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-TRW0pDlB88o"
      },
      "source": [
        "# Operadores Aritiméticos\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EkpUmxt3CE2d"
      },
      "outputs": [],
      "source": [
        "# São os operadores das operações matemáticas()\n",
        "'''\n",
        "    -   (subtração)\n",
        "    +   (adição ou concatenção)\n",
        "    *   (multiplicação)\n",
        "    /   (divisão)\n",
        "    //  (divisão inteira)\n",
        "    %   (resto da divisão)\n",
        "    **  (potenciação)\n",
        "   '''"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gZvtg24rGfJi"
      },
      "source": [
        "# Identação\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NA2_Fld_GlX3"
      },
      "outputs": [],
      "source": [
        "from IPython.core.display import clear_output\n",
        "#Exercício rápido\n",
        "senha = \"ifma22\"\n",
        "confere = input(\"Digite sua senha: \")\n",
        "if senha == confere:\n",
        "  print(\"Senha Correta! |Logado no sistema\")\n",
        "elif confere == \"225\":\n",
        "  print(\"Senha de Administrador. Agora você é root\")\n",
        "else:\n",
        "  print(\"Senha incorreta!\")\n",
        "  clear_output()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E2PUQNhvI5WJ"
      },
      "outputs": [],
      "source": [
        "# exemplo de If com True\n",
        "senha = \"ifma22\"\n",
        "confere = input(\"Digite sua senha: \")\n",
        "if True:\n",
        "  print(\"Senha de Administrador. Agora você é root\")\n",
        "else:\n",
        "  print(\"Senha incorreta!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ETRbakdUo7Wa"
      },
      "source": [
        "# Entrada de Comandos\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "4PDKyb7LpH_o"
      },
      "outputs": [],
      "source": [
        "# Entrada de comandos de texto é o input()\n",
        "# Exemplo de cadastro\n",
        "nome = input(\"Digite seu nome: \")\n",
        "endereco = input(\"Endereço: \")\n",
        "sexo = input(\"Sexo: M/F?\")\n",
        "identidade = input(\"Identidade: \")\n",
        "CPF = input(\"CPF\")\n",
        "print(f\"Nome:{nome}\\nEndereço:{endereco}\\nsexo:{sexo}\\nidentidade:{identidade}\\ncpf:{CPF}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_PZ_zFK3rER8"
      },
      "source": [
        "# Exercício"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s7p_apO_rJ33"
      },
      "outputs": [],
      "source": [
        "# Faça os algoritmos em Python de acordo com o que se pede abaixo:\n",
        "# for i in range(x) o range vai dizer até onde o i vai contar\n",
        "\n",
        "# 1) Que imprima números de 1 a 10.\n",
        "for i in range(10):\n",
        "  print(i+1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fMc9-Twtrtjx"
      },
      "outputs": [],
      "source": [
        "# 2) Que imprima os números impares menores que 100.\n",
        "for i in range(50):\n",
        "  print(i*2+1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MYCw1QxJslc4"
      },
      "outputs": [],
      "source": [
        "# 4) Que imprima todas as tabuadas do número 1 ao 10.\n",
        "for i in range(11):\n",
        "  print(\"\\n\\nTabuada de \", i,\"\\n\")\n",
        "  for y in range(11):\n",
        "    print(i,\"*\", y, \"=\", i*y)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n8xGvHbJvPhf"
      },
      "outputs": [],
      "source": [
        "# 5) Que some os números de 1 a 10>\n",
        "soma = 0\n",
        "for i in range(11):\n",
        "  soma+= i # += soma da variável com a variável da frente\n",
        "print(\"A soma é:\", soma)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sTgy2fNwwltW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "40b6c24b-ec9e-47a9-9b05-f2b7406010b8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite um número: 10\n",
            "Digite a porcentagem: 100\n",
            "100.0 % de 10.0 é: 10.0\n"
          ]
        }
      ],
      "source": [
        "# 6) Uma função que calcule a porcentagem de um número.\n",
        "numero = float(input(\"Digite um número: \")) #float são números reais \n",
        "porcento = float(input(\"Digite a porcentagem: \"))\n",
        "resultado = numero*(porcento/100)\n",
        "print(porcento,\"%\", \"de %.1f é: %.1f\" %(numero,resultado))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dd1bCDqEx-nd"
      },
      "source": [
        "# Casting (Mudança de tipos de variáveis)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ny2c-Wdfy9iw"
      },
      "outputs": [],
      "source": [
        "texto1 = \"1.5\"\n",
        "texto2 = '4'\n",
        "numero1 = float(texto1)\n",
        "numero2 = int(texto2)\n",
        "#numero3 = 1.546\n",
        "textovoltar = str(numero1)\n",
        "\n",
        "print(type(texto1))\n",
        "print(type(texto2))\n",
        "print(type(numero1))\n",
        "print(type(numero2))\n",
        "print(type(textovoltar))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "62dPmpcdz5-7"
      },
      "outputs": [],
      "source": [
        "numeros = \"0123456789\"\n",
        "print(numeros[5])\n",
        "numeros_casting=int(numeros[5])\n",
        "print(int(numeros[5]))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Invertendo string\n"
      ],
      "metadata": {
        "id": "lx8bMcGKsG-N"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SynURyQ425D_"
      },
      "outputs": [],
      "source": [
        "# Invertendo string\n",
        "texto = \"ROMA\"\n",
        "x = texto.split()\n",
        "print(x)\n",
        "print(texto[::-1]) # print(texto[iniciar:intervalo:ordem]) se colocar a ordem negativo vai printar aocontrário\n",
        "# algorismos:iniciar:intervalo:ordem\n",
        "print(texto[::-3]) # o output é \"AR\", pois o A é o \"0\" quando a ordem está invertida e o \"3\" significa que será contado de 3 em 3, então a segunda letra vai ser \"R\", pois está na posição \"3\"."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Testando a existência de caracter no texto\n"
      ],
      "metadata": {
        "id": "UOuglHncsOyI"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y91SlN5N7uUI"
      },
      "outputs": [],
      "source": [
        "# Testando a existência de caracter no texto\n",
        "texto1 = \"Casa\"\n",
        "print(\"a\"in texto1)\n",
        "print(\"i\"in texto1)\n",
        "print(\"ASA\"in texto1)\n",
        "print(\"asa\"in texto1)\n",
        "print(\"ASA\" not in texto1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "py-fy5t8hV_u"
      },
      "source": [
        "# Imutalidade de String"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c9F_eMVOkf_0"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo python 3\"\n",
        "texto[14] = \"2\"\n",
        "print(texto) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yr0LVud9hdg1"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo python 3\"\n",
        "texto[0:14] + \"2\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TVBpiyEohpJM"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo Ththon 3\"\n",
        "print(texto.replace(\"T\",\"P\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KXB93ZWWjyAM"
      },
      "source": [
        "# Métodos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D9V6vmSHkwyU"
      },
      "source": [
        "## Método len # Length"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CigZMVVDlMEV"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo python 3\"\n",
        "\n",
        "print(len(texto))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ewmbPf10l9y3"
      },
      "source": [
        "## Método capitalize\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H7CycFRLmGOt"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo python 3\"\n",
        "texto2 = texto.capitalize()\n",
        "print(texto2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jLmV2IHPmvvw"
      },
      "source": [
        "## Método startswith"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ujkwP3Wnm4tI"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo python 3\"\n",
        "texto2 = texto.startswith(\"e\")\n",
        "print(texto2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kgwn3_eDnGJZ"
      },
      "source": [
        "## Método endswith"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NbFZAYPAnOGh"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo python 3\"\n",
        "texto2 = texto.endswith(\"e\")\n",
        "print(texto2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TugDx3pinaWr"
      },
      "source": [
        "## Método split"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OVgAIYS9ngda"
      },
      "outputs": [],
      "source": [
        "texto = \"estudo python 3\"\n",
        "print(type(texto))\n",
        "texto2 = texto.split()\n",
        "print(texto2)\n",
        "print(type(texto2))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Formatando Strings"
      ],
      "metadata": {
        "id": "epC2-8rAs0tH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# teste de confirmação de email\n",
        "email = input(\"Digite seu email: \")\n",
        "if \"@\" in email:\n",
        "  print(\"email correto!\")\n",
        "else:\n",
        "  print(\"Favor acrescente o email correto\")"
      ],
      "metadata": {
        "id": "xWtZP1Cds3_I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Separando uma string\n",
        "nomeCompleto = input(\"Digite seu nome: \")\n",
        "print(len(nomeCompleto))\n",
        "nome = nomeCompleto[:8]\n",
        "sobrenome = nomeCompleto[-7:]\n",
        "print(\"Nome: \" + nome)\n",
        "print(\"Sobrenome: \" + sobrenome)"
      ],
      "metadata": {
        "id": "y9Wy-J47uHOK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Comandos de decisão IF Else e Elif"
      ],
      "metadata": {
        "id": "uPH9M_kr6xtl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numero = 11\n",
        "if numero >= 11:\n",
        "  print(\"Maior ou igual a 11\")"
      ],
      "metadata": {
        "id": "wHl-B4yk65sM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = 3\n",
        "\n",
        "b = int(input(\"Digite um número: \"))"
      ],
      "metadata": {
        "id": "AtaDSeyDBtHV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=3\n",
        "b=int(input(\"Digite um número:\"))\n",
        "if a>b:\n",
        "  print(\"A é maior que B\")\n",
        "  print(\"A maça da apple\")\n",
        "  print(\"Linux é o melhor SO do mundo!\")\n",
        "else:\n",
        "  print(\"A é menor que B\")\n",
        "  print(\"Eu me chamo João\")\n",
        "  print(\"A terra é redonda\")"
      ],
      "metadata": {
        "id": "bLKJ2hm17E1P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nome = input(\"Digite seu nome: \")\n",
        "nome = nome.lower()\n",
        "for i in range(len(nome)):\n",
        "  if nome[i] in \"a\":\n",
        "      print(\"O nome\", nome, \"tem a vogal\", nome[i])\n",
        "  if nome[i] in \"e\":\n",
        "      print(\"O nome\", nome, \"tem a vogal\", nome[i])\n",
        "  if nome[i] in \"i\":\n",
        "      print(\"O nome\", nome, \"tem a vogal\", nome[i])\n",
        "  if nome[i] in \"o\":\n",
        "      print(\"O nome\", nome, \"tem a vogal\", nome[i])\n",
        "  if nome[i] in \"u\":\n",
        "      print(\"O nome\", nome, \"tem a vogal\", nome[i])"
      ],
      "metadata": {
        "id": "lfo7bg-U9A-y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "num = int(input(\"Digite um nuúmero: \"))\n",
        "if num <10: \n",
        "  print(\"Menor que 10\")\n",
        "elif num <100:\n",
        "  print(\"Menor que 100\")\n",
        "elif num <1000:\n",
        "  print(\"Menor que 1000\")\n",
        "else:\n",
        "  print(\"Não estão dentro de valores\")"
      ],
      "metadata": {
        "id": "MepD-AEUBfZc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Laço While"
      ],
      "metadata": {
        "id": "oU6qApmcClEP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Comando com break\n",
        "num = 0\n",
        "while True:\n",
        "  if num ==5:\n",
        "    break\n",
        "  print(num)\n",
        "  num+=1\n",
        "print(\"encerrou\")"
      ],
      "metadata": {
        "id": "pYaRd9ZfCphI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Comando continue pulando um valor\n",
        "num = 0\n",
        "while num<10:\n",
        "  num+=1\n",
        "  if num ==4:\n",
        "    continue\n",
        "  print(num)\n",
        "print(\"Terminou\")"
      ],
      "metadata": {
        "id": "2DGAy1llE-8u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Comando For"
      ],
      "metadata": {
        "id": "syFw7O8eGvH7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(10):\n",
        "  print(i)"
      ],
      "metadata": {
        "id": "6cgV9hDiGx_j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Start para o range. --> Coloca o número para iniciar antes \n",
        "for i in range(1,11):\n",
        "  print(i)"
      ],
      "metadata": {
        "id": "TWG1P6kfG7by"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Usando o terceiro valor dentro do range(No fim)\n",
        "\n",
        "for i in range(2,10,2):# primeiro valor é o inicial da variável, o segundo valor é até onde ele vai contar, e o terceiro é intervalo\n",
        "  print(i)"
      ],
      "metadata": {
        "id": "t44tEng2HlAb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Range regressivo\n",
        "# No range regressivo o valor do primeiro será até onde o valor vai contar, o segundo é o valor inicial e o terceiro é o intervalo\n",
        "for i in range(100,-2,-2):\n",
        "  print(i)"
      ],
      "metadata": {
        "id": "GXd7XzoJJTaQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Range com strings\n",
        "texto = \"Maria Carolina\"\n",
        "for i in range(0 , len(texto)):\n",
        "  print(texto[i])"
      ],
      "metadata": {
        "id": "itfYoGnRKGSh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Encontrando uma letra e a posição\n",
        "nome = input(\"Digite um nome: \")\n",
        "letra = input(\"Digite uma letra: \")\n",
        "for i in range(0,len(nome)):\n",
        "  if letra == nome[i]:\n",
        "    print(\"Encontrei a letra %s na posição %i\" %(letra, i))\n",
        "    print(\"Encontrei a letra {} na posição {}\" .format(letra, i))\n",
        "    print(f\"Encontrei a letra {letra} na posição {i}\")"
      ],
      "metadata": {
        "id": "FwCeNfmCLIl0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Condicionando com digito de uma letra apenas\n",
        "nome = input(\"Digite um nome: \")\n",
        "letra = input(\"Digite uma letra: \")\n",
        "if len(letra) !=1:\n",
        "  print(\"Digite apenas uma letra por favor!\")\n",
        "else: \n",
        "  for i in range(0,len(nome)):\n",
        "    if letra == nome[i]:\n",
        "      print(\"Encontrei a letra %s na posição %i \") %(letra, i)\n",
        "    break"
      ],
      "metadata": {
        "id": "ajMc46qTNCRK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# For com texto\n",
        "texto= \"Ana Maria\"\n",
        "for x in texto:\n",
        "  print(x)"
      ],
      "metadata": {
        "id": "0hflFnsEPA69"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# For aninhados Tabuadas de 1 ee 2 ou mais\n",
        "\n",
        "for x in range(1,11):\n",
        "  print(\"========================\")\n",
        "  for j in range(1,11): \n",
        "    print(x,\"x\",j,\"=\",x*j)"
      ],
      "metadata": {
        "id": "Eq4NFcIqqtxP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Arrays tipo lista em python\n"
      ],
      "metadata": {
        "id": "Ew9IQc1arICM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "array = []\n",
        "arry = list([1,2,3]) #List é um método do python \n",
        "print(array)\n",
        "print(arry)"
      ],
      "metadata": {
        "id": "jbhCJAwrrM3M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "array = [2,\"nome\",5,7, 10, 15, 21, \"Leandro\",'Barbosa', True, None]\n",
        "print(array[0:3]) #imprimindo vetores com mais de uma posição\n",
        "print(array[-1]) #imprimi o ultimo elemento do vetor\n",
        "print(array[0]) #imprimi o primeiro elemento da lista\n",
        "print(array) # para imprimir toda a lista não coloca colchetes"
      ],
      "metadata": {
        "id": "v04NkouStFM9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vetor = [10,2,3]\n",
        "# metodo append() insere um elemento no final da lista\n",
        "vetor.append(5)\n",
        "print(vetor)\n",
        "# metodo que insete um elemento no vetor em qualquer posição do vetor.(2,6)\n",
        "vetor.insert(2,6) # não apaga valores da lista\n",
        "print(vetor)\n",
        "# substitui um elemento do vetor\n",
        "vetor[0] = \"Leandro\"\n",
        "print(vetor)\n",
        "\n",
        "''' REMOVENDO VALORES '''\n",
        "# Removendo um elemento pelo valor do elemento\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "Wv2XfJGvtu3N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vetor = [10,2,3]\n",
        "vetor[1] = 16 # apaga o valor anterior e coloca o novo\n",
        "vetor.append(5) # adciona um valor no final da lista\n",
        "vetor.insert(3,100) # adciona um valor na posição selecionada sem apagar o valor que estava na posição anteriormente\n",
        "print(vetor)"
      ],
      "metadata": {
        "id": "rW3CFLw6ysXe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vetor1 = [100,101,102,103]\n",
        "vetor3 = vetor1+vetor2"
      ],
      "metadata": {
        "id": "P1mM6mWt6QKN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vetor4=[1,2,3,4]\n"
      ],
      "metadata": {
        "id": "y3iKzF9f6dtI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiplicação de arrays (duplica)\n",
        "\n",
        "vetor4 = [1,2,3,4]\n",
        "produto = ((vetor)*2)"
      ],
      "metadata": {
        "id": "7v54ue4F6z09"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Separaçõ do vetor em variáveis\n",
        "vetor10 = [7,8,9]\n",
        "x,y,z = vetor10\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)"
      ],
      "metadata": {
        "id": "sOneO65A67uG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Separando elementos  com MENOS ELEMENTOS QUE O TOTAL do vetor\n",
        "vetor = [7,8,9]\n",
        "x,y,z = vetor[0:3]\n",
        "a,b,_ = vetor #coloca underline no espaço que não quer os elementos\n",
        "print(a)\n",
        "print(b)\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)"
      ],
      "metadata": {
        "id": "RVEAj7fW87DM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Percorrendo elementos de um vetor\n",
        "cores = [\"azul\", \"preto\", \"amarelo\"]\n",
        "for x in cores:\n",
        "  print(x)"
      ],
      "metadata": {
        "id": "SU1yfGVJpGM3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Percorrendo elementos de um vetor pelos índices\n",
        "cores = [\"azul\", \"preto\", \"amarelo\"]\n",
        "for i in range(0, len(cores)): # range(start, stop, step)\n",
        "  print(cores[i])"
      ],
      "metadata": {
        "id": "tij3HmM0rWXl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Percorrendo elementos de um vetor com while\n",
        "cor = [\"azul\",\"preto\",\"amarelo\"]\n",
        "indice=0\n",
        "while (indice < len(cor)):\n",
        "  print(cor[indice])\n",
        "  indice +=1"
      ],
      "metadata": {
        "id": "nW_B9d-Drv9s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Valores em ordem crescente e decrescente numa lista\n",
        "## Ordem crescente\n",
        "a = [5,7,2,3,9]\n",
        "a.sort()\n",
        "print(a)"
      ],
      "metadata": {
        "id": "C2P0LhCLsXgS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ordem crescente com armazenamento em outra variável\n",
        "lista1 = [2,7,8,9,4]\n",
        "nova_lista = sorted(lista1)\n",
        "print(nova_lista)"
      ],
      "metadata": {
        "id": "cabEpn3MtKfK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ordem descrescente com \"reverse = True \"\n",
        "a = [5,7,2,3,9]\n",
        "a.sort(reverse=True)\n",
        "print(a)"
      ],
      "metadata": {
        "id": "A50WCjICtxhI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ordem decrescente com armazenamento em outra variável\n",
        "lista1 = [2,7,8,9,4]\n",
        "nova_lista = sorted(lista1, reverse=True)\n",
        "print(nova_lista)"
      ],
      "metadata": {
        "id": "MAMF4xxpuIpX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Utilizando o Enumerate\n",
        "impostos = ['MEI', 'Simples', 'Complexo']\n",
        "for i, imposto in enumerate(impostos):\n",
        "  print(i, imposto)"
      ],
      "metadata": {
        "id": "Rx-duJ_Ev6kA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Lista de listas\n",
        "lista = [[1,2,3],[7,8,9]]\n",
        "primeiraLista = lista[0]\n",
        "print(primeiraLista)\n",
        "segundaLista = lista[1]\n",
        "print(segundaLista)"
      ],
      "metadata": {
        "id": "Q8tA_N1LxAYU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Pegando elementos de uma lista interna\n",
        "lista = [[1,2,3],[7,8,9]]\n",
        "elemento1 = lista[0][0]\n",
        "elemento2 = lista[0][1]\n",
        "elemento3 = lista[0][2]\n",
        "\n",
        "print(elemento1)\n",
        "print(elemento2)\n",
        "print(elemento3)"
      ],
      "metadata": {
        "id": "_3yGh3qVx6fy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SET - Listas imutáveis"
      ],
      "metadata": {
        "id": "JqENDLbbAziS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Com set não pode mudar itens, mas somente remover e inserir itens\n",
        "lista_set = {0}\n",
        "lista_set_comElementos = {1,2,3,4,5}\n",
        "lista_set.add(4) # Adicionando elemento no set . Não adciona em listas set sem elementos\n",
        "lista_set_comElementos.add(4)\n",
        "print(lista_set)\n",
        "print(lista_set_comElementos)"
      ],
      "metadata": {
        "id": "GE3kMemwsfrE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# União de sets \n",
        "set1 = {1,2,3} # coloca em ordem crescente e alfabética e não repete elementos\n",
        "set2 = {3,4,5}\n",
        "set_unido = set1.union(set2)\n",
        "print(set_unido)"
      ],
      "metadata": {
        "id": "U-DK9ABHu8Iw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Insterseção de sets\n",
        "set1 = {1,2,3} # Dá só os elementos que se repetem\n",
        "set2 = {3,4,5}\n",
        "set_inter = set1.intersection(set2)\n",
        "print(set_inter)"
      ],
      "metadata": {
        "id": "Kx_D_tmdvneT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Diferente do sets \n",
        "set1 = {1,2,3}\n",
        "set2 = {3,4,5}\n",
        "set_dif = set2.difference(set1)\n",
        "print(set_dif)\n",
        "set_dif = set1.difference(set2)\n",
        "print(set_dif)"
      ],
      "metadata": {
        "id": "OCR72Nw0w_TM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tuplas"
      ],
      "metadata": {
        "id": "pVCBuX1yA5uk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tupla é uma lista que não pode ser modificada e deve ter no mínimo 02 elementos(imutáveis)\n",
        "objetos = (\"Casa\",\"Sala\",\"Janela\") # pode ser assim ou:\n",
        "doces = tuple((\"chocolate\", \"bombom\", \"paçoca\")) # pode ser ainda que assim: doces = (\"chocolate\", \"bombom\",\" paçoca\")\n",
        "print(doces)"
      ],
      "metadata": {
        "id": "m8o1egD2A8Cb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# pegando elementos da tupla\n",
        "num = (1,2,3,4,17)\n",
        "escolha = num[2:4] # sempre reduz um elemento então se quiser printar o número 17 terá que colocar 5\n",
        "print(escolha)\n",
        "index = num.index(3) # localizar o indexador da tupla\n",
        "print(index)"
      ],
      "metadata": {
        "id": "H9qp1Ux1CaGX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "objetos = \"Casa\",\"Sala\",\"Janela\"\n",
        "objetos1 = (\"Casa\",\"Sala\",\"Janela\")\n",
        "objetos2 = tuple((\"Casa\",\"Sala\",\"Janela\"))\n",
        "print(type(objetos))\n",
        "print(type(objetos1))\n",
        "print(type(objetos2))"
      ],
      "metadata": {
        "id": "oW-GR1mfC7G7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Transformando tuplas em listas e vice-versa\n",
        "setTupla = (1,2,3,4,5) # ------> Tupla\n",
        "ListaNormal = list(setTupla) #Tupla em lista\n",
        "ListaNormal[0] = 9\n",
        "print(setTupla)\n",
        "print(ListaNormal)\n",
        "ListaNormal.append(\"Olá\")\n",
        "setLista = tuple(ListaNormal) # Lista em Tupla\n",
        "print(setLista)\n",
        "teste = list(setLista)\n",
        "print(teste)"
      ],
      "metadata": {
        "id": "u95tJrY_F00m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tupla = (1,2,3,4,5,6,8)\n",
        "print(tupla)\n",
        "lista = list(tupla)\n",
        "lista[0] = 100\n",
        "print(lista)\n",
        "tupla = tuple(lista)\n",
        "print(tupla)"
      ],
      "metadata": {
        "id": "fPJL2HKcQL_T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dicionários"
      ],
      "metadata": {
        "id": "m1y9wfl8MHKt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Dicionário é formado por um conjunto chave(índice) valor\n",
        "# É necessário desterminar o índice e o valor \n",
        "idades = {'Ana':16,'Carol':20, 'Dinha':43}\n",
        "criador = {0:'Ana', 1:\"rafael\", 2:True}\n",
        "print(idades)\n",
        "print(idades['Ana']) # acessa-se pela chave\n",
        "print(criador)"
      ],
      "metadata": {
        "id": "Z_17pfQ-MKv6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Chave e valor pode ser de qualquer tipo\n",
        "reais = {3.1:\"Três ponto um\", 2.9: \"Dois ponto nove\"}\n",
        "logico = {True: 1, False:0}\n",
        "print(reais)\n",
        "print(logico)"
      ],
      "metadata": {
        "id": "HT1APl4t2ud8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Alterando valores de dicionários com [] ou update\n",
        "idades = {'Ana':16, 'Carol':20, 'Dinha':43, 'Cristiano': 49}\n",
        "idades['Carol'] = 19 # Primeira forma de alteração de valor\n",
        "idades.update({'Cristiano':48}) # Segunda forma de alteracão de valor \n",
        "print(idades)"
      ],
      "metadata": {
        "id": "M6gK-rvz3tXq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Adicionando chaves e valores\n",
        "idades['Fofinho'] = 2\n",
        "print(idades)"
      ],
      "metadata": {
        "id": "Z4ErSKWT4pxC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Removendo valores\n",
        "idades = {'Ana':16, 'Carol':20, 'Dinha':43, 'Cristiano':49}\n",
        "idades['Fofinho'] = 2\n",
        "idades.pop('Ana') # Forma de remover indice\n",
        "print(idades)\n",
        "idades.popitem() # Remove o último item do dicionário\n",
        "print(idades)"
      ],
      "metadata": {
        "id": "mTO5W7tP6MNh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Convertendo Dicionários em Tuplas "
      ],
      "metadata": {
        "id": "CxSFLjhO9IsH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "idades = {'Ana':16,'Carol':20,'Dinha':43,'Cristiano':49}\n",
        "listas = idades.items() # Esse comando converte dicionários em tuplas \n",
        "print(listas, end ='\\n\\n')\n",
        "\n",
        "# Percorrendo itens da lista\n",
        "for item in listas:\n",
        "  print(item[0], item[1])"
      ],
      "metadata": {
        "id": "hLN4eYt69OlP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Imprimindo separadamente chaves valores\n",
        "idade = {'Ana':16, 'Carol':20, 'Dinha':43, 'Cristiano': 49}\n",
        "chaves = idade.keys()\n",
        "valores = idade.values()\n",
        "for item in chaves :\n",
        "  print(item)\n",
        "print(\" ----------------\")\n",
        "for item in valores: \n",
        "  print(item)"
      ],
      "metadata": {
        "id": "U4DMFWiw9_JA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Lista Comprehensions"
      ],
      "metadata": {
        "id": "4w7sJ66xQRWe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista = [x for x in range(0,11)] # Percorrer de x enquanto x no intervalo de 0 a 10\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "lYrAI6UYQXpl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ou ainda:\n",
        "lista1 = ['0','1','quadro']\n",
        "lista2 = [x for x in lista1]\n",
        "print(lista2)"
      ],
      "metadata": {
        "id": "v_kk0NrdQ4Fo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Lista  para números pares\n",
        "lista = [x for x in range(0,11,2)]\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "lJhWcBCORP3A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ou ainda\n",
        "lista = [x for x in range(0,11) if x%2 ==0]\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "IUG8CAAdRPwv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ou ainda\n",
        "lista = [x*2 for x in range(0,11)]\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "LZ6EL41sSjoj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Impressão de lista retirando elementos de lista\n",
        "lista_aux = [1,2,3,7,8,9]\n",
        "lista = [x for x in range (0,11) if x not in lista_aux]\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "YOF3MgBFTFOU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo de intervalos \n",
        "lista = [x for x in range(-10,10) if x <9 if x>-4]\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "kSsdNKPrTl8l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Mudança de tipo de dado\n",
        "lista = [str(x) for x in range(-10,10) if x <9 if x>-4] # aqui muda para se\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "GCK8NbnzU1eh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Retornando apenas o primeiro digito\n",
        "lista = [str(x)[0] for x in range(0,21)] # aqui muda para string\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "wLsBDGafVshS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Par ou impar \n",
        "teste = ['par' if x % 2 == 0 else 'ímpar' for x in range(2,11)]\n",
        "print(teste)"
      ],
      "metadata": {
        "id": "F9dHjF5-Wnj1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Função lambda\n",
        "lista = [1,2,3,4,5,6,7,8,9]\n",
        "lista = list(filter(lambda x: x%2 == 0)) # Lambda filtra os valores\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "6P70nMdXW8yc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Matriz com lista comprehensions\n",
        "lista = [  [x for x in range(1,5)] for y in range(1,5)   ]\n",
        "print(lista)"
      ],
      "metadata": {
        "id": "aMZCvQw3Xis_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# De outro jeito \n",
        "lista = [[str(x)+ str(y) for x in range(1,8) ] for y in range(1,7)]\n",
        "lista # Aqui também imprime"
      ],
      "metadata": {
        "id": "pJhe5p6Kvphz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Criando uma tuabuada de multiplicação\n",
        "conta = [ [str(x) + \"*\" + str(y) + \"=\"+ str(x*y) for x in range(1,8)] for y in range(1,11)]\n",
        "conta"
      ],
      "metadata": {
        "id": "PulzLZh9z-Nt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Funções"
      ],
      "metadata": {
        "id": "akOmBTBV0dlK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Função em pyhton é def. def nome da função (parâmetros): ... return \n",
        "def qualquercoisa():\n",
        "    num = 10\n",
        "    print(f\"uma função {num}\")\n",
        "qualquercoisa()"
      ],
      "metadata": {
        "id": "TeoHuvL60hbD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Função que \"não faz nada\"\n",
        "def frankstains()\n",
        "  pass\n",
        "frankstains()"
      ],
      "metadata": {
        "id": "5lfBa4BB1pud"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Parâmetros em função exemplo 1:\n",
        "def print_var (numero):\n",
        "  print(numero)"
      ],
      "metadata": {
        "id": "a9-itr6B10FM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Parâmetros em função exemplo 1:\n",
        "def print_var (numero):\n",
        "  print(numero)\n",
        "print_var(2)"
      ],
      "metadata": {
        "id": "Rvd_9lZy3Usx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo :\n",
        "\n",
        "def sum(a, b):\n",
        "  return a + b\n",
        "c = sum(5,3)\n",
        "print(c)"
      ],
      "metadata": {
        "id": "QxC-pfFg4SIx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo 2\n",
        "def sum(a, b, c, d):\n",
        "  return a + b +c + d \n",
        "c = sum(5,3,6,9)\n",
        "print(c)"
      ],
      "metadata": {
        "id": "7CUsOCV16nyv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# mais de um parâmetro\n",
        "def soma(num1,num2):\n",
        "  print(num1+num2)\n",
        "soma(3,2)\n",
        "soma(\"Olá\", \"Mundo\")\n",
        "soma(3.0, 2.4) "
      ],
      "metadata": {
        "id": "0ezLSz63-tjG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# mais de um parâmetro\n",
        "def soma(num1,num2):\n",
        "  print(num1+num2)\n",
        "x = soma(3,2)\n",
        "y = soma(\"Olá\", \"Mundo\")\n",
        "z = soma(3.0, 2.4)"
      ],
      "metadata": {
        "id": "7jb-_zET7wrD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo 3 \n",
        "def sum(a, b):\n",
        "  return a + b\n",
        "sum(5,3)"
      ],
      "metadata": {
        "id": "nrltSpn37hQy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Operação em função \n",
        "def opera(num1,num2):\n",
        "  print(num1+num2)\n",
        "opera(10,4)\n",
        "# ou\n",
        "opera(num1 = 10,num2 = 4)"
      ],
      "metadata": {
        "id": "pJY817wq9wa-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Função com valores padrão paraseus argumentos\n",
        "\n",
        "def salario_descontado_imposto(salario, imposto = 27.5):\n",
        "  return salario - (salario * imposto * 0,.01)\n",
        "salario_descontado_imposto(5000)"
      ],
      "metadata": {
        "id": "cv-Xn3sk-Bvn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Função com números arbitrário de parâmetros \n",
        "def func(*args): # OBS:> Os parâmetros são recebidos na forma de tuplas\n",
        "  print(type(args))  #args é um nome qualquer, poderia ser outro\n",
        "  print(\"Argumentos são: \", args)\n",
        "func()\n",
        "func(1,2,3)\n",
        "func(12, \"a\", 'b', 3.14, [1,2,3,4,5], True)"
      ],
      "metadata": {
        "id": "dhB5MGhj-Z6P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo \n",
        "def funcao(*argumento, outro):\n",
        "  print(argumento)\n",
        "  print(outro)\n",
        "\n",
        "func( [1,2,3], 4, 5, 7        ,          outro = \"Olá\")\n"
      ],
      "metadata": {
        "id": "iBieVos7_uZz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def func(valor, nome = \"Teste\", valores = 1): # os parâmetros com valor padrão tem que ser os últimos\n",
        "  print(valor, nome, valores)\n",
        "func(3)\n",
        "func(3, \"Cristiano\") # outro é a mudança de parâmetro nome. Muda o valor \"Teste\" para o valor \"Outro\""
      ],
      "metadata": {
        "id": "C2mbATIZE05e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Funções com argumentos Arbitrários"
      ],
      "metadata": {
        "id": "2_GTEMxzFXlW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Funções com argumentos tanto de nome ocmo parâmetros arbitrários. Utiliza-se\n",
        "def func(**args): # O ** define que é um dicionário, pois ** é nome parâmetro arbitrário\n",
        "  print(type(args))\n",
        "  print(args) # Imprime todos os argumentos \n",
        "  print(args[\"Valor\"]) # Imprime apenas o arguemento valor\n",
        "\n",
        "  func(Valor = 10, operacao = 'soma', resultado = 10)"
      ],
      "metadata": {
        "id": "kqyDfb8fFdTH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def printe(x)\n",
        "  print(x)\n",
        "\n",
        "def executa_func(func, x):\n",
        "  func(x)\n",
        "\n",
        "minha_funcao = printe\n",
        "print(type(minha_funcao))\n",
        "\n",
        "executa_func(minha_funcao, 12)"
      ],
      "metadata": {
        "id": "2bixYld6TKOB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Função com Retorno"
      ],
      "metadata": {
        "id": "IegA1FGhYM7T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def subtrai(num1,num2):\n",
        "  valor = num1 - num2\n",
        "  return valor\n",
        "subtrai(12,3) # A saída pode ser asssim. ou numa variável para transportar\n",
        "subtracao = subtrai(10,4) # Esse formato é para levar o resultado inserido numa variável para outra operação \n",
        "print(subtracao)"
      ],
      "metadata": {
        "id": "lwaHgOx9YRI6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def len_Int(numero):\n",
        "  numero_em_Texto = str(numero)\n",
        "\n",
        "num1 = 10\n",
        "num2 = 12345\n",
        "num3 = 4136576438653786\n",
        "\n",
        "tamanho1 = len_Int(num1)\n",
        "tamanho2 = len_Int(num2)\n",
        "tamanho3 = len_Int(num3)\n",
        "print(\"O número %d, tem %d digitos\" %(num1,tamanho1))\n",
        "print(\"O número %d, tem %d digitos\" %(num2,tamanho2))\n",
        "\n",
        "print(f\"O número {num1} tem {tamanho1} digitos\")\n",
        "print(f\"O número {num3} tem {tamanho3} digitos\")"
      ],
      "metadata": {
        "id": "NQIXRB5TYqNj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Funções com mais de um retorno"
      ],
      "metadata": {
        "id": "q54yBzup2SQm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Python pode retornar dois ou mais valores. (mú)\n",
        "def retornaDois():\n",
        "  return 2*3, 4+20\n",
        "  valor1 = retornaDois()\n",
        "retornaDois()"
      ],
      "metadata": {
        "id": "gRTPhxV52RLP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def retornaTres(Outro_valor = (5*2)):\n",
        "  return 2*(valor1[0]) + 2*(valor1[1]) + Outro_valor\n",
        "print(retornaTres())"
      ],
      "metadata": {
        "id": "wTAeebhw3Uix"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Função recursiva é aquela que chama a si mesma\n",
        "\n",
        "def conta(numero):\n",
        "  print(numero)\n",
        "  if numero >= 10:\n",
        "    return\n",
        "  conta(numero+1)\n",
        "conta(5)"
      ],
      "metadata": {
        "id": "TZgWGUEI6dbY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo de função recursiva que imprime umastring pelo índice\n",
        "\n",
        "def funTexto(texto, indice):\n",
        "  if indice == len(texto):\n",
        "    return\n",
        "  print(indice, texto[indice])\n",
        "  funTexto(texto, indice+1)\n",
        "funTexto(\"Cristiano\",  0)"
      ],
      "metadata": {
        "id": "Zh6-CYb47eXv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Funções Aninhadas"
      ],
      "metadata": {
        "id": "jkCB1rJt8Imy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def pai()\n",
        "  def filho():\n",
        "    print(\"Eu sou filho\")\n",
        "    def neto():\n",
        "      print(\"Eu sou neto\")\n",
        "    neto()\n",
        "  filho()\n",
        "  print(\"Agora sou Pai\")\n",
        "pai()"
      ],
      "metadata": {
        "id": "4NIXbkYo9vF0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def calculadora(num1, num2, op):\n",
        "  def soma(x,y):\n",
        "    return x + y\n",
        "  def subtrai(a,b):\n",
        "    return a - b\n",
        "  def mult(a,b):\n",
        "    return a * b\n",
        "  def divi(j,z):\n",
        "    return a/b\n",
        "  op = input(\"digite o sinal da operação: \")\n",
        "  if op == '+':\n",
        "    return soma(num1,num2)\n",
        "  elif op == '-':\n",
        "    return subtrai(num1,num2)\n",
        "  elif op == '*':\n",
        "    return mult(num1,num2)\n",
        "  elif op == '/':\n",
        "    return divi(num1,num2)\n",
        "  else:\n",
        "    print('Operação inválida!')\n",
        "calculadora(100,4,'op')  "
      ],
      "metadata": {
        "id": "kcPyt0RLAT2C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Outro exemplo\n",
        "def fora()\n",
        "  def dentro(var):\n",
        "    print(var)\n",
        "  return dentro\n",
        "imprimir = fora()\n",
        "imprimir(12)\n",
        "print(type(imprimir))"
      ],
      "metadata": {
        "id": "Hj8OU9EDCzUm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Funções Built-in"
      ],
      "metadata": {
        "id": "wGw63ghFDtzn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Funções Buitlin são funções já pré elaboradas\n",
        "# Número absoluto - função abs\n",
        "num1 = -10*4\n",
        "num2 = 10\n",
        "print(abs(num1))\n",
        "print(abs(num2))"
      ],
      "metadata": {
        "id": "2nIuzUoAEPP6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Máximo e mínimo\n",
        "valores = max(10,20,30,40,50)\n",
        "print(valores)\n",
        "\n",
        "valores = min(10,20,30,40,50)\n",
        "print(valores)"
      ],
      "metadata": {
        "id": "5JNz230BEmua"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Usando listas (max e min)\n",
        "lista = [1,2,3,4,5,6,7,8,70]\n",
        "print(max(lista))\n",
        "print(min(lista))"
      ],
      "metadata": {
        "id": "1H-sSdzpF3K8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Potência (pow)\n",
        "x = 2\n",
        "y = 3\n",
        "\n",
        "# método tradicional\n",
        "print(x**y) # não é bult-in\n",
        "# usando função bult-in pow\n",
        "print(pow(2,3))"
      ],
      "metadata": {
        "id": "0ko2RMD6GJB8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "# Raiz quadrada\n",
        "print(math.sqrt(25))\n",
        "print(81**(0.5)) # método tradicional"
      ],
      "metadata": {
        "id": "0daqAr3CGI78"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from math import floor, ceil\n",
        "# Arredondamento\n",
        "print(round(5.345)) # se a casa decimal for < 5 arredonda para o número anterior, se for > 5 arredonda para o próximo número\n",
        "# ou com casas decimais\n",
        "print(round(5.345,2)) # round usa uma vírgula extra do arredondamento\n",
        "# Arredondando para cima (ceil)\n",
        "print(ceil(5.345))\n",
        "# Arredonda para baixo (floor)\n",
        "print(floor(5.345))"
      ],
      "metadata": {
        "id": "heqJscS1GxS-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Retornando o Quociente inteiro e o resto da divisão (divmod)\n",
        "print(divmod(10,4))"
      ],
      "metadata": {
        "id": "f11JqpiP4WYp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Funções Built-ein de strings"
      ],
      "metadata": {
        "id": "adzSmRbMAuOC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "texto = \"21212123333333\" # --> Contar quantidade de caracteres\n",
        "print(texto.count(\"1\"))\n",
        "print(texto.count(\"3\"))\n",
        "# print(\"Extistem \", texto.count(x), \"Registros\")"
      ],
      "metadata": {
        "id": "yfm0e5yHAzSH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(texto.startswith(\"21\")) # --> caractere de início\n",
        "print(texto.endswith(\"339\"))"
      ],
      "metadata": {
        "id": "h4ngvS3MBT_R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "texto = 'me encontra 20 10 5'\n",
        "pos = texto.find(\"10\")\n",
        "print(pos)\n",
        "pos = texto.find(\"8\")\n",
        "print(pos)"
      ],
      "metadata": {
        "id": "5RBypp-QBhzJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pos = texto.indes('me')\n",
        "print(pos)"
      ],
      "metadata": {
        "id": "g9jACIphKAfB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "texto = \"Ol@ eu sou @ ful@n@\"       # --> Substituição de caracteres \n",
        "novo_texto = texto.replace(\"@\",\"a\")\n",
        "print(novo_texto)"
      ],
      "metadata": {
        "id": "EcSe7GRFKYP5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "texto = '10:20:30'          # --> Separando strings em vetor\n",
        "lista = texto.split(\":\")\n",
        "print(lista)\n",
        "print(lista[0], \"horas\" )\n",
        "print(lista[1], \"minutos\" )\n",
        "print(lista[2], \"segundos\" )"
      ],
      "metadata": {
        "id": "m2RaCSTfMrDH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "texto = \"Olá, bom dia \\n este é um curso de python\\n seja bem vindo\"\n",
        "print(texto.splitlines())"
      ],
      "metadata": {
        "id": "lpujBwllRUif"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"abcdE3\".isalpha()) # Todos os caracteres são letras? retorna true senão retorna"
      ],
      "metadata": {
        "id": "D1VqGWKVT51L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"0\".isdecimal() # Retorna true se for decimal"
      ],
      "metadata": {
        "id": "qZgfn-R9UXd_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"abcsE3\".isalnum()) # Retorna True se qualquer uma das quatro condições anteriores não haver caracteres especiais\n",
        "print(\"111@ddd\".isalnum()) # , - , @, % $ etc...\n",
        "print(\"111aa\".isalum())"
      ],
      "metadata": {
        "id": "3z8gOYUiUdq3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"   \".isspace) # Reconhece uma string vazia e retorna true ou false\n",
        "print(\"123\".isspace)\n",
        "print(\"1  \".isspace)"
      ],
      "metadata": {
        "id": "ebozkl9MWZWA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "texto = \"isTo É esTRanhO\"\n",
        "print(texto.lower())\n",
        "print(texto.upper())\n",
        "print(texto.capitalize())\n",
        "print(texto.swapcase) # Inverte de maiúscula para minúsculo"
      ],
      "metadata": {
        "id": "uRrFjgx-Xhuy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Descobrindo o caractere que gera um número\n",
        "numero = 70\n",
        "print(f\"O numero {numero} é lido pelo caractere {chr(numero)}\")\n",
        "print(numero)\n",
        "print(x.replace(\"F\", \"f\"))"
      ],
      "metadata": {
        "id": "j8S71PWUX6Zz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(0,127):\n",
        "  print(f'{i} = {chr(i)}')"
      ],
      "metadata": {
        "id": "YiygQWP_YORE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Descobrindo o número por meio do caractere\n",
        "caractere = \"a\"\n",
        "print(ord(caractere))"
      ],
      "metadata": {
        "id": "hYdOu71Z0oRT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista = [5,10,2,1,5,10] # Coloca em ordem crescente\n",
        "lista_nomes = [\"Zelda\", \"Ana\",  \"Teresa\", \"Beatriz\", \"Gilda\"]\n",
        "lista.sort()\n",
        "lista_nomes.sort() # Coloca em ordem alfabética                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \n",
        "print(lista)\n",
        "print(lista_nomes)"
      ],
      "metadata": {
        "id": "RL2JwsMV4ZWa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista_nomes = [\"Zelda\", \"Ana\",  \"Teresa\", \"Beatriz\", \"Gilda\"]\n",
        "lista.sort(reverse = True) # Coloca em ordem descrescente\n",
        "print(lista)\n",
        "lista_nomes.sort(reverse = True) # Coloca em ordem alfabética                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \n",
        "print(lista_nomes)"
      ],
      "metadata": {
        "id": "UaD745_i5R9s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "produtos = [['carro','R$ 100.000'],\n",
        "            ['caceira','R$ 1000'],\n",
        "            ['Moto','R$ 40000'],\n",
        "            ['geladeira','R$ 20000'],\n",
        "            ['armário','R$ 1500']]\n",
        "\n",
        "for produto, valor in produtos:\n",
        "  print(produto,\"- \",valor)"
      ],
      "metadata": {
        "id": "Jw_-GZ0t5a4E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime\n",
        "\n",
        "data_completa = datetime.datetime.now()\n",
        "data = data_completa.date()\n",
        "hora = data_completa.time()\n",
        "\n",
        "print(data_completa)\n",
        "print(hora)\n",
        "print(data)\n",
        "\n",
        "data2 = data.strftime(\"%d/%m/%Y\") # Modificando o formato da data do datetime\n",
        "print(data2)\n",
        "data2 = data.strftime(\"%d-%m-%Y\")\n",
        "print(data2)\n",
        "data2.format(\"%d-%m-%Y\")\n",
        "print(data2)"
      ],
      "metadata": {
        "id": "YfiSCR1F-IJQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime\n",
        "# h = 23\n",
        "# m = 00\n",
        "# s = 00\n",
        "# hora = datetime.time(h,m,s)\n",
        "# print(hora)\n",
        "hora = datetime.time(10,20,30)\n",
        "print(hora)"
      ],
      "metadata": {
        "id": "6NsiZkNmCqRj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "current_time = data.strftime(\"Data: %y/%m/%d \\nHora: %H:%M:%S\")\n",
        "print(current_time)"
      ],
      "metadata": {
        "id": "0vr0z-HqEbKA"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "zN8CUsYzku8c",
        "jrvl4wv8mT1R",
        "tZUWPxnFptw3",
        "-TRW0pDlB88o",
        "gZvtg24rGfJi",
        "ETRbakdUo7Wa",
        "_PZ_zFK3rER8",
        "Dd1bCDqEx-nd",
        "lx8bMcGKsG-N",
        "UOuglHncsOyI",
        "py-fy5t8hV_u",
        "KXB93ZWWjyAM",
        "D9V6vmSHkwyU",
        "ewmbPf10l9y3",
        "jLmV2IHPmvvw",
        "Kgwn3_eDnGJZ",
        "TugDx3pinaWr",
        "epC2-8rAs0tH",
        "uPH9M_kr6xtl",
        "oU6qApmcClEP",
        "syFw7O8eGvH7",
        "Ew9IQc1arICM",
        "JqENDLbbAziS",
        "pVCBuX1yA5uk",
        "m1y9wfl8MHKt",
        "CxSFLjhO9IsH",
        "4w7sJ66xQRWe",
        "akOmBTBV0dlK"
      ],
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOyehyjUsA4H4nGe7ZvAa1H",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}