ESTUDO_DE_PYTHON_.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/metsumesquita/Python_resumo/blob/main/ESTUDO_DE_PYTHON_.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ve1aWRTjmIH_"
      },
      "outputs": [],
      "source": [
        "#objetos e estruturas de dados basicas\n",
        "#python é uma linguagem orientada a objetos\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2IKB0cjDu3aE"
      },
      "source": [
        "#Importaçao"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fnjTKFkCu0nx"
      },
      "outputs": [],
      "source": [
        "from collections import namedtuple #importaçao"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "llWCVCCyS2DW"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dDt7N7gkdTFW"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gEJ_y9ljGqIu"
      },
      "source": [
        "#Variaveis e atribuiçao"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QuLVkl2polDo"
      },
      "outputs": [],
      "source": [
        "#as variaveis é apenas um nome dado a uma locaçao de memoria\n",
        "#o string nao sao mutaveis\n",
        "#toda a operaçao feita sobre a variavel afeta a locaçao de memoria"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S3znG9jp3Fvf",
        "outputId": "ce39e12e-d031-48b8-8f18-714d6a66ff0b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello \tWorld\n"
          ]
        }
      ],
      "source": [
        "print(\"Hello \\tWorld\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Er1xjey2-1CS",
        "outputId": "cd2640d8-70ba-4504-dbb2-5b9b45015b95"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "She said: \"Hi\"\n"
          ]
        }
      ],
      "source": [
        "#essa é a maneira que da pra fazer personagem : \"frase\"\n",
        "fala = \"She said: \\\"Hi\\\"\"\n",
        "print(fala)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4hwLJr2Z2NzG",
        "outputId": "f26bf1ba-391a-41d6-a26b-7610968039ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "O nome dela é : ?  Thais\n"
          ]
        }
      ],
      "source": [
        "#devemos nomear as variaveis da seguinte forma\n",
        "my_name = 'Thais' # esse = é uma ATRIBUIÇAO\n",
        "print('O nome dela é  ? :  '+my_name)\n",
        "#nao é permitido usar numeros no começo das variaveis\n",
        "#nao é permitido utilizar o espaço dentro de uma variavel"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eRQjowhJ2FsJ",
        "outputId": "8c5cc8a9-b085-47fb-b229-e7ea0cf1592a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Gato de gravata\n",
            "Urso de gravata\n"
          ]
        }
      ],
      "source": [
        "#alterando\n",
        "phrase=\"Gato de gravata\"\n",
        "print(phrase)\n",
        "#frase original\n",
        "print(phrase.replace(\"Gato\",\"Urso\"))\n",
        "#frase que sofreu  substituiçao"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8L4ed7m5Cawi",
        "outputId": "90db484d-95e5-4f2a-b483-a148428fa670"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Gato De Gravata\n"
          ]
        }
      ],
      "source": [
        "print(phrase.title())\n",
        "#deixa em maiusculo a primeira letra de cada palavra"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YjXiNtns6OPo",
        "outputId": "89026006-32ec-4464-95fe-9290971d7440"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "print(phrase.startswith(\"Urso\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "935FpLTg7XJw",
        "outputId": "30fa82a9-2426-48e7-f24f-b7aa0f17bcef"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(phrase.startswith(\"Gato\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fCyzdj2X7fVM",
        "outputId": "17c8b165-d332-4d28-8679-2aedbe886c95"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "print(phrase.endswith(\"gravata\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vOgSqQ6O1z29"
      },
      "source": [
        "#Leitura de Dados do Teclado/Entrada"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sZX8mq2tmnui"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "if __name__ == '__main__':\n",
        "    a = int(input(\"informe valor\"))\n",
        "    b = int(input(\"informe valor\"))\n",
        "    print((int(a)+int(b)))\n",
        "    print((int(a)-int(b) ))\n",
        "    print((int(a)*int(b)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 380
        },
        "id": "8UGOkZiDjR7g",
        "outputId": "98b473ce-b5d7-46bd-c03e-26c3e847476e"
      },
      "outputs": [
        {
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-2118551f056a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#aqui notamos que essas duas variaveis ,sao consideradas strings\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnum1\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Informe o valor da variavel 1 : '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mnum2\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Informe o valor da variavel 2 : '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Resposta : '\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mnum1\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mnum2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m##num1 e num2 sao strings\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m    861\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    862\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 863\u001b[0;31m             \u001b[0mpassword\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    864\u001b[0m         )\n\u001b[1;32m    865\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    902\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    903\u001b[0m                 \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 904\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Interrupted by user\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    905\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    906\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid Message:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexc_info\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
          ]
        }
      ],
      "source": [
        "#aqui notamos que essas duas variaveis ,sao consideradas strings\n",
        "num1=input('Informe o valor da variavel 1 : ')\n",
        "num2=input('Informe o valor da variavel 2 : ')\n",
        "print('Resposta : '+num1+num2)\n",
        "##num1 e num2 sao strings\n",
        "#mas nao era isso q esperavamos ou queriamos\n",
        "soma=int(num1)+int(num2)\n",
        "#soma precisa ser do tipo string para poder ser utilizado com o print dessa forma abaixo\n",
        "print('Resultado desejado: '+str(soma) )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "98XZdEe9lwmp"
      },
      "outputs": [],
      "source": [
        "#string\n",
        "meu_texto = input(\"Digite um texto : \")\n",
        "# Recebendo números\n",
        "numero_inteiro = int(input(\"Digite um numero inteiro qualquer : \"))\n",
        "numero_decimal = float(input(\"Digite um numero decimal qualquer : \"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DVYX6t8A7AIx"
      },
      "source": [
        "#trabalhando com strings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OhKYGDLc3BSN"
      },
      "outputs": [],
      "source": [
        "nome=input(\"Informe o seu nome : \")\n",
        "idade=int(input(\"Informe a sua idade : \"))\n",
        "print(\"Seu nome é : \"+nome+\"e  sua idade é  : \"+ str(idade) )\n",
        "\n",
        "#tambem podemos fazer algo como utilizar o upper para torna tudo maiusculo\n",
        "\n",
        "#utilizamos find pra encontrar a posiçao que aquela letra/char se encontra\n",
        "\n",
        "#abaixo vamos fazer um exercicio"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ioXqdyLmvdjN"
      },
      "outputs": [],
      "source": [
        "#Faça um programa que receba a idade do usuário e diga se ele é maior ou menor de idade.\n",
        "if(idade>=18):\n",
        "  print(nome+ \"é maior de idade \")\n",
        "else:\n",
        "  print(nome+\" é menor de idade\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fpfQUF-Q6I_4"
      },
      "outputs": [],
      "source": [
        "type(nome)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dXr1KlaT7y8f"
      },
      "outputs": [],
      "source": [
        "#alfa numerico\n",
        "'54A12B'.isalnum()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SXzt2gpLAdrr",
        "outputId": "f3ab7e90-0fb0-4d50-fa0c-4bf8ba5306b0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1940 A casa do penhasco\n"
          ]
        }
      ],
      "source": [
        "print(1940,\"A casa do penhasco\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yd86iEW0xZ0W"
      },
      "source": [
        "##Concatenando String"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k91Tczk5yLQK",
        "outputId": "f154ddde-8a33-4189-a930-da6097347b6b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Pam\n"
          ]
        }
      ],
      "source": [
        "name='sam'\n",
        "last_letters=name[1::]\n",
        "new_name='P'+last_letters\n",
        "print(new_name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sohdbq_g3OMz",
        "outputId": "3bacb867-0231-4abd-d882-6e76022e3e0b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Ola todos,nos da light academyEstamos convidando todos os novatos para o evento de sabado a noite\n",
            "as 18 horas\n",
            "Ola todos,nos da light academy\n",
            "Estamos convidando todos os novatos para o evento de sabado a noite\n"
          ]
        }
      ],
      "source": [
        "a=\"Ola todos,nos da light academy\"\n",
        "b=\"Estamos convidando todos os novatos para o evento de sabado a noite\"\n",
        "c=a + b +\"\\n\" #quebra de linha\n",
        "print(c+\"as 18 horas\")\n",
        "d=a+\"\\n\"+b #quebra de linha\n",
        "print(d)\n",
        "#com quebra de linha"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7zXtrU8w7HTU"
      },
      "outputs": [],
      "source": [
        "#index\n",
        "frase=\"Os gatos persa sao a raça mais popular entre as outras raças de gato\"\n",
        "\n",
        "print(frase[0])\n",
        "print(frase[1])#espaço\n",
        "print(frase[2])\n",
        "print(frase[3])\n",
        "print(frase[4])\n",
        "print(frase[5])\n",
        "print(frase[6])\n",
        "print(frase[7])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IrwS9rxf948p"
      },
      "outputs": [],
      "source": [
        "print(str(frase.upper()))#maiusculo\n",
        "print(str(frase.lower()))#minusculo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DlzHpe7y9f_P"
      },
      "outputs": [],
      "source": [
        "print(frase[0:])\n",
        "#retorna do inicio ate o final da frase\n",
        "\n",
        "print(frase.find('g'))\n",
        "#retorna a posiçao que é encontrado\n",
        "#caso nao seja encontrado retorna -1\n",
        "\n",
        "print(\"gatos\" in frase)\n",
        "#aqui rerificamos se esse \"algo\" esta sendo usando na frase"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ycpzu4TIwfvT",
        "outputId": "a8f35b85-c6c6-4849-b0a1-9136550b6ec8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ink\n"
          ]
        }
      ],
      "source": [
        "print('tinker'[1:4])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "UoMU8lAg63PZ",
        "outputId": "d12c87e9-6e5d-46d2-8f44-244025ab858a"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'abcdefghiklmno'"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_frase='abcdefghiklmno'\n",
        "my_frase[::]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "392aomqd7KtI",
        "outputId": "e1ef6245-2dd1-4fed-aeed-0018c358ffcb"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'o'"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_frase[::2]#pula 2 em 2\n",
        "my_frase[::-1]#inverte\n",
        "'Hello World'[7]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BaX6D664Ow_j"
      },
      "source": [
        "#Entrada de dados e Concatenando Strings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yUvWtHSvOv_m"
      },
      "outputs": [],
      "source": [
        "fruit=input(\"nome da fruta :\")\n",
        "index = 0\n",
        "while index < len(fruit):\n",
        " letter = fruit[index]\n",
        " print (letter)\n",
        " index = index + 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "R1s0L-wuO0Tv"
      },
      "outputs": [],
      "source": [
        "#alem disso podemos saber o tamanho desse string,qtd de letras\n",
        "print(len(fruit)) #banana=6\n",
        "#vem a ser util qunado desejamos limitar o numero de letras para ser utilizado pelo usuario\n",
        "#por ex em um formulario 50 letras pra um nome pode ser um absurdo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rpFXVPfA0A4Z",
        "outputId": "4f21da2f-1e94-44f0-8b2d-f2274106ef97"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "comida=\"banana\"\n",
        "comida.find(\"na\")\n",
        "#a posiçao que ele encontra o inicio do que esta sendo prourado"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eYUBF1hfGtlj"
      },
      "source": [
        "os comentarios podem ser feitos utilizando # no caso de uma unica linha e\n",
        "\"\"\"\n",
        "algo\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "13zvFHDrLp5I"
      },
      "outputs": [],
      "source": [
        "first_nm=input(\"o primeiro nome : \")\n",
        "last_nm=input(\"o sobrenome:\")\n",
        "msg= f'{first_nm}[ {last_nm} ]is a coder'\n",
        "print(msg)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4KXLQhDEl7QR"
      },
      "outputs": [],
      "source": [
        "insert=\"inserido aqui\"\n",
        "print(f'vamos colocar algo aqui {insert}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EmXSBFn2zucK"
      },
      "source": [
        "###Print Formatting with Strings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5lUVxZm9KEIV"
      },
      "outputs": [],
      "source": [
        "print('vamos colocar algo aqui {}'.format(\"INSERIDO AQUI\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k_8rcidmM_4W"
      },
      "outputs": [],
      "source": [
        "print(\"o {0} {2} {1}\".format('gato','correu','preto'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "spz7OKYlNfI2"
      },
      "outputs": [],
      "source": [
        "print(\"o {g} {p} {c}\".format(g='gato',c='correu',p='preto'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KN6a6XTT3Hky"
      },
      "outputs": [],
      "source": [
        "print('Python rules{}'.format('!'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yHEktsdh4Rdv"
      },
      "outputs": [],
      "source": [
        "planet = \"Earth\"\n",
        "diameter = 12742\n",
        "print(\"The diameter of {0}is {1} kilometer\".format(planet,diameter))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7-O31H1_OaA-"
      },
      "source": [
        "#como transforma um string em uma lista"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MVr4lxEPOrHJ",
        "outputId": "c8247b5e-7e60-47ff-f7a4-b2f4c260ce6e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['Geeks', 'for', 'Geeks']\n"
          ]
        }
      ],
      "source": [
        "#utilizaçao de funçao\n",
        "def Convert(string):\n",
        "    li = list(string.split(\" \"))\n",
        "    return li\n",
        "\n",
        "\n",
        "# Driver code\n",
        "str1 = \"Geeks for Geeks\"\n",
        "print(Convert(str1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6aDnTOhFzIW"
      },
      "source": [
        "#Operaçoes Matematicas em Python\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ifPTal_WJMfA"
      },
      "source": [
        "as regras que usamos na matematica,continuam aqui,\n",
        "entao as operaçoes contendo o parentese forçam ser feitos primeiro,a exponenciaçao vem antes da multiplicaçao e da divissao que vem antes da soma e da divisao\n",
        "outra coisa este tipo de operaçao é\n",
        "'2'-'1' 'eggs'/'easy' 'third'*'a charm'\n",
        "nao é permitido por serem strings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t-M0KxqgF06n",
        "outputId": "26fe4b83-d7e3-4f0b-eb10-1cc146a99a90"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8\n",
            "6\n"
          ]
        }
      ],
      "source": [
        "#exponenciaçao\n",
        "a=2**3\n",
        "#multiplicaçao\n",
        "b=2*3\n",
        "print(a)\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3eZaMHoa_Iyg",
        "outputId": "95e30734-be0c-431d-e5e8-a72367f5eeab"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "21.5\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "#esta divisao resulta  em um valor do tipo float\n",
        "c=43/2\n",
        "#esta divisao inteira(QUOCIENTE) que resulta em um valor do tipo  integer\n",
        "e=15//3\n",
        "print(c)\n",
        "print(e)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uz3xsPX-ximN",
        "outputId": "2c9edd49-7979-4509-95a6-511af1e37d11"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n"
          ]
        }
      ],
      "source": [
        "#modulo de um valor utilizado para receber o resto de uma operaçao matematica (RESTO)\n",
        "d=30%2\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mCMvWN8OQo6E",
        "outputId": "30c7a31b-eea7-40bd-8a62-cab6f21e163f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#valor absoluto em python\n",
        "abs(80-100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JTPeegcNhTio",
        "outputId": "359b046e-15c2-436d-d8b6-f4857927396a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4.0\n"
          ]
        }
      ],
      "source": [
        "import math\n",
        "#raiz\n",
        "print(math.sqrt(16))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NRKb3cvG2_2s"
      },
      "outputs": [],
      "source": [
        "#Escreva um programa que resolva uma equação de segundo grau.\n",
        "#nao sabemos o valor de x nem de delta\n",
        "A=int(input(\"Digite um numero inteiro  Para varial   A: \"))\n",
        "B=int(input(\"Digite um numero inteiro  Para variavel B: \"))\n",
        "C=int(input(\"Digite um numero inteiro  Para variavel C: \"))\n",
        "delta=(B*B) - (4*A*C)\n",
        "print(delta)\n",
        "x1=-(B-delta)/(2*A)\n",
        "x2=-(B+delta)/(2*A)\n",
        "print(\"o valor de   x1 é \"+str(x1)+\" o valor de x2 é \"+str(x2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 135
        },
        "id": "biyTsRl6zsrG",
        "outputId": "26e89539-1af0-46f3-b1ba-10741e7c6e4a"
      },
      "outputs": [
        {
          "ename": "SyntaxError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-10a3ca66d5d6>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    0=0.0\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to literal\n"
          ]
        }
      ],
      "source": [
        "0=0.0\n",
        "#encontrar o erro isso é uma atribuiçao"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rjtVw5rizoet",
        "outputId": "a0f77826-9ce4-45fe-842e-a028fb517236"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "0 == 0.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SAczWdV3uy0P"
      },
      "outputs": [],
      "source": [
        "#nesse problemas queremos saber quantos litros de agua vao ser carregadados por cada pessoa se\n",
        "#o caminhao com agua tem 320.5 litros de agua se temos 60 pessoas\n",
        "agua=320.5\n",
        "pessoas=60\n",
        "print(\"cada pessoa vai carregar a quantidade de \"+str(agua/pessoas)+\"de litros de agua\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7a0SvCqQ0Jvj",
        "outputId": "74d1774a-e8fe-456a-e93c-03a938651c0f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "9\n"
          ]
        }
      ],
      "source": [
        "#Temos tambem o pow,max,min,abs entre outros\n",
        "#potencia\n",
        "elevar=pow(3,2)# 3^2 = 9\n",
        "print(elevar)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZH_nMhZyQniM",
        "outputId": "9423fb0b-b8a2-4a65-95fd-b92563caff76"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2401"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "pow(7,4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nczSi1Lq1WZU"
      },
      "outputs": [],
      "source": [
        "#maximo e minimo entre valores\n",
        "maior_entre=max(4,6)#o maior entre os valores 4< 6 =6\n",
        "menor_entre=min(2,7)#o menor entre os dois valores 2<7 =2\n",
        "print(maior_entre)\n",
        "print(menor_entre)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xp7lp-HD1cmW"
      },
      "outputs": [],
      "source": [
        "#arrendodamento  pra baixo ou pra cima\n",
        "arrendodado_cima=round(3.7)\n",
        "arredondado_baixo=round(3.2)\n",
        "print(arrendodado_cima)\n",
        "print(arredondado_baixo)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K7NQbyz7JhLC"
      },
      "outputs": [],
      "source": [
        "import decimal\n",
        "d=decimal.Decimal(\"39.54484700000000\")\n",
        "round(d,2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5Nh9A8x3-8xq"
      },
      "outputs": [],
      "source": [
        "#vamos ver um pouco mais sobre operaçoes abaixo\n",
        "\n",
        "x=3#atribuiçao\n",
        "y= x + 3\n",
        "print(\"o valor de y é:\"+str(y))#3+3=6\n",
        "\n",
        "y+= 3\n",
        "print(\"o valor de y + 3 é igual a :\"+str(y))#6+3=9\n",
        "\n",
        "y-= 4\n",
        "print(\"o valor de y - 4 é igual a :\"+str(y))#9-4=5\n",
        "\n",
        "y*=2\n",
        "print(\"o valor de y vezes 2 é igual a :\"+str(y))#5*2=10\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4LLYJLFELiDc",
        "outputId": "f4596eed-b851-46f6-c226-b696497a2db9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Digite um numero inteiro : 5\n",
            "Digite outro numero inteiro: 2\n",
            "Soma: {} /n Subtraçao: {} /ndivisao: {}/n multiplicaçao: 7;\n"
          ]
        }
      ],
      "source": [
        "#alem disso podemos print dessa outra forma as seguintes operaçoes\n",
        "\n",
        "\n",
        "value_1=int(input(\"Digite um numero inteiro : \"))\n",
        "value_2=int(input(\"Digite outro numero inteiro: \"))\n",
        "somar= value_1 + value_2\n",
        "\n",
        "subtrair = value_1 - value_2\n",
        "\n",
        "dividir=value_1/value_2\n",
        "multiplicar=value_1*value_2\n",
        "\n",
        "resto=value_1%value_2\n",
        "print('Soma: {}  Subtraçao: {}  divisao: {}  multiplicaçao: {};'.format(somar,subtrair,dividir,multiplicar))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AyBoilALh45h",
        "outputId": "22ca366d-e45a-4034-b56a-3bd4c83a634f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "o resultado é 0.1287\n"
          ]
        }
      ],
      "source": [
        "result=100/777\n",
        "print(\"o resultado é {r:1.4f}\".format(r=result))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TRd1K0-F6n47"
      },
      "source": [
        "##Conversão de valores  numericos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h_REiOkI6y8a",
        "outputId": "3f54020c-268c-4d59-c274-70b108f599d8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "9.0"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "float(9)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wyci6w1l6ysN",
        "outputId": "e96d3506-f1a8-48bc-8cc5-e411fc8eefd1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "int(6.0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zMooPScF64EC",
        "outputId": "e38110f4-4d74-45b7-ed5a-728d3a8562f6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "int(6.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Ldr6G3sCIZ2"
      },
      "source": [
        "#Operador logico e relacional\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "#####Operador relacional\n",
        "######== se iquais\n",
        "######!= se diferentes\n",
        "######<  menor,> maior ,<=  menor iqual,>= maior iqual\n",
        "---\n",
        "Operador logico\n",
        "\n",
        "o operador OR espera que pelo menos uma das condiçoes seja verdadeira\n",
        "\n",
        "o operador AND espera que as duas das condiçoes sejam verdadeiras\n",
        "\n",
        "o operador NOT inverte o valor/resultado\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GJWJQqFewzJ1",
        "outputId": "079b654e-8c1c-4530-de3f-45053ee73c3f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Informe a primeira atividade avaliativa do aluno/a :-1\n",
            "Informe a segunda atividade avaliativa do aluno/a :1\n",
            "valor inadequado\n"
          ]
        }
      ],
      "source": [
        "#atividade\n",
        "#Faça um programa que receba duas notas digitadas pelo usuário.\n",
        "# Se a nota for maior ou igual a seis, escreva aprovado, senão escreva reprovado.\n",
        "QG_1=int(input(\"Informe a primeira atividade avaliativa do aluno/a :\"))\n",
        "QG_2=int(input(\"Informe a segunda atividade avaliativa do aluno/a :\"))\n",
        "if((QG_1>10 or QG_1<0) or (QG_2>10 or QG_2<0)):\n",
        "  print(\"valor inadequado\")\n",
        "else:\n",
        "  media= (QG_1+QG_2)/2\n",
        "  if(media>=6):\n",
        "    print(\"aluno aprovado \")\n",
        "  else:\n",
        "    print(\"aluno reprovador\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mBneNRRcBwkW"
      },
      "outputs": [],
      "source": [
        "# AND\n",
        "var1=4\n",
        "var2=3\n",
        "var3=6\n",
        "soma=var1+var3 #10   10>7 10>9\n",
        "soma2=var1+var2#7    7<10 7<9\n",
        "soma3=var2+var3#9    9>7 9<10\n",
        "print(soma>soma2 and soma>soma3) #ambas afirmaçoes sao verdadeiras\n",
        "print(soma<soma2 and soma>soma3) #ambas afirmaçoes nao sao verdadeiras ,a primeira condiçao é falsa"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3_aU58E_3omI"
      },
      "outputs": [],
      "source": [
        "#OR\n",
        "\n",
        "print(soma>soma2 or soma>soma3) #ambas afirmaçoes sao verdadeiras,o or retorna  TRUE que pelo menos 1 seja verdadeira\n",
        "print(soma<soma2 or soma>soma3) #ambas afirmaçoes nao sao verdadeiras,mas o or retorna true com uma condiçao verdadeira"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a2C_bGxe5k01"
      },
      "source": [
        "#Condicional\n",
        "#####o python tem o if ,elif e o else\n",
        "#####caso note que sera utilizado muitos elif pense em utilizar o CASE ou o switch\n",
        "#####if == se\n",
        "#####elif ou else if == se nao\n",
        "######TENHA CUIDADO COM A INDENTAÇAO"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zL3e4iFZzpU4"
      },
      "outputs": [],
      "source": [
        "#if e elif\n",
        "cinco=5\n",
        "if cinco<10:\n",
        "  print('o valor é inferior a 10 ')\n",
        "elif cinco>20:\n",
        "  print('o valor é superior a 20 ');\n",
        "  #normalmente temos o\n",
        "  #if condiçao :\n",
        "  ####um tab ou 4 espaços entao  linha/ou bloco q acontece se cumprir a condiçao\n",
        "  ####a tecla TAB fica mais a esquerda do teclado proxima do \" ' e do Q (normalmente)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2VFbOM2H1NXu"
      },
      "outputs": [],
      "source": [
        "temperatura=25\n",
        "if temperatura>35:\n",
        "    print(\"é um dia escandalte\")\n",
        "elif temperatura>=30:\n",
        "  print(\"é um dia comum\")\n",
        "elif temperatura>20:\n",
        "  print(\"é um dia ameno\")\n",
        "elif temperatura>10:\n",
        "  print(\"é um dia congelante\")\n",
        "else:\n",
        "  print(\"é um dia severo\")\n",
        "##aqui temos o fim de um bloco\n",
        "print('done')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "F5gQwOrnqS0B"
      },
      "outputs": [],
      "source": [
        "#vamos para outro exemplo que vamos ver como a indentaçao é importante\n",
        "var1=4\n",
        "var3=6\n",
        "##precisa executar alguns celulas acima pra poder ter o valor ve var1 e var3\n",
        "if var3>var1:                                                                   #linha 1\n",
        "  if var3>0:                                                                    #linha 2 aqui temos um tab em relaçao ao 1 if\n",
        "    print(\"a variavel var3 é positiva e ela é maior do que a variavel var1\")    #liha  3 aqui temos 2 tabs em relaçao ao 1 if\n",
        "  else:                                                                         #linha 4 aqui temos 2 tabs, esta alinhado com relaçao ao segundo if\n",
        "    print(\"a variavel var3 nao é positiva e nao é maior do que a variavel var1\")#linha 5 aqui temos 2 tabs\n",
        "else:                                                                           #linha 6\n",
        "  print(\"a variavel var 3 é menor que a variavel var1\")                         #linha 7 aqui temos um tab e esta alinhado ao primeiro if"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TsKUAvTG6HOW",
        "outputId": "b341c47d-1250-4113-b01f-d444bebc398d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "24\n",
            "Not Weird\n"
          ]
        }
      ],
      "source": [
        "import math\n",
        "import os\n",
        "import random\n",
        "import re\n",
        "import sys\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    n = int(input().strip())\n",
        "if(n>1or n<=100):\n",
        "    if(n%2==0):\n",
        "\n",
        "        if(n>20):\n",
        "            print(\"Not Weird\")\n",
        "        elif(n<=2 or n<=5):\n",
        "            print(\"Not Weird\")\n",
        "        else:\n",
        "            print(\"Weird\")\n",
        "    else:\n",
        "        print(\"Weird\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wxi8abxN7iWL",
        "outputId": "389967a2-6c65-46f6-8a87-b3094c8fc533"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "informe a sua açao\n",
            " ex :comendo,dormindo,correndo,falando\n",
            " ex2 :viajando,caminhando,lendo,rindo,escutando musica\n",
            "escutando\n",
            "voce esta sendo feliz\n"
          ]
        }
      ],
      "source": [
        "#insira uma frase e assim podemos avaliar como voce esta agindo\n",
        "if __name__ == '__main__':\n",
        "    action= str(input(\"informe a sua açao\\n ex :comendo,dormindo,correndo,falando\\n ex2 :viajando,caminhando,lendo,rindo,escutando musica\\n\"))\n",
        "action.lower()\n",
        "if (action==\"viajando\"or  (\"dormindo\" in action)):\n",
        "  print(\"descansando~\")\n",
        "elif((\"caminhando\" in action)or (\"correndo\" in action)):\n",
        "    print(\"mexendo o corpo\")\n",
        "\n",
        "elif((\"lendo\" in action)or action==\"rindo\"or (\"escutando\" in action)):\n",
        "    print(\"voce esta sendo feliz\")\n",
        "else:\n",
        "  print(\"voce esta \"+action+\",\\nvivendo a vida como pode\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AqEeVDB0vYp6"
      },
      "outputs": [],
      "source": [
        "#CONVENSAO DE VALORES NO FORMATO DE  PESO\n",
        "Weight=input('informe o peso : ')\n",
        "unit=input('utilizar grams (K)g ou pounds (L)bs:')\n",
        "if unit.upper()==\"L\":\n",
        "  form=int(Weight)*0.45\n",
        "  print(\"o valor em Kg é\"+str(form))\n",
        "elif unit.upper()==\"K\":\n",
        "  form=int(Weight)/0.45\n",
        "  print(\"o valor em Lbs/pounds é :\"+str(form))\n",
        "else:\n",
        "  print(\"esta errada o tipo da medida escolhida\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GNYuZNF2msB3"
      },
      "outputs": [],
      "source": [
        "#https://learn.microsoft.com/pt-br/office/troubleshoot/excel/determine-a-leap-year\n",
        "def é_bissexto(year):\n",
        "    leap = False\n",
        "    if(year%4==0):\n",
        "        leap=True\n",
        "        if(year%100==0):\n",
        "            if(year%400==0):\n",
        "                leap=True\n",
        "            else:\n",
        "                leap=False\n",
        "    return leap\n",
        "\n",
        "year = int(input())\n",
        "print(is_leap(year))\n",
        "#esse o ano é bissexto"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##numeros interios ou float"
      ],
      "metadata": {
        "id": "H58t1a6Vumv_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "numero =input(\"infome um numero qualquer\")\n",
        "divisor= input(\"informe um valor para dividir o numero qualquer que voce informou\")\n",
        "\n",
        "if numero%divisor==0 :\n",
        "    print(\"Este número: \" + str(numero) + \" é divisível por \" + str(divisor))\n",
        "else :\n",
        "     print(\"este numero: \" + str(numero) + \" não divisivel por \" + str(divisor))\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 245
        },
        "id": "csMaEnRMuy7i",
        "outputId": "8e5a0bdb-1175-46c5-8f57-b92ab0c14349"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "infome um numero qualquer30\n",
            "informe um valor para dividir o numero qualquer que voce informou3\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "not all arguments converted during string formatting",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-414d8d89e0c1>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mdivisor\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"informe um valor para dividir o numero qualquer que voce informou\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mnumero\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0mdivisor\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m0\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Este número: \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumero\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" é divisível por \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdivisor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: not all arguments converted during string formatting"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fa-Pf1uN6UWo"
      },
      "source": [
        "#loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bHrRC3yS5xQs"
      },
      "outputs": [],
      "source": [
        "#For loops give you more control than\n",
        "#while loops. You can loop through anything\n",
        "#that is iterable. e.g. a range, a list, a dictionary\n",
        "#or tuple."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_QDxZ8gkzpOR"
      },
      "outputs": [],
      "source": [
        "i=1\n",
        "while i<=5:\n",
        "  print(i)\n",
        "  i=i+1\n",
        "print('crescente')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YbEqRhXHzpRx"
      },
      "outputs": [],
      "source": [
        "#repeated\n",
        "n=5\n",
        "while n>0:\n",
        "  print(n)\n",
        "  n=n-1\n",
        "print('decrescente')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "60LatfIi0eRC",
        "outputId": "a169f3e3-0561-4326-d007-b61cd54c5157"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Digite o ultimo numero a imprimir5\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "numerofinal=int(input(\"Digite o ultimo numero a imprimir: \"))\n",
        "x=1\n",
        "while x<= numerofinal:\n",
        "  print(x)\n",
        "  x=x+1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2iZ4mC_RzpLN"
      },
      "outputs": [],
      "source": [
        "i=1\n",
        "while i<=5:\n",
        "  print(i*'*')\n",
        "  i+=1\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iDaHjL3fUKTm",
        "outputId": "f00577b2-8529-4e88-cfe9-6eb503660806"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Current Letter : P\n",
            "Current Letter : y\n",
            "Current Letter : t\n"
          ]
        }
      ],
      "source": [
        "\n",
        "for letter in 'Python':     # First Example\n",
        "   if letter == 'h':\n",
        "    break\n",
        "   print ('Current Letter :', letter)\n",
        "\n",
        "   #devemos estudar mais depois como utilizar o break ele pode ser interessante mais tarde\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6QbZz6W6aZo"
      },
      "source": [
        "##acumuladores\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "98U6VcdT6fmN",
        "outputId": "24efecf4-5794-4b2b-9953-2163c07f8090"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Digite o 1º número: 3\n",
            "Soma: 3\n",
            "Digite o 2º número: 2\n",
            "Soma: 5\n",
            "Digite o 3º número: 1\n",
            "Soma: 6\n",
            "Digite o 4º número: 4\n",
            "Soma: 10\n",
            "Digite o 5º número: 5\n",
            "Soma: 15\n",
            "Digite o 6º número: 4\n",
            "Soma: 19\n",
            "Digite o 7º número: 3\n",
            "Soma: 22\n",
            "Digite o 8º número: 2\n",
            "Soma: 24\n",
            "Digite o 9º número: 1\n",
            "Soma: 25\n",
            "Digite o 10º número: 1\n",
            "Soma: 26\n",
            "media: 2.6\n"
          ]
        }
      ],
      "source": [
        "#spma de 10 numeros\n",
        "n=1\n",
        "soma=0\n",
        "while n<= 10:\n",
        "  x = int(input(\"Digite o %dº número: \" % n))\n",
        "  soma = soma+x\n",
        "  n=n+1\n",
        "  print(\"Soma: %d\"%soma)\n",
        "media=soma/10\n",
        "print(\"media:\",media)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kidSuDnz88dm"
      },
      "source": [
        "##interropendo um looping"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 356
        },
        "id": "Jyeqtj9884EV",
        "outputId": "03780809-56ba-4f33-89e0-f0cada40e6ae"
      },
      "outputs": [
        {
          "ename": "KeyboardInterrupt",
          "evalue": "Interrupted by user",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-67fbdb33e190>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Digite o %dº número (ou 0 para interromper): \"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Interrupção do loop solicitada.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m    849\u001b[0m                 \u001b[0;34m\"raw_input was called, but this frontend does not support input requests.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    850\u001b[0m             )\n\u001b[0;32m--> 851\u001b[0;31m         return self._input_request(str(prompt),\n\u001b[0m\u001b[1;32m    852\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    853\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    893\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    894\u001b[0m                 \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 895\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Interrupted by user\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    896\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    897\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid Message:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexc_info\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
          ]
        }
      ],
      "source": [
        "soma = 0\n",
        "n = 1\n",
        "\n",
        "while True:\n",
        "    x = int(input(\"Digite o %dº número (ou 0 para interromper): \" % n))\n",
        "    if x == 0:\n",
        "        print(\"Interrupção do loop solicitada.\")\n",
        "        break\n",
        "    soma += x\n",
        "    n += 1\n",
        "\n",
        "print(\"A soma é:\", soma)\n",
        "print(\"Quantidade de numeros digitados\",n)\n",
        "media =soma/(n-1)\n",
        "print(\"media ariticetica\",media)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "glrT3AdzHMbX"
      },
      "source": [
        "###For e lista"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yjd6aM5JhsRZ",
        "outputId": "db9826b8-d6e4-45ba-af91-169b076f4a61"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "1234\n"
          ]
        }
      ],
      "source": [
        "#dado um valor informado\n",
        "#devolvemos uma string com os numero 1 ate o valor informado\n",
        "if __name__ == '__main__':\n",
        "    n = int(input())\n",
        "    string=''\n",
        "    for i in range(1,n,1):\n",
        "        string =str(i)+string\n",
        "print(string[::-1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o8Se0765E93n",
        "outputId": "6ea9b4ae-1f7d-48dc-e347-bf499f5e4606"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "0\n",
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ]
        }
      ],
      "source": [
        "#se n maior que zero e menor ou igual a 20\n",
        "#iremos fazer esse valor n vezes ele mesmo\n",
        "#ate chegar (n-1)*(n-1)\n",
        "if __name__ == '__main__':\n",
        "    n = int(input())\n",
        "    if(n>=1 and n<=20):\n",
        "      for x in range(n):\n",
        "       if(x<n):\n",
        "            print(x*x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fbp-cNyCzpEg",
        "outputId": "3d20fb5f-7ae6-4476-ebe2-ab302af2f309"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "8\n",
            "3\n",
            "4\n",
            "end\n"
          ]
        }
      ],
      "source": [
        "#aqui temos uma lista feita por numeros inteiros\n",
        "#que o usuario vai visualizar numero apos numero um abaixo do outro ate chegar ao final\n",
        "#quando chegar ao final ele deve visualizar a palavra 'end'\n",
        "lista_int=[5,8,3,4]\n",
        "for i in lista_int:\n",
        "  print(i)\n",
        "print(\"end\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xTLEyjpjbFjZ",
        "outputId": "560801fd-9dd8-46eb-97c4-6e6f3004a1bf"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "lista_int.index(8)\n",
        "#retorna a posiçao do numero caso ele seja encontrado"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        },
        "id": "L5ZX1y94bvGd",
        "outputId": "0fd35d13-0d7b-4cfe-802f-c1f0f2658a93"
      },
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "name 'lista_int' is not defined",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-9-cbf7998ae9f8>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlista_int\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mlista_int\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'lista_int' is not defined"
          ]
        }
      ],
      "source": [
        "lista_int[-1]\n",
        "lista_int[-2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SWQSxl-QjKRn",
        "outputId": "23d6890a-d176-4b37-885c-7e694bb3c500"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "#lembrar de ter cuidado quando utilizar o range com lista\n",
        "for x in range(5):\n",
        "  print(x)\n",
        "  #podemos assim saber em que valor estamos /percorrendo\n",
        "  #de 0 ate 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dBk-87CQjlZc",
        "outputId": "74b821c8-0d56-496f-e7a1-28719f91fa59"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ]
        }
      ],
      "source": [
        "for x in range(5,10):\n",
        "  print(x)\n",
        "  #podemos assim saber em que valor estamos /percorrendo\n",
        "  #agora iniciamos do 5 e vamos ate o 9"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9f4xjCAbVueD"
      },
      "outputs": [],
      "source": [
        "for i in range(5,20,2):\n",
        "#de 5 ate 19 de 2 em 2\n",
        " print(i)\n",
        " #pula de 2 em 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OwqOkMyQ_EZB"
      },
      "outputs": [],
      "source": [
        "#coordenadas\n",
        "for x in range(4):  #outer loop 0 ate 3\n",
        "  for y in range(3):  ##inner loop\n",
        "    print(f'{x},{y}')\n",
        "    #(x,y) plano cartesiano\n",
        "    #https://youtu.be/_uQrJ0TkZlc?t=6610"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OiZPxtwzaPKI"
      },
      "outputs": [],
      "source": [
        "#coordenadas\n",
        "#https://youtu.be/_uQrJ0TkZlc?t=6549\n",
        "#https://youtu.be/kqtD5dpn9C8?t=2714"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_o7QrYMca4wp"
      },
      "outputs": [],
      "source": [
        "lista_int.pop()#tira o ultimo elemento da lista\n",
        "print(lista_int)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BDDnKi_3GdcG",
        "outputId": "bb9c4f6c-778c-4f32-bfb3-00d0016709b8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "34\n"
          ]
        }
      ],
      "source": [
        "scores = [34, 67, 99, 105]\n",
        "for s in scores:\n",
        " if s > 100:\n",
        "   print(\"Invalid\")\n",
        " break\n",
        "print(s)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V3urVffsJ3p6",
        "outputId": "f3deff02-6a53-4716-9434-d2f4061b61c3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2, 4, 6, 8, 10]\n"
          ]
        }
      ],
      "source": [
        "#aqui temos uma lista de numeros\n",
        "#e queremos apenas os numeros pares\n",
        "x = [1, 2, 3,4,5,6,7,8,9,10]\n",
        "\n",
        "#solution :\n",
        "y = [ i for i in x if i % 2 == 0]\n",
        "\n",
        "print(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4HiPBCcxMwaP",
        "outputId": "d2faf2e3-f1ab-4170-d86a-bc307a9031c7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n"
          ]
        }
      ],
      "source": [
        "#Aqui temos outra possivel soluçao para termos o retorno do valores pares\n",
        "for i in x:\n",
        "  if(i%2==0):\n",
        "    print(i)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xoc6oDQGJ7TM",
        "outputId": "46647136-dbce-4db1-b446-a98c8223016b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0, 1, 2]\n"
          ]
        }
      ],
      "source": [
        "x = [1, 2, 3]\n",
        "y = [variable-1 for variable in x]\n",
        "print(y)\n",
        "#variable e nosso elemento em cada index\n",
        "#logo nossas variaveis sao 1 2 3\n",
        "#se fosse varible +1 la no vetor y\n",
        "#print(y) seria 2,3,4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H_vUxtuJUFD1",
        "outputId": "e2cb3f6b-5627-49e6-b019-f2c6df14c751"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "for var in range(5):\n",
        " print (var)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gvV3S0zWU7WV",
        "outputId": "ba11cd49-dd38-4992-abe4-8bf4187c1fef"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ]
        }
      ],
      "source": [
        "for var in range(2,11):\n",
        " print(var)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EIyZ9J7JVGoI",
        "outputId": "8144df33-cfcd-4651-8d3a-a3df73d20ca5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n",
            "5\n",
            "10\n",
            "15\n",
            "20\n",
            "25\n"
          ]
        }
      ],
      "source": [
        "for var in range (0,30,5):\n",
        "   print(var)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yhyxMGs0aiPv",
        "outputId": "42129596-f79e-41ca-bc5f-f8abf97233df"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "informe a sua nota 1?6\n",
            "informe a sua nota 2?8\n",
            "informe a sua nota 3?5\n",
            "19.0\n",
            "6.333333333333333\n"
          ]
        }
      ],
      "source": [
        "soma=0\n",
        "for var in range(1,4):\n",
        "  nota=float(input(\"informe a sua nota \"+str(var)+\"?\"))\n",
        "  soma=soma+nota\n",
        "result = soma/var\n",
        "\n",
        "print(soma)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YliaUGjGHm4s"
      },
      "source": [
        "#Listas\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6XguC_srxZ5L"
      },
      "outputs": [],
      "source": [
        "#uma lista pode ter diversos tipos de dados\n",
        "#podendo ser float,boolean,string\n",
        "#podemos criar uma lista de listas"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AQZZ7yfCwmUa",
        "outputId": "05389cb7-cb6f-4496-9fab-3f8aeb78cd0d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['luis', 'pedro', 'lucas', 'fernando']\n"
          ]
        }
      ],
      "source": [
        "nome='luis'\n",
        "nome1='pedro'\n",
        "nome2='lucas'\n",
        "nomes=[nome,nome1,nome2]\n",
        "nomes.append(\"fernando\")\n",
        "print(nomes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WqUgKP4uxOR3",
        "outputId": "cb1f3e2f-a860-48c3-c0c8-7274a1dab246"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['luis', 'pedro']\n"
          ]
        }
      ],
      "source": [
        "#index do elemento\n",
        "nomes.pop(2)\n",
        "print(nomes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Wqbq_Ay5soF",
        "outputId": "57cc355b-a87a-45fa-d38a-7ff5dc511049"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['lucas', 2, 4, 9, 2, 'pedrita']\n"
          ]
        }
      ],
      "source": [
        "#o remove so retira o elemento q ele encontrar igual\n",
        "#ele retira o primeiro elemento q ele encontrar igual\n",
        "lista=['lucas',2,4,6,9,2]\n",
        "lista.append(\"pedrita\")\n",
        "lista.remove(6)\n",
        "print(lista)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QSWJg23p7EjL",
        "outputId": "f45c6bf3-a37c-4cf6-fe02-6fa9ba3cb764"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 40,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "lista.index(4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ShgWW7CB6cS-",
        "outputId": "5e6cb56c-e7ef-4b54-a5f4-8ca2f3e01ead"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#count retona a quantidade q aquele elemtno se repete\n",
        "lista.count(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sAtPfrvL6t9F",
        "outputId": "9171f07f-4fdf-4ef4-ddd7-ee9ff2c492a1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7]\n",
            "28\n"
          ]
        }
      ],
      "source": [
        "num=[1,2,7,3,4,0,5,6]\n",
        "num.sort()\n",
        "#o sort so é possivel com elementos do mesmo tipo\n",
        "print(num)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XROilixm7ib7"
      },
      "outputs": [],
      "source": [
        "#soma de todos os valores da lista\n",
        "print(sum(num))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jyysbev6IpuY",
        "outputId": "f0914f64-fe03-47b4-bd1d-8a6304e275b6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "xxxxx\n",
            "xx\n",
            "xxxxx\n",
            "xx\n",
            "xx\n",
            "xxxxx\n"
          ]
        }
      ],
      "source": [
        "numeros=[5,2,5,2,2,5]\n",
        "index=0\n",
        "while index < len(numeros):\n",
        " letter = numeros[index]\n",
        " print (letter*'x')\n",
        " index = index + 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y1kek6cFfhR6",
        "outputId": "d88bb09d-264a-4547-c3fb-c3b7e15aa286"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['vila', 'pizzaria', 'padaria', 'casa', 'trabalho', 'praia', 'estudo', 'cidade', 'fazenda']\n",
            "['casa', 'cidade', 'estudo', 'fazenda', 'padaria', 'pizzaria', 'praia', 'trabalho', 'vila']\n",
            "['vila']\n"
          ]
        }
      ],
      "source": [
        "list_string=[\"vila\",\"pizzaria\",\"padaria\",\"casa\",\"trabalho\",\"praia\",\"estudo\",\"cidade\",\"fazenda\"]\n",
        "print(list_string)\n",
        "\n",
        "list_string.sort()\n",
        "print(list_string)\n",
        "\n",
        "del list_string[:-1]#List Slicing\n",
        "print(list_string)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "96dyzSL6f0SN",
        "outputId": "b63bb4d2-7fad-4c52-fc0f-c759a0d8a9b8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['casa', 1, 1.9, 'lua']\n"
          ]
        }
      ],
      "source": [
        "coisa_list=[\"casa\",1,1.9,'lua']\n",
        "print(coisa_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TYmb4P52iuMY"
      },
      "outputs": [],
      "source": [
        "coisa_list.insert(3, \"mar\")#aqui passamos o index e o elemento\n",
        "print(coisa_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_wiZgxypDWpU"
      },
      "outputs": [],
      "source": [
        "coisa_list.append(\"vida\")\n",
        "print(coisa_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KXJOK5bUsWlF"
      },
      "outputs": [],
      "source": [
        "lista=[5,8,9,11,40,22,21,33,10,1,0,2,90,10,2,190]\n",
        "lista.reverse()\n",
        "\n",
        "print(lista)\n",
        "\n",
        "lista=sorted(lista)\n",
        "print(lista)\n",
        "\n",
        "lista.sort(reverse=True)\n",
        "print(lista)\n",
        "\n",
        "lista.pop()#Removes and returns last object or obj from list\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CDwfqjwlDkgO"
      },
      "outputs": [],
      "source": [
        "set(lista)#os valores aqui nao existem sendo repetidos;/sao unicos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NCdZA4sZ17LQ"
      },
      "outputs": [],
      "source": [
        "#escreva um programa que ordene uma lista numérica com três elementos.\n",
        "lista=[6,2,1]\n",
        "lista=sorted(lista)\n",
        "print(lista)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mXJBRhKKSz__",
        "outputId": "1f287ee9-0bfa-423b-d510-7f4273301031"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[5, [20, 40, ['Destino']], 90, 22, 1010]\n",
            "[20, 40, ['Destino']]\n",
            "['Destino']\n"
          ]
        }
      ],
      "source": [
        "#como coletar algo desejado dentro de uma lista\n",
        "lst = [1,2,[3,4],[5,[20,40,['Destino']],90,122,1010],2,4,7]\n",
        "\n",
        "segunda_lista=lst[3]\n",
        "\n",
        "print(segunda_lista)\n",
        "terceira_lista=segunda_lista[1]\n",
        "\n",
        "print(terceira_lista)\n",
        "palavra_desejada=terceira_lista[2]\n",
        "\n",
        "print(palavra_desejada)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x_GSPOgpd9VY",
        "outputId": "5fd008c9-790f-4b55-cafe-bb1e17b8286d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[['açucar', 'fermento']]\n"
          ]
        }
      ],
      "source": [
        "#aqui como a lista dentro da lista bolo\n",
        "bolo = ['farinha de trigo', 'ovo', 'leite', 'manteiga']\n",
        "bolo.append(['açucar', 'fermento'])##melhor pra desempenho por adicionar sempre ao final da lista\n",
        "print(bolo[4:])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XSSKIIHxdkL5",
        "outputId": "28422e3e-b87a-4217-b519-269dc6be60f2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['farinha de trigo', 'ovo', 'leite', 'manteiga', 'açucar', 'fermento']\n"
          ]
        }
      ],
      "source": [
        "##aqui como elemento da lista\n",
        "bolo = ['farinha de trigo', 'ovo', 'leite', 'manteiga']\n",
        "bolo.extend(['açucar', 'fermento'])\n",
        "print(bolo)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I-4yn9KKDJo1",
        "outputId": "e7867793-9038-4c86-e0b0-35e42c18a7cd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "esta e a minha lista normal[2, 4, 6, 8, 1]\n",
            "esta é minha lista[6, 20, 42, 72, 2]\n"
          ]
        }
      ],
      "source": [
        "#list comprehension\n",
        "#uma outa forma de fazer uma operaçao sobre de uma forma mais abstrata\n",
        "\n",
        "num_normal=[2,4,6,8,1]\n",
        "num_multi=[i*(i+1) for i  in  num_normal]\n",
        "print(\"esta e a minha lista normal\"+str(num_normal))\n",
        "\n",
        "#[2*(2+1) , 4*(4+1) , 6*(6+1) ,8*(8+1) + 1*(1+1)]\n",
        "\n",
        "print(\"esta é minha lista\"+str(num_multi))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qsV6B2OLe220"
      },
      "source": [
        "##lista e string"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zGABOpxve15l",
        "outputId": "598b6ef4-5d06-4d17-d4f5-afc7161d4d78"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['S', 'o', ' ', 'm', 'u', 'c', 'h', ' ', 'd', 'r', 'a', 'm', 'a', ' ', '.']\n",
            "So much drama .\n"
          ]
        }
      ],
      "source": [
        "# Converte uma string em uma lista.\n",
        "s = list(\"So much drama .\")\n",
        "print(s)\n",
        "\n",
        "# Converte uma lista em uma string.\n",
        "l = [ \"S\",\"o\",\" \",\"m\",\"u\",\"c\",\"h\",\" \", \"d\",\"r\",\"a\",\"m\",\"a\",\" \",\".\"]\n",
        "print(''.join(l))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cZaWQnDDvL2W",
        "outputId": "18539e72-9f0e-49e2-fdf6-6c76ea4d9424"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4\n",
            "123\n"
          ]
        }
      ],
      "source": [
        "#aqui temos uma funçao na qual recebemos um valor qualquer e printamos do valor 1 ate o valor qualquer\n",
        "if __name__ == '__main__':\n",
        "    n = int(input())\n",
        "    lista=[]\n",
        "    for x in range(n):\n",
        "        lista.append(str(x))\n",
        "        cao= ''.join(lista)\n",
        "    print(cao[1::])\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "590vNnavPVcr"
      },
      "source": [
        "enumerate"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gLiQ-iiqPUgI"
      },
      "outputs": [],
      "source": [
        "#a funçao enumerate serve para coloca a lista na ordem crescente\n",
        "list_string=[\"vila\",\"pizzaria\",\"padaria\",\"casa\",\"trabalho\",\"praia\",\"estudo\",\"cidade\",\"fazenda\"]\n",
        "\n",
        "for i, word in enumerate(list_string):\n",
        "    print(i, word)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ciSPItRFnSmr",
        "outputId": "8b26b0e8-2ba3-40ef-8a05-2665291d926e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'nest_key': ['dentro da nest key', ['o fundo']]}\n"
          ]
        }
      ],
      "source": [
        "complicado = {'k1':[{'nest_key':['dentro da nest key',['o fundo']]}]}\n",
        "#pegue o fundo\n",
        "\n",
        "print(complicado[\"k1\"][0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s0b6x1-XRSa9"
      },
      "source": [
        "#FIFO (First In, First Out) FALTA\n",
        "####não necessamente é uma lista\n",
        "\n",
        "\n",
        "FALTAAA"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# https://www.otaviomiranda.com.br/2020/filas-em-python-com-deque-queue/\n",
        "#https://www.oreilly.com/library/view/python-cookbook/0596001673/ch17s15.html\n",
        "# https://medium.com/@khasnobis.sanjit890/linear-data-structure-queue-in-python-fifo-first-in-first-out-bbd03f6b3b0f\n",
        "#https://www.simplilearn.com/tutorials/python-tutorial/queue-in-python#:~:text=Python%20list%20is%20used%20as,to%20maintain%20the%20FIFO%20manner."
      ],
      "metadata": {
        "id": "FOOPAX0gaaTK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lV2q8JsHkwhk"
      },
      "source": [
        "\n",
        "\n",
        "#Dictionaries in Python\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "#####desordenado,cam not be sorted\n",
        "#####Dictionaries objects retrieved by key name\n",
        "#####sao mutaveis\n",
        "#####Dictionaries retain order and are a sequence - é uma afirmaçao falsa (incorreta)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5NlAOOkoVlQi"
      },
      "outputs": [],
      "source": [
        "#del dictionarie ;        # delete entire dictionary\n",
        "#dict.clear();     # remove all entries in dict\n",
        "#Keys must be immutable. Which means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed. Following is a simple example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yjFyasJBepOp"
      },
      "outputs": [],
      "source": [
        "my_dict={\"comida\" : \"pizza\",\"bebida\" : \"cha mate\"}\n",
        "my_dict #pode ser usado para print"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7K0o88Pui_39"
      },
      "outputs": [],
      "source": [
        "print(my_dict[\"comida\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tGTWll8cnFGj",
        "outputId": "9693d02e-b2c8-4eaf-fbff-006e50d291d2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Dicionário vazio:  {}\n",
            "Exemplo de dicionário:  {'BRA': 'Brasil', 'EUA': 'Estados Unidos', 'FRA': 'França'}\n",
            "Tipo de um dicionário:  <class 'dict'>\n",
            "Exemplo de dicionário:  Brasil\n"
          ]
        }
      ],
      "source": [
        "dicionario_vazio = {}\n",
        "print(\"Dicionário vazio: \", dicionario_vazio)\n",
        "\n",
        "paises = {'BRA': 'Brasil', 'EUA': 'Estados Unidos', 'FRA': 'França'}\n",
        "print(\"Exemplo de dicionário: \", paises)\n",
        "\n",
        "print(\"Tipo de um dicionário: \", type(paises))\n",
        "\n",
        "print(\"Exemplo de dicionário: \", paises[\"BRA\"])\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RIWUKd36psyH",
        "outputId": "01776bd4-16d4-47d2-b98d-b249cbad8f8f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "este é meu dicionario{'k1': [1, 2, 3, 4], 'k2': ['casa', 'praia', 'rua']}\n",
            "ele possuem 2 itens que sao : este primeiro item[1, 2, 3, 4]\n",
            "este sedundo item do dicionario['casa', 'praia', 'rua']\n",
            "CASA\n"
          ]
        }
      ],
      "source": [
        "#utilizaçao de formatting with string and concatenation\n",
        "dictionarie={\"k1\":[1,2,3,4],\"k2\":[\"casa\",\"praia\",\"rua\"]}\n",
        "\n",
        "other_list=dictionarie[\"k1\"]\n",
        "\n",
        "espaço_list=dictionarie[\"k2\"]\n",
        "\n",
        "print(\"este é meu dicionario{d}\".format(d=dictionarie)+'\\n'+\"ele possuem 2 itens que sao : este primeiro item{um}\".format(um=other_list)\n",
        "\n",
        "+'\\n'+ \"este sedundo item do dicionario{dois}\".format(dois=espaço_list))\n",
        "\n",
        "lista_lugar=dictionarie[\"k2\"][0].upper()\n",
        "print(lista_lugar)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MQOEHnVKoRF9"
      },
      "outputs": [],
      "source": [
        "del dictionarie['k2']; # remove entry with key 'k2'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dy53jjFqjAq0"
      },
      "outputs": [],
      "source": [
        "d={\"v1\":100,\"v2\":200}\n",
        "d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cFncQSRfjAg-"
      },
      "outputs": [],
      "source": [
        "d[\"v3\"]=300\n",
        "d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LEJ8CNHzEMRJ"
      },
      "outputs": [],
      "source": [
        "d[\"v4\"]={\"inside key \":200}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IOqcboReEMBw"
      },
      "outputs": [],
      "source": [
        "i=0\n",
        "for i  in d.values():\n",
        "  print(i)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2B-4GIGmhFai"
      },
      "source": [
        "# Modularizaçao ou Def //functions\n",
        "####A function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bf3MxE4aWaSQ"
      },
      "outputs": [],
      "source": [
        "#funçoes sao definidas sao palavra reservada def\n",
        "#Functions are considered as the building blocks of any programming language."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RJtlGoUiwgRj",
        "outputId": "42a2cbd6-0c0c-4123-aaf1-14c2fe71e645"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "informe o seu nome6\n",
            "hii6\n"
          ]
        }
      ],
      "source": [
        "def hi(x):\n",
        "  print(\"Ola\"+str(x)+\"seja bem vindo\")\n",
        "hi(input(\"informe o seu nome\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wGe7yThHBOXa",
        "outputId": "90db07e4-6953-4543-be8b-6afd44579987"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8\n"
          ]
        }
      ],
      "source": [
        "def soma(x,y):\n",
        "  return x+y;\n",
        "\n",
        "print(soma(2,6))\n",
        "#aqui temos uma funçao com input"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UDXJaXPQpbdp"
      },
      "outputs": [],
      "source": [
        "# Outro exemplo de função que retorna um valor.\n",
        "def eleva_ao_quadrado(n):\n",
        "    return n ** 2\n",
        "\n",
        "print(\"O número {} elevado ao quatrado é {}\".format(10, eleva_ao_quadrado(10)))\n",
        "#aqui temos um output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j93oQv45l2MU",
        "outputId": "d3227cf7-351f-4adb-b929-26b1d40d4ff9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "20 4 12\n"
          ]
        }
      ],
      "source": [
        "def foo(a, b=4, c=6):\n",
        "    print(a, b, c)\n",
        "\n",
        "foo(20, c=12)\n",
        "#aqui temos uma funçao com input"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4u--Bz5CsLjG",
        "outputId": "5ddf4777-7c8c-4c51-9c42-d27b0f86805c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "22\n",
            "13\n",
            "6\n",
            "9\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "def soma(*args):\n",
        "    resultado = 0\n",
        "    for numero  in args:\n",
        "        resultado += numero\n",
        "    return resultado\n",
        "\n",
        "\n",
        "def main():\n",
        "    print(soma(4,7,11))\n",
        "\n",
        "    print(soma(8,4,1))\n",
        "\n",
        "    print(soma(4,2))\n",
        "\n",
        "    print(soma(2,2,5))\n",
        "print(main())\n",
        "    #ai é quando nos entendemos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kD7-RB7LsO2q",
        "outputId": "4683cff0-5279-4ce6-b0b6-460f0308864c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ja passamos por trabalho\n",
            "ja passamos por praia\n",
            "ja passamos por estudo\n",
            "ja passamos por cidade\n",
            "ja passamos por fazenda\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "def visitar(*lugares):\n",
        "  for canto in lugares:\n",
        "    print(f\"ja passamos por {canto}\")\n",
        "\n",
        "def main():\n",
        "  visitar(\"trabalho\",\"praia\",\"estudo\",\"cidade\",\"fazenda\")\n",
        "\n",
        "print(main())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        },
        "id": "A7WU0rmDVXGc",
        "outputId": "378482b3-0382-443e-c077-d294ec963ee9"
      },
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-20-1af7329437ff>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0ma_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma_variable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;31m#era pra dar um erro\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m#Variables created inside a function are\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'a_variable' is not defined"
          ]
        }
      ],
      "source": [
        "def a_function(a_parameter):\n",
        "    a_variable = 15\n",
        "    return a_parameter\n",
        "\n",
        "a_function(10)\n",
        "\n",
        "print(a_variable)\n",
        "#aqui da um erro ja que temos um comando fora do nossa funçao\n",
        "#deveriamos ter criado ela dentro no bloco da nossa funçao\n",
        "#aqui temos um output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tn14Z24OHpvF",
        "outputId": "3e4ead8a-6a26-40cb-f1da-dc06ffa4483e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "bruce\n",
            "bruce\n"
          ]
        }
      ],
      "source": [
        "def print_twice():\n",
        "  print(\"bruce\")\n",
        "  print(\"bruce\")\n",
        "print_twice()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-WJ8x6yEpbeX"
      },
      "outputs": [],
      "source": [
        "# Function definition is here\n",
        "def printme( str ):\n",
        "   \"This prints a passed string into this function\"\n",
        "   print (str)\n",
        "   return;\n",
        "\n",
        "# Now you can call printme function\n",
        "printme(\"fazendo a chamada  dessa funçao\")\n",
        "printme(\"chamando novamente a mesa funçao tambem podemos mandar outras coisas\")\n",
        "#aqui estamos chamando a mesma funçao duas vezes mas estamos passando diferentes parametros"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v94Id9zg49Rl",
        "outputId": "dbc42068-ebcd-41d6-e668-9eb561267fbc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "I'm a lumberjack, and I'm okay.\n",
            "I sleep all night and I work all day.\n",
            "I'm a lumberjack, and I'm okay.\n",
            "I sleep all night and I work all day.\n"
          ]
        }
      ],
      "source": [
        "def print_lyrics():\n",
        "\n",
        "   print(\"I'm a lumberjack, and I'm okay.\")\n",
        "   print('I sleep all night and I work all day.')\n",
        "\n",
        "def repeat_lyrics():\n",
        "  print_lyrics()\n",
        "  print_lyrics()\n",
        "repeat_lyrics()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NqRJXb1hRhkV",
        "outputId": "30eae530-fa1c-473e-da86-a6e8e52521a3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "6\n",
            "7\n",
            "12\n",
            "13\n",
            "20\n",
            "21\n",
            "30\n"
          ]
        }
      ],
      "source": [
        "def fuc ():\n",
        "  result=0\n",
        "  for k in range(0, 10):\n",
        "    if(( k % 2 ) == 1 ):\n",
        "       result = result + k\n",
        "       print(result)\n",
        "    else:\n",
        "      result=result+1\n",
        "      print(result)\n",
        "\n",
        "fuc()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rXZp3wg9YVZL",
        "outputId": "d31fbfc5-5b20-4a96-f102-f221c4bb79b3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "email 1 : gmail.com, email 2 : outlook.com ,email 3 : hotmail.com\n"
          ]
        }
      ],
      "source": [
        "\n",
        "#modificamos o parametro que quebra do nosso string\n",
        "def get_mail(string):\n",
        "    li = list(string.split(\"@\"))\n",
        "    #pegamos a 2 parte da saber o tipo da fonte de email\n",
        "    return li[1]\n",
        "   #retornamos o tipo\n",
        "\n",
        "# Driver code\n",
        "mail = \"fefeNandez@gmail.com\"\n",
        "\n",
        "mail1= \"dodo12@outlook.com\"\n",
        "mail2= \"meialua24@hotmail.com\"\n",
        "print(\"email 1 : \"+get_mail(mail)+\", email 2 : \"+get_mail(mail1)+\" ,email 3 : \"+get_mail(mail2))\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Kj2CB7vxXYnM"
      },
      "outputs": [],
      "source": [
        "# Definição do dicionário de produtos e listas de itens\n",
        "produtos = {\n",
        "    \"Bebidas\": [\"coca\", \"cha mate\", \"agua\", \"chocolate quente\"],\n",
        "    \"Comida\": [\"bolo\", \"file com fritas\", \"chocolate\"],\n",
        "    \"Custo_Bebidas\": [5.0, 2.4, 0.5, 2],\n",
        "    \"Custo_Comida\": [10, 20, 5.3]\n",
        "}\n",
        "\n",
        "bebidas_list = produtos[\"Bebidas\"]\n",
        "alimentos_list = produtos[\"Comida\"]\n",
        "\n",
        "custoC_list = produtos[\"Custo_Comida\"]\n",
        "custoB_list = produtos[\"Custo_Bebidas\"]\n",
        "\n",
        "# Função para exibir os produtos disponíveis\n",
        "def exibir_produtos():\n",
        "    print(\"Produtos disponíveis:\")\n",
        "    print(\"Lista de Bebidas:\")\n",
        "    for i, bebida in enumerate(bebidas_list):\n",
        "        print(f\"{i + 1}. {bebida} - R${produtos['Custo_Bebidas'][i]:.2f}\")\n",
        "    print(\"Lista de Comida:\")\n",
        "    for i, comida in enumerate(alimentos_list):\n",
        "        print(f\"{i + 1}. {comida} - R${produtos['Custo_Comida'][i]:.2f}\")\n",
        "\n",
        "# Função para obter a posição do item na lista de bebidas\n",
        "def itemPosiçãoB(item):\n",
        "    achou = False\n",
        "    i = 0\n",
        "    while i < len(bebidas_list):\n",
        "        if bebidas_list[i] == item:\n",
        "            achou = True\n",
        "            break\n",
        "        i += 1\n",
        "    if achou:\n",
        "        return i\n",
        "    else:\n",
        "        return -1\n",
        "\n",
        "# Função para obter a posição do item na lista de alimentos\n",
        "def itemPosiçãoC(item):\n",
        "    achou = False\n",
        "    i = 0\n",
        "    while i < len(alimentos_list):\n",
        "        if alimentos_list[i] == item:\n",
        "            achou = True\n",
        "            break\n",
        "        i += 1\n",
        "    if achou:\n",
        "        return i\n",
        "    else:\n",
        "        return -1\n",
        "\n",
        "# Função para calcular o preço da bebida com base na quantidade\n",
        "def calcular_preço_bebida(posição):\n",
        "    qtd = int(input(\"Informe a quantidade do item que você deseja: \"))\n",
        "    valor = custoB_list[posição] * qtd\n",
        "    return valor\n",
        "\n",
        "# Função para calcular o preço da comida com base na quantidade\n",
        "def calcular_preço_comida(posição):\n",
        "    qtd = int(input(\"Informe a quantidade do item que você deseja: \"))\n",
        "    valor = custoC_list[posição] * qtd\n",
        "    return valor\n",
        "\n",
        "# Saudação inicial\n",
        "print(\"Seja bem-vindo à loja\")\n",
        "exibir_produtos()\n",
        "\n",
        "# Obtenção da opção do usuário\n",
        "opçãolista = int(input(\"Selecione 1 para selecionar algum item da lista de bebidas disponíveis\\nSelecione 2 para selecionar algum item da lista de alimentos disponíveis\\nSelecione 0 para sair do menu: \"))\n",
        "\n",
        "if opçãolista == 1:\n",
        "    escolhido = input(\"Informe por escrito qual o nome do item selecionado: \")\n",
        "    posição = itemPosiçãoB(escolhido)\n",
        "    if posição != -1:\n",
        "        totalB = calcular_preço_bebida(posição)\n",
        "        print(f\"O valor total para {escolhido} é: R${totalB:.2f}\")\n",
        "    else:\n",
        "        print(\"Item não encontrado na lista de bebidas.\")\n",
        "\n",
        "elif opçãolista == 2:\n",
        "    escolhido = input(\"Informe por escrito qual o nome do item selecionado: \")\n",
        "    posição = itemPosiçãoC(escolhido)\n",
        "    if posição != -1:\n",
        "        totalC = calcular_preço_comida(posição)\n",
        "        print(f\"O valor total para {escolhido} é: R${totalC:.2f}\")\n",
        "    else:\n",
        "        print(\"Item não encontrado na lista de alimentos.\")\n",
        "\n",
        "elif opçãolista == 0:\n",
        "    print(\"Obrigado por visitar nossa loja. Até logo!\")\n",
        "\n",
        "else:\n",
        "    print(\"Opção inválida. Por favor, selecione uma opção válida.\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nKBrXPk-IVlc"
      },
      "source": [
        "#MAP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        },
        "id": "KE6M7RpqF8PZ",
        "outputId": "236dc22b-e35b-4030-9579-201188db7a14"
      },
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-7-50440faea4df>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mvalue_more\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mMap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msoma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;31m#map to list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mvalue_more\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue_more\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'Map' is not defined"
          ]
        }
      ],
      "source": [
        "#pode ser utilizado para voce aplicar uma funçao que voce criou\n",
        "#a valores que voce tem interesse que sofram a açao da funçao e entao retorne algo\n",
        "#FUNÇAO MAP\n",
        "def soma(x):\n",
        "    return x+x\n",
        "value=[3,6,9,12]\n",
        "value_more=Map(soma,value)\n",
        "#map to list\n",
        "value_more=list(value_more)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S-dVp9osIYX1"
      },
      "source": [
        "#REDUCE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pQCCZwiDF8HH"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DYr3urQ6Ia4S"
      },
      "source": [
        "#ZIP\n",
        "COPILA MAIS DE UMA LISTA DURANTE UM LALI"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hA-DxP2MF79f"
      },
      "outputs": [],
      "source": [
        "#pode ser utilizado para interagir com mais de duas listas ao mesmo tempo\n",
        "#recebe como parametro lista e inputa tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EByer1cTrKdx"
      },
      "source": [
        "#Vetores\n",
        "[*array*](https://numpy.org/doc/stable/user/basics.creation.html)\n",
        "\n",
        "[index](https://thispointer.com/find-the-index-of-a-value-in-numpy-array/)\n",
        "\n",
        "---\n",
        "\n",
        "o array é mutavel e seus items sao do mesmo tipo de dado sempre"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Jsu1tDrRA-ZT"
      },
      "outputs": [],
      "source": [
        "a = np.array([2, 3, 4, 5, 6,10,15, 45, 67, 34])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l1hbp5zcIjMj",
        "outputId": "5b05d0cb-96e2-470b-fd4a-72361e7490ca"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a.size"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sq7iIhalI__O",
        "outputId": "242aed34-10c3-468f-95eb-d6d4ef418032"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tuple of arrays returned :  (array([6]),)\n",
            "Elements with value 15 exists at following indices\n",
            "[6]\n"
          ]
        }
      ],
      "source": [
        "result = np.where(a == 15)\n",
        "print('retorno do array e posiçao : ', result)\n",
        "print(\"retornando a possiçao onde o elemento de valor 15 é encontrato \", result[0], sep='\\n')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xtr9-sATKCvA",
        "outputId": "4d9b11e6-ddef-4708-825d-56ba65335b95"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#cria um vetor que cresce regularmente /\n",
        "np.arange(10)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wOSOkjU6U4gX",
        "outputId": "c38ba39b-9494-48b4-f53d-3728d4a3b049"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0. , 1.6, 3.2, 4.8, 6.4, 8. ])"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#numpy.linspace criará arrays com um número especificado de elementos\n",
        "#e espaçado igualmente entre os valores inicial e final especificados.\n",
        "np.linspace(0., 8., 6)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HkHS5NkFhk_Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NCXCFO3PA-Sb"
      },
      "outputs": [],
      "source": [
        "#array de duas dimensoes\n",
        "a2D = np.array([[1, 2], [3, 4]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fEhcRPN_cOHb",
        "outputId": "8f786036-797d-4e86-9ef0-95b63805b84a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 0., 0., 0.],\n",
              "       [0., 1., 0., 0.],\n",
              "       [0., 0., 1., 0.],\n",
              "       [0., 0., 0., 1.]])"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#esse exemplo é uma matriz identidade\n",
        "#onde quando i=j sera igual a 1(linha coluna)\n",
        "np.eye(4, 4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 226
        },
        "id": "DIiQdk7bapv_",
        "outputId": "5abacaaa-8c1e-49b2-8fde-9149c7f4b0d9"
      },
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-ac3e86931278>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0marr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0marr\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwhere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
          ]
        }
      ],
      "source": [
        "a = np.array([10,11,12,13,14,15,16,17,18,,19,20])\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O7eZKeJPpQZw"
      },
      "outputs": [],
      "source": [
        "\n",
        "import numpy as np\n",
        "\n",
        "# create numpy array elements\n",
        "a = np.array([2, 3, 4, 5, 6, 45, 67, 34])\n",
        "\n",
        "# display element index where value = 45\n",
        "\n",
        "index_of_element = -1\n",
        "for i in range(a.size):\n",
        "    if a[i] == 45:\n",
        "        index_of_element = i\n",
        "        break\n",
        "\n",
        "if index_of_element != -1:\n",
        "    print(\"element index  : \", index_of_element)\n",
        "else:\n",
        "    print(\"The element not present\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Jh0dJjakNlgY"
      },
      "outputs": [],
      "source": [
        "#as tuplas sao um tipo especial de array que armazena diferentes tipos de data na mesma coleçao\n",
        "#enquanto o array precisa ser do mesmo tipo de dado e sao mutaveis"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tQ4rL-0XE_y-"
      },
      "source": [
        "#Tuples ou tuplas\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "####nao podem ser modificadas/sao imutaveis\n",
        "####pode fazer o wap = é a troca dos valores de duas variáveis da tupla\n",
        "####Entretanto, ela não é completamente imutável, pois quando armazena outro\n",
        "####nao  aceitam muitos metodos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AgNkp_GqE24A",
        "outputId": "2143a3a9-729d-40e4-e701-4e7bc14c04b7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "certo\n"
          ]
        }
      ],
      "source": [
        "a = [1, 4, 3]\n",
        "b = [3, 2, 2]\n",
        "\n",
        "def store_original_ids():\n",
        "    a = [1, 4, 3]\n",
        "    b = [3, 2, 2]\n",
        "\n",
        "store_original_ids()\n",
        "#aqui tempos um SWAP\n",
        "temp =b\n",
        "b=a\n",
        "a=temp\n",
        "#que tambem poderia ser resolvido assim\n",
        "\n",
        "##a, b = a, b\n",
        "\n",
        "def check():\n",
        "     if a==[3, 2, 2] and b ==[1, 4, 3] :\n",
        "            print('certo')\n",
        "\n",
        "check()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HDklaaFoO5ZI"
      },
      "outputs": [],
      "source": [
        "Estados = namedtuple('Estados', ['sigla', 'nome'])\n",
        "estado_pe = Estados('PE', 'Recife')\n",
        "estado_pe"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IXFP_vg3uiLw"
      },
      "outputs": [],
      "source": [
        "Estados(sigla='PE', nome='recife')\n",
        "print(estado_pe.sigla)\n",
        "print(estado_pe.nome)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rYKpz1hZO529"
      },
      "outputs": [],
      "source": [
        "#devemos  usar uma 3 variavel para fazer o wap funcionar corretamente\n",
        "#caso contrario um dos valores das variaveis sera perdido\n",
        "#observe abaixo:\n",
        "coordenada_xy = (10, 20)\n",
        "x, y = coordenada_xy\n",
        "temp=x   # 10\n",
        "x=y      # 20\n",
        "y=temp   # 10\n",
        "#portanto usamos a variavel temp para armazena o valor de x antes dele ser modificado/substituido por um novo valor\n",
        "print(\"valor de variavel  x : \"+str(x)+   \"\\n\"\n",
        "     +\"valor de variavel  y : \"+ str(y) + \"\\n\"\n",
        "    + \"valor de variavel temp : \"+ str(temp))\n",
        "#para usar esses valores que conhecemos precisamos colocar eles como se fossem string"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ho1Ojn1YO5tR"
      },
      "outputs": [],
      "source": [
        "# Swap com tuplas.\n",
        "print(\"x e y antes do swap: \", x, y)\n",
        "\n",
        "x, y = y, x\n",
        "\n",
        "print(\"x e y depois do swap: \", x, y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "37akH_CXvNFy",
        "outputId": "ccd36ddf-34c2-4c5d-dc4a-e5832f5fe4b6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n",
            "1\n",
            "3\n"
          ]
        }
      ],
      "source": [
        "tupla_nomes = ('Giordano', 'Paulo', 'Lucas', 'João', 'Felipe')\n",
        "#se o elemento esta na tupla\n",
        "print('Giordano' in tupla_nomes)\n",
        "\n",
        "print('Paulo' in tupla_nomes)\n",
        "\n",
        "print (tupla_nomes.count('Lucas')) #< possui unica vez o nome lucas\n",
        "\n",
        "print(tupla_nomes.index(\"João\"))# retorna a posiçao na tupla"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j0-554BOO5kE"
      },
      "outputs": [],
      "source": [
        "# tupla com apenas um elemento\n",
        "#nao precisa usar sempre ()\n",
        "tupla_elemento = 10,\n",
        "tupla_elemento\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o-bshhXUypAv"
      },
      "outputs": [],
      "source": [
        "nick=(\"n\",\"i\",\"n\",\"a\")\n",
        "\n",
        "nick.index(\"n\")#retorna a vez q aparece primeiro"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bCbGJgLvx5GO"
      },
      "outputs": [],
      "source": [
        "name_1=(\"m\",\"a\",\"r\",\"i\",\"a\",\"n\",\"a\")\n",
        "\n",
        "print(name_1.index(\"n\"))#retorna a vez q aparece primeiro\n",
        "\n",
        "print(name_1.index(\"a\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PMpOJGKgZkQJ"
      },
      "source": [
        "#Matrizes-FALTA CONTINUAR\n",
        "######sao criadas a partir de uma lista com varias dimensoes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gI-U4_2LA-Dx"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zNNN3AocA-BS"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o7yiwcczA9xq"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PBTvF5G_WMtH"
      },
      "source": [
        "#SETS- FALTA CONTINUAR\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ibFdcVmq8rG5",
        "outputId": "0a567f4d-5807-4c37-cd64-6fedefb592a6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{1, 2, 3}\n"
          ]
        }
      ],
      "source": [
        "myset=set()\n",
        "myset.add(1)\n",
        "myset.add(3)\n",
        "myset.add(2)\n",
        "myset.add(3)\n",
        "print(myset)\n",
        "#ver mas coisas o Sets em python\n",
        "#valores unicos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OeiN9TMCqapo",
        "outputId": "17033194-f575-46a5-dafd-645453ec8aae"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "set"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type(myset)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sc40xCIVCvIO"
      },
      "source": [
        "#args"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UAVGmXm_CyB1"
      },
      "outputs": [],
      "source": [
        "#*Args permite você passar um número indeterminado de parâmetros para uma função.\n",
        "# Os argumentos são passados por posição, ou seja, sem nenhuma chave que os identifique.\n",
        "#A identificação depende apenas da posição em que o parâmetro é passado."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cp37EgTH0nr_"
      },
      "source": [
        "#Tratamento de exceçoes\n",
        "#####https://docs.python.org/3/library/exceptions.html\n",
        "#####https://www.tutorialspoint.com/python-exception-base-classes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vNTJBgpGxRqt"
      },
      "outputs": [],
      "source": [
        "lista1=[1,10]\n",
        "try:\n",
        "  divisao=10/1               #se for 10/0 da o erro\n",
        "  num1=lista1[1]             #se for 3 da o erro\n",
        "\n",
        "except ZeroDivisionError:\n",
        "  print(\"nao é possivel realizar uma divisao por 0\")\n",
        "except IndexError:\n",
        "  print(\"error ao acessar um indice invalido da lista\")\n",
        "else :\n",
        "  print(\"nao houve nenhuma exception\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9A9Fcx8oxRfT"
      },
      "outputs": [],
      "source": [
        "#outra maneira de ligar com esse tipo de erro de atribuiçao e outros erros tambem\n",
        "#todas as exception tem pai e tem filho\n",
        "try:\n",
        "  x=a\n",
        "except BaseException as ex:\n",
        "  print('erro desconhecido. Error :{}'.format(ex))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oMosRG3c06m7"
      },
      "source": [
        "#Leitura de arquivo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iOjwgO3_06D-",
        "outputId": "51460554-04af-4e15-b9d2-982966312872"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "a luz do sol entra pela janela,clareado o ambiente\n",
            "o calor que tinha antes dentro do quarto se dissipa com a forte rajada de vento que sai pela janela.\n",
            "os fios castanhos ganham sutis tons avermelhados e alaranjados,o rosto palido se torna levemente rosado \n",
            "os cachos mesmo ainda pequenos sao bonitos e combinam com o garoto\n",
            "ele nao se encolhe com o frio que começa a tomar conta do quarto com o passar do tempo.\n",
            "ele continua perto da janela observando o ceu\n",
            "admirado talvez com o branco do ceu  ou talvez apreciando o barulho da chuva ou ate mesmo observando o temporal que acontece la fora.\n",
            "apesar de cantarolar e de dançar pela casa com frequencia ele nao costumava conversa sozinho e tambem nao andava fazendo barulho.\n",
            "os olhos continuavam fixos na janela mesmo apos a queda de algum objeto no andar de baixo da casa\n",
            "nos viviamos naquela casa ja se tinha 5 anos e mesmo assim eu so o via raramente pele casa \n",
            "mas todos sabiam dos passos de dança pela cozinha,foi por causa dele que fiquei de castigo por duas semanas apos ele esquecer o arroz no fogo\n",
            "nao so eu fiquei como todos que estavam na cozinha aquele dia..\n",
            "\n",
            "links:\n",
            "https://guiarails.com.br/security.html\n",
            "https://dev.to/leandronsp/web-basics-a-tcp-server-in-ruby-947\n",
            "https://medium.com/rubycademy/how-network-programming-is-represented-in-ruby-bed554256648\n",
            "\n",
            "https://jzolotarev.medium.com/on-the-rails-c8c4721fd55a\n",
            "https://www.bluleadz.com/blog/http-vs-https-understanding-the-difference-picking-the-best-option-for-your-website\n",
            "https://www.treinaweb.com.br/blog/o-que-e-ruby-on-rails\n",
            "https://prograils.com/top-10-famous-sites-built-with-ruby-on-rails\n",
            "https://www.freecodecamp.org/news/understanding-the-basics-of-ruby-on-rails-http-mvc-and-routes-359b8d809c7a/\n",
            "https://devcenter.heroku.com/articles/getting-started-with-rails7\n",
            "https://medium.com/analytics-vidhya/deploy-ruby-on-rails-6-application-to-heroku-3d07a8d7428c\n",
            "https://guides.rubyonrails.org/routing.html\n",
            "https://www.youtube.com/watch?v=_-Dnys7_ESE&t=1s\n",
            "https://www.youtube.com/watch?v=EQcsD3ff14E&list=PLCC34OHNcOtoz3tvoN9uDkIAaDYqPqoEr\n",
            "https://www.youtube.com/watch?v=fmyvWz5TUWg&t=3160s\n",
            "https://tadhao.medium.com/everything-about-rails-router-cb82faa1b8a1\n",
            "\n",
            "-LENDO-LIDO\n",
            "https://www.devmedia.com.br/introducao-a-rotas-e-responders-no-ruby-on-rails/33521 < BOM,vale ler ate a parte de RESTful\n",
            "https://blog.skylight.io/the-lifecycle-of-a-request/< iniciando\n",
            "https://www.freecodecamp.org/news/understanding-the-basics-of-ruby-on-rails-http-mvc-and-routes-359b8d809c7a/ < lendo,logo no inicio tem conceitos basicos massa\n",
            "https://www.javatpoint.com/ruby-on-rails-router\n"
          ]
        }
      ],
      "source": [
        "arquivo = open('menino de cafe.txt', 'r') # <<funçao open para abrir o arquivoe o 'r' para indicar leitura\n",
        "##issso é um handle\n",
        "conteudo = arquivo.read() #aqui lemos o arquivo e passamos o conteudo do arquivo para variavel conteudo\n",
        "print(conteudo)\n",
        "#o arquivo precisa ser carregado em arquivos\n",
        "#https://youtu.be/Fo1tW09KIwo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_rKJkaN36cvJ",
        "outputId": "6adee628-2917-491b-cd6e-2b4ffe562fe8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "a luz do sol entra pela janela,clareado o ambiente\n",
            "\n",
            "o calor que tinha antes dentro do quarto se dissipa com a forte rajada de vento que sai pela janela.\n",
            "\n",
            "os fios castanhos ganham sutis tons avermelhados e alaranjados,o rosto palido se torna levemente rosado \n",
            "\n",
            "os cachos mesmo ainda pequenos sao bonitos e combinam com o garoto\n",
            "\n",
            "ele nao se encolhe com o frio que começa a tomar conta do quarto com o passar do tempo.\n",
            "\n",
            "ele continua perto da janela observando o ceu\n",
            "\n",
            "admirado talvez com o branco do ceu  ou talvez apreciando o barulho da chuva ou ate mesmo observando o temporal que acontece la fora.\n",
            "\n",
            "apesar de cantarolar e de dançar pela casa com frequencia ele nao costumava conversa sozinho e tambem nao andava fazendo barulho.\n",
            "\n",
            "os olhos continuavam fixos na janela mesmo apos a queda de algum objeto no andar de baixo da casa\n",
            "\n",
            "nos viviamos naquela casa ja se tinha 5 anos e mesmo assim eu so o via raramente pele casa \n",
            "\n",
            "mas todos sabiam dos passos de dança pela cozinha,foi por causa dele que fiquei de castigo por duas semanas apos ele esquecer o arroz no fogo\n",
            "\n",
            "nao so eu fiquei como todos que estavam na cozinha aquele dia..\n",
            "\n",
            "\n",
            "\n",
            "links:\n",
            "\n",
            "https://guiarails.com.br/security.html\n",
            "\n",
            "https://dev.to/leandronsp/web-basics-a-tcp-server-in-ruby-947\n",
            "\n",
            "https://medium.com/rubycademy/how-network-programming-is-represented-in-ruby-bed554256648\n",
            "\n",
            "\n",
            "\n",
            "https://jzolotarev.medium.com/on-the-rails-c8c4721fd55a\n",
            "\n",
            "https://www.bluleadz.com/blog/http-vs-https-understanding-the-difference-picking-the-best-option-for-your-website\n",
            "\n",
            "https://www.treinaweb.com.br/blog/o-que-e-ruby-on-rails\n",
            "\n",
            "https://prograils.com/top-10-famous-sites-built-with-ruby-on-rails\n",
            "\n",
            "https://www.freecodecamp.org/news/understanding-the-basics-of-ruby-on-rails-http-mvc-and-routes-359b8d809c7a/\n",
            "\n",
            "https://devcenter.heroku.com/articles/getting-started-with-rails7\n",
            "\n",
            "https://medium.com/analytics-vidhya/deploy-ruby-on-rails-6-application-to-heroku-3d07a8d7428c\n",
            "\n",
            "https://guides.rubyonrails.org/routing.html\n",
            "\n",
            "https://www.youtube.com/watch?v=_-Dnys7_ESE&t=1s\n",
            "\n",
            "https://www.youtube.com/watch?v=EQcsD3ff14E&list=PLCC34OHNcOtoz3tvoN9uDkIAaDYqPqoEr\n",
            "\n",
            "https://www.youtube.com/watch?v=fmyvWz5TUWg&t=3160s\n",
            "\n",
            "https://tadhao.medium.com/everything-about-rails-router-cb82faa1b8a1\n",
            "\n",
            "\n",
            "\n",
            "-LENDO-LIDO\n",
            "\n",
            "https://www.devmedia.com.br/introducao-a-rotas-e-responders-no-ruby-on-rails/33521 < BOM,vale ler ate a parte de RESTful\n",
            "\n",
            "https://blog.skylight.io/the-lifecycle-of-a-request/< iniciando\n",
            "\n",
            "https://www.freecodecamp.org/news/understanding-the-basics-of-ruby-on-rails-http-mvc-and-routes-359b8d809c7a/ < lendo,logo no inicio tem conceitos basicos massa\n",
            "\n",
            "https://www.javatpoint.com/ruby-on-rails-router\n",
            "temos o total de 36 linhas no nosso texto\n"
          ]
        }
      ],
      "source": [
        "sequence=open('menino de cafe.txt', 'r')\n",
        "count=0\n",
        "for linetoline in sequence :\n",
        "  count=count+1\n",
        "  print(linetoline)\n",
        "#forma elegante\n",
        "print(\"temos o total de \"+str(count)+\" linhas no nosso texto\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Qah0tWs6crT",
        "outputId": "c408cdf2-4db3-4e5d-ec58-72a91bef7d1b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2585\n",
            "a luz do sol\n"
          ]
        }
      ],
      "source": [
        "arquivo = open('menino de cafe.txt', 'r') # <<funçao open para abrir o arquivoe o 'r' para indicar leitura\n",
        "##issso é um handle\n",
        "conteudo = arquivo.read() #aqui lemos o arquivo e passamos o conteudo do arquivo para variavel conteudo\n",
        "print(len(conteudo))##chacracter\n",
        "print(conteudo[:12])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2AGKkWjsdHsY",
        "outputId": "3c1bedb4-0243-4d48-e051-43037b018d6a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "fechando o arquivo\n"
          ]
        }
      ],
      "source": [
        "\n",
        "try:\n",
        "  arquivo = open('menino de cafe.txt', 'r')\n",
        "  texto = arquivo.read()\n",
        "finally:\n",
        "  print(\"fechando o arquivo\")\n",
        "  at=arquivo.close()\n",
        "  #Utilizamos o Finally nesse caso para que independente que aja erro ou nao\n",
        "  #ocorra o fechamento do arquivo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "8EMPsvoP6cpr",
        "outputId": "5f86ce9a-e68e-4781-c813-605e87e1985a"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content'"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "pwd"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sAnV484g6cl1"
      },
      "outputs": [],
      "source": [
        "#O método de arquivo Python seek() define a posição atual do arquivo no deslocamento.\n",
        "#O argumento wherece é opcional e o padrão é 0, o que significa posicionamento absoluto do arquivo,\n",
        "#outros valores são 1, o que significa busca em relação à posição atual e 2 significa busca em relação ao final do arquivo.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wt07EjLY6ccG"
      },
      "outputs": [],
      "source": [
        "#aqui temos outra forma de ler e exibir o arquivo\n",
        "x = open('test.txt', 'w')\n",
        "x.write('This is my file')\n",
        "x.close()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xrSGNRhkZ9Yi"
      },
      "outputs": [],
      "source": [
        "#aqui estamos escrevendo dentro do arquivo\n",
        "with open('test.txt', 'w') as doc_Escrita:\n",
        "    doc_Escrita.write(\"This is line A\\n\")\n",
        "    doc_Escrita.write(\"This is line B\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 200
        },
        "id": "CTAGejvVaWXo",
        "outputId": "0b6b0d93-3ea5-44f9-eb3b-d70c5fd229c8"
      },
      "outputs": [
        {
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-7-8d25de12182b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#neste aqui adicionamos uma linha ao texto\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/resources/data/Example2.txt'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'a'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mtestwritefile\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mtestwritefile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"This is line C\\n\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/resources/data/Example2.txt'"
          ]
        }
      ],
      "source": [
        "#neste aqui adicionamos uma linha ao texto\n",
        "with open('/resources/data/Example2.txt', 'a') as testwritefile:\n",
        "    testwritefile.write(\"This is line C\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p95zX_GYa40x",
        "outputId": "441df896-fe4e-48d3-87a8-0c19210727e5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Doubt thou, the stars are fire \n",
            "\n",
            "Doubt, that the sun doth move \n",
            "\n",
            "Doubt truth to be a liar \n",
            "\n",
            "But never doubt I love \n",
            "\n"
          ]
        }
      ],
      "source": [
        "# linhas para ser colocadas no arquivo do tipo txt\n",
        "\n",
        "Lines = [\"Doubt thou, the stars are fire \\n\", \"Doubt, that the sun doth move \\n\", \"Doubt truth to be a liar \\n\",\"But never doubt I love \\n\"]\n",
        "Lines\n",
        "\n",
        "# escrita das linhas no arquivo\n",
        "\n",
        "with open('Example2.txt', 'w') as writefile:\n",
        "    for line in Lines:\n",
        "        print(line)\n",
        "        writefile.write(line)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dJxWIC8MJ4ie"
      },
      "outputs": [],
      "source": [
        "#procurar saber mais sobre mode  para trabalhar com arquivos  como 'r+'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B6JkvJVbS-sK"
      },
      "source": [
        "#FLASK utilizaçao para web"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ESTxhA3UTCy2",
        "outputId": "1fa63e29-928f-45fc-df9c-df40eadeb72d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting flask-ngrok\n",
            "  Downloading flask_ngrok-0.0.25-py3-none-any.whl (3.1 kB)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (from flask-ngrok) (2.25.1)\n",
            "Requirement already satisfied: Flask>=0.8 in /usr/local/lib/python3.8/dist-packages (from flask-ngrok) (1.1.4)\n",
            "Requirement already satisfied: itsdangerous<2.0,>=0.24 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-ngrok) (1.1.0)\n",
            "Requirement already satisfied: click<8.0,>=5.1 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-ngrok) (7.1.2)\n",
            "Requirement already satisfied: Jinja2<3.0,>=2.10.1 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-ngrok) (2.11.3)\n",
            "Requirement already satisfied: Werkzeug<2.0,>=0.15 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-ngrok) (1.0.1)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests->flask-ngrok) (2.10)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests->flask-ngrok) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests->flask-ngrok) (2022.12.7)\n",
            "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests->flask-ngrok) (4.0.0)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.8/dist-packages (from Jinja2<3.0,>=2.10.1->Flask>=0.8->flask-ngrok) (2.0.1)\n",
            "Installing collected packages: flask-ngrok\n",
            "Successfully installed flask-ngrok-0.0.25\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting flask-bootstrap\n",
            "  Downloading Flask-Bootstrap-3.3.7.1.tar.gz (456 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m456.4/456.4 KB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: Flask>=0.8 in /usr/local/lib/python3.8/dist-packages (from flask-bootstrap) (1.1.4)\n",
            "Collecting dominate\n",
            "  Downloading dominate-2.7.0-py2.py3-none-any.whl (29 kB)\n",
            "Collecting visitor\n",
            "  Downloading visitor-0.1.3.tar.gz (3.3 kB)\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: itsdangerous<2.0,>=0.24 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-bootstrap) (1.1.0)\n",
            "Requirement already satisfied: click<8.0,>=5.1 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-bootstrap) (7.1.2)\n",
            "Requirement already satisfied: Werkzeug<2.0,>=0.15 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-bootstrap) (1.0.1)\n",
            "Requirement already satisfied: Jinja2<3.0,>=2.10.1 in /usr/local/lib/python3.8/dist-packages (from Flask>=0.8->flask-bootstrap) (2.11.3)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.8/dist-packages (from Jinja2<3.0,>=2.10.1->Flask>=0.8->flask-bootstrap) (2.0.1)\n",
            "Building wheels for collected packages: flask-bootstrap, visitor\n",
            "  Building wheel for flask-bootstrap (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for flask-bootstrap: filename=Flask_Bootstrap-3.3.7.1-py3-none-any.whl size=460123 sha256=25319ee76faadc4248848e94c2b987fc2b2799acd8081c924f017d44f2132296\n",
            "  Stored in directory: /root/.cache/pip/wheels/f2/a3/85/fe8b65a65a447c9906e3b7edb7d9e6c74dfa9c8425c3dd3007\n",
            "  Building wheel for visitor (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for visitor: filename=visitor-0.1.3-py3-none-any.whl size=3943 sha256=a983ffa1d9c564a501331a8a1c0025c145eace2bc1fe876ce157205544974eff\n",
            "  Stored in directory: /root/.cache/pip/wheels/d3/40/52/5dae7760434a82caf8b8f88323029188b2d4ea3ac1235e550a\n",
            "Successfully built flask-bootstrap visitor\n",
            "Installing collected packages: visitor, dominate, flask-bootstrap\n",
            "Successfully installed dominate-2.7.0 flask-bootstrap-3.3.7.1 visitor-0.1.3\n"
          ]
        }
      ],
      "source": [
        "!pip install flask-ngrok\n",
        "!pip install flask-bootstrap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ijpdHwnAXAJ3"
      },
      "outputs": [],
      "source": [
        "from flask_ngrok import run_with_ngrok\n",
        "from flask import Flask, render_template , request\n",
        "import os\n",
        "\n",
        "#criaçao da instancia\n",
        "app = Flask(__name__)\n",
        "\n",
        "@app.route(\"/\")\n",
        "def hello_world():\n",
        "    return \"<p>Hello, World!</p>\""
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "REDES NEURAIS\n",
        "https://medium.com/geekculture/understanding-the-basics-of-neural-networks-for-beginners-9c26630d08\n",
        "https://machinelearningmastery.com/implement-perceptron-algorithm-scratch-python/\n",
        "https://www.simplilearn.com/tutorials/deep-learning-tutorial/neural-network\n"
      ],
      "metadata": {
        "id": "iON51fPHBCH6"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Bwkt1psWBCej"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "SW9Hr3hXBDDz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "AmP6Vwk5BC1K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#criando arquivos aparti deste"
      ],
      "metadata": {
        "id": "veL3Yb0oZFYO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import nbformat\n",
        "\n",
        "# Caminho para o arquivo do notebook\n",
        "file_path = \"/mnt/data/ESTUDO_DE_PYTHON_.ipynb\"\n",
        "\n",
        "# Carregando o notebook\n",
        "with open(file_path, \"r\", encoding=\"utf-8\") as file:\n",
        "    notebook = nbformat.read(file, as_version=4)\n",
        "\n",
        "# Verificando as seções (células) do notebook\n",
        "notebook_cells = notebook.cells\n",
        "len(notebook_cells), notebook_cells[0], notebook_cells[-1]\n"
      ],
      "metadata": {
        "id": "BUXq77YdZIvd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Função para criar um novo notebook com um subconjunto de células\n",
        "def create_notebook(cells, path):\n",
        "    new_notebook = nbformat.v4.new_notebook()\n",
        "    new_notebook.cells = cells\n",
        "    with open(path, 'w', encoding='utf-8') as f:\n",
        "        nbformat.write(new_notebook, f)\n",
        "\n",
        "# Dividindo as células em três partes\n",
        "part1_cells = notebook_cells[:76]\n",
        "part2_cells = notebook_cells[76:152]\n",
        "part3_cells = notebook_cells[152:]\n",
        "\n",
        "# Caminhos para os novos arquivos\n",
        "part1_path = \"/mnt/data/ESTUDO_DE_PYTHON_part1.ipynb\"\n",
        "part2_path = \"/mnt/data/ESTUDO_DE_PYTHON_part2.ipynb\"\n",
        "part3_path = \"/mnt/data/ESTUDO_DE_PYTHON_part3.ipynb\"\n",
        "\n",
        "# Criando os novos notebooks\n",
        "create_notebook(part1_cells, part1_path)\n",
        "create_notebook(part2_cells, part2_path)\n",
        "create_notebook(part3_cells, part3_path)\n",
        "\n",
        "part1_path, part2_path, part3_path\n"
      ],
      "metadata": {
        "id": "ihVx3DA-ZL8E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mknWkaZzC4NF"
      },
      "source": [
        "#referencia :"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GiDKDbyf-OoP"
      },
      "outputs": [],
      "source": [
        "#referencia\n",
        "# https://www.geeksforgeeks.org/try-except-else-and-finally-in-python/\n",
        "# https://www.freecodecamp.org/news/learning-python-from-zero-to-hero-120ea540b567/\n",
        "# https://algoritmosempython.com.br/cursos/programacao-python/listas/\n",
        "# https://www.youtube.com/watch?v=t8pPdKYpowI\n",
        "# https://www.youtube.com/watch?v=rfscVS0vtbw\n",
        "# https://www.w3schools.com/python/python_for_loops.asp\n",
        "# youtube.com/watch?v=kqtD5dpn9C8\n",
        "# https://youtu.be/Fo1tW09KIwo\n",
        "# https://algoritmosempython.com.br/cursos/programacao-python/entrada-saida/\n",
        "# https://www.youtube.com/watch?v=ax3kaDGa1YE\n",
        "# https://algoritmosempython.com.br/cursos/programacao-python/fluxo-controle/\n",
        "# https://algoritmosempython.com.br/cursos/programacao-python/tuplas/\n",
        "# https://blog.betrybe.com/tecnologia/tuplas-em-python/#:~:text=Boa%20leitura!-,O%20que%20%C3%A9%20tupla%3F,alterar%20ou%20remover%20seus%20elementos.\n",
        "# https://docs.python.org/3/tutorial/controlflow.html\n",
        "# https://pydatascience.org/data-science-cheatsheets/\n",
        "# https://programmingwithmosh.com/wp-content/uploads/2019/02/Python-Cheat-Sheet.pdf\n",
        "# https://www.youtube.com/watch?v=u-OmVr_fT4s\n",
        "# https://github.com/Pierian-Data/Complete-Python-3-Bootcamp\n",
        "# https://projecteuler.net/archives\n",
        "# http://codingbat.com/python\n",
        "# https://www.tutorialspoint.com/python-exception-base-classes\n",
        "# https://docs.python.org/3/library/exceptions.html\n",
        "#https://www.geeksforgeeks.org/python-math-function-sqrt/\n",
        "# 2022 Complete Python Bootcamp From Zero to Hero in Python\n",
        "# https://www.techtudo.com.br/noticias/2018/10/o-que-sao-cookies-entenda-os-dados-que-os-sites-guardam-sobre-voce.ghtml\n",
        "# https://www.freecodecamp.org/learn/scientific-computing-with-python/python-for-everybody/build-your-own-functions\n",
        "# https://www.tutorialspoint.com/python/python_functions.htm\n",
        "# https://www.tutorialspoint.com/python/python_break_statement.htm\n",
        "# https://towardsdatascience.com/how-to-make-goodreads-com-top-400-list-8e3a26e509bf\n",
        "# https://www.sqlshack.com/understanding-args-and-kwargs-arguments-in-python/\n",
        "# https://cadernodelaboratorio.com.br/args-e-kwargs-o-que-significam-em-python/\n",
        "# file:///C:/Users/Dell/Documents/estudos/100%20dias%20com%20python/Python+Syntax+Cheat+Sheet+Booklet.pdf\n",
        "# https://stackoverflow.com/questions/4967580/how-to-get-the-size-of-a-string-in-python\n",
        "#  Replit pode ser usado tb para codar\n",
        "#https://www.youtube.com/watch?v=Ej_02ICOIgs\n",
        "#https://www.youtube.com/watch?v=XGf2GcyHPhc\n",
        "#https://www.youtube.com/watch?v=LHBE6Q9XlzI\n",
        "#https://www.youtube.com/watch?v=EsDFiZPljYo&list=PLWKjhJtqVAblvI1i46ScbKV2jH1gdL7VQ\n",
        "#https://www.youtube.com/watch?v=JeznW_7DlB0\n",
        "# https://www.tutorialspoint.com/python/python_date_time.htm\n",
        "# https://www.w3schools.com/python/ref_keyword_finally.asp\n",
        "#https://stackoverflow.com/questions/52345913/how-to-handle-wait-for-input-signal-in-python\n",
        "#https://stackabuse.com/getting-user-input-in-python/\n",
        "#https://docs.python.org/3/library/signal.html\n",
        "#https://www.linkedin.com/pulse/signal-processing-python-part-1-generate-signals-basic-hampiholi\n",
        "#https://colab.research.google.com/github/computationalcore/introduction-to-python/blob/master/notebooks/4-files/PY0101EN-4-2-WriteFile.ipynb#scrollTo=fFFgFOl00uqo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BybfMNgnn7Os"
      },
      "outputs": [],
      "source": [
        "#pessoas importantes na computaçao:\n",
        "# https://deepai.org/profile/sanjay-ghemawat\n",
        "# https://en.wikipedia.org/wiki/Sanjay_Ghemawat\n",
        "# https://pt.wikipedia.org/wiki/Dennis_Ritchie\n",
        "# https://horizontes.sbc.org.br/index.php/2021/12/dennis-m-ritchie-humildade-e-genialidade/\n",
        "# https://pt.wikipedia.org/wiki/Margaret_Hamilton_(cientista_da_computa%C3%A7%C3%A3o)\n",
        "# https://horizontes.sbc.org.br/index.php/2021/05/margaret-hamilton-mae-cientista-na-lideranca-do-apollo-11/\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}